zoukankan      html  css  js  c++  java

  • java 加密工具类（MD5、RSA、AES等加密方式）

    1.加密工具类encryption

    MD5加密

    [java] view plain copy print?
    1. import org.apache.commons.codec.digest.DigestUtils;  
    2.   
    3. /** 
    4.  * MD5加密组件 
    5.  *  
    6.  * @author wbw 
    7.  * @version 1.0 
    8.  * @since 1.0 
    9.  */  
    10. public abstract class MD5Util {  
    11.   
    12.     /** 
    13.      * MD5加密 
    14.      *  
    15.      * @param data 
    16.      *            待加密数据 
    17.      * @return byte[] 消息摘要 
    18.      *  
    19.      * @throws Exception 
    20.      */  
    21.     public static byte[] encodeMD5(String data) throws Exception {  
    22.   
    23.         // 执行消息摘要  
    24.         return DigestUtils.md5(data);  
    25.     }  
    26.   
    27.     /** 
    28.      * MD5加密 
    29.      *  
    30.      * @param data 
    31.      *            待加密数据 
    32.      * @return byte[] 消息摘要 
    33.      *  
    34.      * @throws Exception 
    35.      */  
    36.     public static String encodeMD5Hex(String data) {  
    37.         // 执行消息摘要  
    38.         return DigestUtils.md5Hex(data);  
    39.     }  
    40. }  

    AES加密:

    [java] view plain copy print?
    1. import javax.crypto.Cipher;  
    2. import javax.crypto.spec.SecretKeySpec;  
    3.   
    4. public class AESUtil {  
    5.   
    6.     private static final String KEY_AES = "AES";  
    7.   
    8.     public static String encrypt(String src, String key) throws Exception {  
    9.         if (key == null || key.length() != 16) {  
    10.             throw new Exception("key不满足条件");  
    11.         }   
    12.         byte[] raw = key.getBytes();  
    13.         SecretKeySpec skeySpec = new SecretKeySpec(raw, KEY_AES);  
    14.         Cipher cipher = Cipher.getInstance(KEY_AES);  
    15.         cipher.init(Cipher.ENCRYPT_MODE, skeySpec);  
    16.         byte[] encrypted = cipher.doFinal(src.getBytes());  
    17.         return byte2hex(encrypted);  
    18.     }  
    19.   
    20.     public static String decrypt(String src, String key) throws Exception {  
    21.         if (key == null || key.length() != 16) {  
    22.             throw new Exception("key不满足条件");  
    23.         }  
    24.         byte[] raw = key.getBytes();  
    25.         SecretKeySpec skeySpec = new SecretKeySpec(raw, KEY_AES);  
    26.         Cipher cipher = Cipher.getInstance(KEY_AES);  
    27.         cipher.init(Cipher.DECRYPT_MODE, skeySpec);  
    28.         byte[] encrypted1 = hex2byte(src);  
    29.         byte[] original = cipher.doFinal(encrypted1);  
    30.         String originalString = new String(original);  
    31.         return originalString;  
    32.     }  
    33.   
    34.     public static byte[] hex2byte(String strhex) {  
    35.         if (strhex == null) {  
    36.             return null;  
    37.         }  
    38.         int l = strhex.length();  
    39.         if (l % 2 == 1) {  
    40.             return null;  
    41.         }  
    42.         byte[] b = new byte[l / 2];  
    43.         for (int i = 0; i != l / 2; i++) {  
    44.             b[i] = (byte) Integer.parseInt(strhex.substring(i * 2, i * 2 + 2),  
    45.                     16);  
    46.         }  
    47.         return b;  
    48.     }  
    49.   
    50.     public static String byte2hex(byte[] b) {  
    51.         String hs = "";  
    52.         String stmp = "";  
    53.         for (int n = 0; n < b.length; n++) {  
    54.             stmp = (java.lang.Integer.toHexString(b[n] & 0XFF));  
    55.             if (stmp.length() == 1) {  
    56.                 hs = hs + "0" + stmp;  
    57.             } else {  
    58.                 hs = hs + stmp;  
    59.             }  
    60.         }  
    61.         return hs.toUpperCase();  
    62.     }  
    63.   
    64. }  

    Base64加密：

    [java] view plain copy print?
    1. import org.apache.commons.codec.binary.Base64;  
    2.   
    3. /** 
    4.  * Base64组件 
    5.  *  
    6.  * @author wbw 
    7.  * @version 1.0 
    8.  * @since 1.0 
    9.  */  
    10. public abstract class Base64Util {  
    11.   
    12.     /** 
    13.      * 字符编码 
    14.      */  
    15.     public final static String ENCODING = "UTF-8";  
    16.   
    17.     /** 
    18.      * Base64编码 
    19.      *  
    20.      * @param data 待编码数据 
    21.      * @return String 编码数据 
    22.      * @throws Exception 
    23.      */  
    24.     public static String encode(String data) throws Exception {  
    25.   
    26.         // 执行编码  
    27.         byte[] b = Base64.encodeBase64(data.getBytes(ENCODING));  
    28.   
    29.         return new String(b, ENCODING);  
    30.     }  
    31.   
    32.     /** 
    33.      * Base64安全编码<br> 
    34.      * 遵循RFC 2045实现 
    35.      *  
    36.      * @param data 
    37.      *            待编码数据 
    38.      * @return String 编码数据 
    39.      *  
    40.      * @throws Exception 
    41.      */  
    42.     public static String encodeSafe(String data) throws Exception {  
    43.   
    44.         // 执行编码  
    45.         byte[] b = Base64.encodeBase64(data.getBytes(ENCODING), true);  
    46.   
    47.         return new String(b, ENCODING);  
    48.     }  
    49.   
    50.     /** 
    51.      * Base64解码 
    52.      *  
    53.      * @param data 待解码数据 
    54.      * @return String 解码数据 
    55.      * @throws Exception 
    56.      */  
    57.     public static String decode(String data) throws Exception {  
    58.   
    59.         // 执行解码  
    60.         byte[] b = Base64.decodeBase64(data.getBytes(ENCODING));  
    61.   
    62.         return new String(b, ENCODING);  
    63.     }  
    64.   
    65. }  

    DES加密：

    [java] view plain copy print?
    1. import java.security.Key;  
    2. import java.security.SecureRandom;  
    3. import java.security.Security;  
    4.   
    5. import javax.crypto.Cipher;  
    6. import javax.crypto.KeyGenerator;  
    7. import javax.crypto.SecretKey;  
    8. import javax.crypto.SecretKeyFactory;  
    9. import javax.crypto.spec.DESKeySpec;  
    10.   
    11. import org.apache.commons.codec.binary.Base64;  
    12. import org.bouncycastle.jce.provider.BouncyCastleProvider;  
    13.   
    14. /** 
    15.  * DES安全编码组件 
    16.  *  
    17.  * @author wbw 
    18.  * @version 1.0 
    19.  */  
    20. public abstract class DESUtil {  
    21.     static{  
    22.         Security.insertProviderAt(new BouncyCastleProvider(), 1);  
    23.     }  
    24.     /** 
    25.      * 密钥算法 <br> 
    26.      * Java 6 只支持56bit密钥 <br> 
    27.      * Bouncy Castle 支持64bit密钥 
    28.      */  
    29.     public static final String KEY_ALGORITHM = "DES";  
    30.   
    31.     /** 
    32.      * 加密/解密算法 / 工作模式 / 填充方式 
    33.      */  
    34.     public static final String CIPHER_ALGORITHM = "DES/ECB/PKCS5PADDING";  
    35.   
    36.     /** 
    37.      * 转换密钥 
    38.      *  
    39.      * @param key 
    40.      *            二进制密钥 
    41.      * @return Key 密钥 
    42.      * @throws Exception 
    43.      */  
    44.     private static Key toKey(byte[] key) throws Exception {  
    45.   
    46.         // 实例化DES密钥材料  
    47.         DESKeySpec dks = new DESKeySpec(key);  
    48.   
    49.         // 实例化秘密密钥工厂  
    50.         SecretKeyFactory keyFactory = SecretKeyFactory  
    51.                 .getInstance(KEY_ALGORITHM);  
    52.   
    53.         // 生成秘密密钥  
    54.         SecretKey secretKey = keyFactory.generateSecret(dks);  
    55.   
    56.         return secretKey;  
    57.     }  
    58.   
    59.     /** 
    60.      * 解密 
    61.      *  
    62.      * @param data 
    63.      *            待解密数据 
    64.      * @param key 
    65.      *            密钥 
    66.      * @return byte[] 解密数据 
    67.      * @throws Exception 
    68.      */  
    69.     public static byte[] decrypt(byte[] data, byte[] key) throws Exception {  
    70.   
    71.         // 还原密钥  
    72.         Key k = toKey(key);  
    73.   
    74.         // 实例化  
    75.         Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);  
    76.   
    77.         // 初始化，设置为解密模式  
    78.         cipher.init(Cipher.DECRYPT_MODE, k);  
    79.   
    80.         // 执行操作  
    81.         return cipher.doFinal(data);  
    82.     }  
    83.   
    84.     /** 
    85.      * 加密 
    86.      *  
    87.      * @param data 
    88.      *            待加密数据 
    89.      * @param key 
    90.      *            密钥 
    91.      * @return byte[] 加密数据 
    92.      * @throws Exception 
    93.      */  
    94.     public static byte[] encrypt(byte[] data, byte[] key) throws Exception {  
    95.   
    96.         // 还原密钥  
    97.         Key k = toKey(key);  
    98.   
    99.         // 实例化  
    100.         Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);  
    101.   
    102.         // 初始化，设置为加密模式  
    103.         cipher.init(Cipher.ENCRYPT_MODE, k);  
    104.   
    105.         // 执行操作  
    106.         return cipher.doFinal(data);  
    107.     }  
    108.   
    109.     /** 
    110.      * 生成密钥 <br> 
    111.      * Java 6 只支持56bit密钥 <br> 
    112.      * Bouncy Castle 支持64bit密钥 <br> 
    113.      *  
    114.      * @return byte[] 二进制密钥 
    115.      * @throws Exception 
    116.      */  
    117.     public static byte[] initKey() throws Exception {  
    118.   
    119.         /* 
    120.          * 实例化密钥生成器 
    121.          *  
    122.          * 若要使用64bit密钥注意替换 将下述代码中的KeyGenerator.getInstance(CIPHER_ALGORITHM); 
    123.          * 替换为KeyGenerator.getInstance(CIPHER_ALGORITHM, "BC"); 
    124.          */  
    125.         KeyGenerator kg = KeyGenerator.getInstance(KEY_ALGORITHM);  
    126.   
    127.         /* 
    128.          * 初始化密钥生成器 若要使用64bit密钥注意替换 将下述代码kg.init(56); 替换为kg.init(64); 
    129.          */  
    130.         kg.init(56, new SecureRandom());  
    131.   
    132.         // 生成秘密密钥  
    133.         SecretKey secretKey = kg.generateKey();  
    134.   
    135.         // 获得密钥的二进制编码形式  
    136.         return secretKey.getEncoded();  
    137.     }  
    138.       
    139.     public static byte[] initKey(String seed) throws Exception {  
    140.         KeyGenerator kg = KeyGenerator.getInstance(KEY_ALGORITHM);  
    141.         SecureRandom secureRandom = new SecureRandom(new Base64().decode(seed));    
    142.         kg.init(secureRandom);  
    143.         SecretKey secretKey = kg.generateKey();  
    144.         return secretKey.getEncoded();  
    145.     }  
    146. }  

    RSA加密：

    [java] view plain copy print?
    1. import java.io.ByteArrayOutputStream;  
    2. import java.security.Key;  
    3. import java.security.KeyFactory;  
    4. import java.security.KeyPair;  
    5. import java.security.KeyPairGenerator;  
    6. import java.security.PrivateKey;  
    7. import java.security.PublicKey;  
    8. import java.security.SecureRandom;  
    9. import java.security.Security;  
    10. import java.security.interfaces.RSAPrivateKey;  
    11. import java.security.interfaces.RSAPublicKey;  
    12. import java.security.spec.PKCS8EncodedKeySpec;  
    13. import java.security.spec.X509EncodedKeySpec;  
    14. import java.util.HashMap;  
    15. import java.util.Map;  
    16. import java.util.UUID;  
    17.   
    18. import javax.crypto.Cipher;  
    19.   
    20. import org.bouncycastle.jce.provider.BouncyCastleProvider;  
    21. import org.bouncycastle.util.encoders.Base64;  
    22.   
    23.   
    24. /** 
    25.  * RSA安全编码组件 
    26.  *  
    27.  * @author wbw 
    28.  * @version 1.0 
    29.  */  
    30. public class RSAUtil {  
    31.     /** 
    32.      * 非对称加密密钥算法 
    33.      */  
    34.     public static final String KEY_ALGORITHM_RSA = "RSA";  
    35.   
    36.     /** 
    37.      * 公钥 
    38.      */  
    39.     private static final String RSA_PUBLIC_KEY = "RSAPublicKey";  
    40.   
    41.     /** 
    42.      * 私钥 
    43.      */  
    44.     private static final String RSA_PRIVATE_KEY = "RSAPrivateKey";  
    45.       
    46.     /** 
    47.      * RSA密钥长度  
    48.      * 默认1024位， 
    49.      * 密钥长度必须是64的倍数，  
    50.      * 范围在512至65536位之间。 
    51.      */  
    52.     private static final int KEY_SIZE = 1024;  
    53.       
    54.     static{  
    55.         Security.insertProviderAt(new BouncyCastleProvider(), 1);  
    56.     }  
    57.     /** 
    58.      * 私钥解密 
    59.      *  
    60.      * @param data 
    61.      *            待解密数据 
    62.      * @param key 
    63.      *            私钥 
    64.      * @return byte[] 解密数据 
    65.      * @throws Exception 
    66.      */  
    67.     public static byte[] decryptByPrivateKey(byte[] data, byte[] key)  
    68.             throws Exception {  
    69.   
    70.         // 取得私钥  
    71.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);  
    72.   
    73.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM_RSA);  
    74.   
    75.         // 生成私钥  
    76.         PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);  
    77.   
    78.         // 对数据解密  
    79.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());  
    80.   
    81.         cipher.init(Cipher.DECRYPT_MODE, privateKey);  
    82.   
    83.         int blockSize = cipher.getBlockSize();  
    84.         if(blockSize>0){  
    85.             ByteArrayOutputStream bout = new ByteArrayOutputStream(64);  
    86.             int j = 0;  
    87.             while (data.length - j * blockSize > 0) {  
    88.                 bout.write(cipher.doFinal(data, j * blockSize, blockSize));  
    89.                 j++;  
    90.             }  
    91.             return bout.toByteArray();  
    92.         }  
    93.         return cipher.doFinal(data);  
    94.     }  
    95.   
    96.     /** 
    97.      * 公钥解密 
    98.      *  
    99.      * @param data 
    100.      *            待解密数据 
    101.      * @param key 
    102.      *            公钥 
    103.      * @return byte[] 解密数据 
    104.      * @throws Exception 
    105.      */  
    106.     public static byte[] decryptByPublicKey(byte[] data, byte[] key)  
    107.             throws Exception {  
    108.   
    109.         // 取得公钥  
    110.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);  
    111.   
    112.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM_RSA);  
    113.   
    114.         // 生成公钥  
    115.         PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);  
    116.   
    117.         // 对数据解密  
    118.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());  
    119.   
    120.         cipher.init(Cipher.DECRYPT_MODE, publicKey);  
    121.   
    122.         return cipher.doFinal(data);  
    123.     }  
    124.   
    125.     /** 
    126.      * 公钥加密 
    127.      *  
    128.      * @param data 
    129.      *            待加密数据 
    130.      * @param key 
    131.      *            公钥 
    132.      * @return byte[] 加密数据 
    133.      * @throws Exception 
    134.      */  
    135.     public static byte[] encryptByPublicKey(byte[] data, byte[] key)  
    136.             throws Exception {  
    137.   
    138.         // 取得公钥  
    139.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);  
    140.   
    141.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM_RSA);  
    142.           
    143.         PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);  
    144.   
    145.         // 对数据加密  
    146.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());  
    147.   
    148.         cipher.init(Cipher.ENCRYPT_MODE, publicKey);  
    149.           
    150.         int blockSize = cipher.getBlockSize();  
    151.         if(blockSize>0){  
    152.             int outputSize = cipher.getOutputSize(data.length);  
    153.             int leavedSize = data.length % blockSize;  
    154.             int blocksSize = leavedSize != 0 ? data.length / blockSize + 1  
    155.                     : data.length / blockSize;  
    156.             byte[] raw = new byte[outputSize * blocksSize];  
    157.             int i = 0,remainSize=0;  
    158.             while ((remainSize = data.length - i * blockSize) > 0) {  
    159.                 int inputLen = remainSize > blockSize?blockSize:remainSize;  
    160.                 cipher.doFinal(data, i * blockSize, inputLen, raw, i * outputSize);  
    161.                 i++;  
    162.             }  
    163.             return raw;  
    164.         }  
    165.         return cipher.doFinal(data);  
    166.     }  
    167.   
    168.     /** 
    169.      * 私钥加密 
    170.      *  
    171.      * @param data 
    172.      *            待加密数据 
    173.      * @param key 
    174.      *            私钥 
    175.      * @return byte[] 加密数据 
    176.      * @throws Exception 
    177.      */  
    178.     public static byte[] encryptByPrivateKey(byte[] data, byte[] key)  
    179.             throws Exception {  
    180.   
    181.         // 取得私钥  
    182.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);  
    183.   
    184.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM_RSA);  
    185.   
    186.         // 生成私钥  
    187.         PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);  
    188.   
    189.         // 对数据加密  
    190.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());  
    191.   
    192.         cipher.init(Cipher.ENCRYPT_MODE, privateKey);  
    193.   
    194.         int blockSize = cipher.getBlockSize();  
    195.         if(blockSize>0){  
    196.             int outputSize = cipher.getOutputSize(data.length);  
    197.             int leavedSize = data.length % blockSize;  
    198.             int blocksSize = leavedSize != 0 ? data.length / blockSize + 1  
    199.                     : data.length / blockSize;  
    200.             byte[] raw = new byte[outputSize * blocksSize];  
    201.             int i = 0,remainSize=0;  
    202.             while ((remainSize = data.length - i * blockSize) > 0) {  
    203.                 int inputLen = remainSize > blockSize?blockSize:remainSize;  
    204.                 cipher.doFinal(data, i * blockSize, inputLen, raw, i * outputSize);  
    205.                 i++;  
    206.             }  
    207.             return raw;  
    208.         }  
    209.         return cipher.doFinal(data);  
    210.     }  
    211.   
    212.     /** 
    213.      * 取得私钥 
    214.      *  
    215.      * @param keyMap 
    216.      *            密钥Map 
    217.      * @return key 私钥 
    218.      * @throws Exception 
    219.      */  
    220.     public static Key getPrivateKey(Map<String, Key> keyMap)  
    221.             throws Exception {  
    222.         return keyMap.get(RSA_PRIVATE_KEY);  
    223.     }  
    224.   
    225.     /** 
    226.      * 取得私钥 
    227.      *  
    228.      * @param keyMap 
    229.      *            密钥Map 
    230.      * @return byte[] 私钥 
    231.      * @throws Exception 
    232.      */  
    233.     public static byte[] getPrivateKeyByte(Map<String, Key> keyMap)  
    234.             throws Exception {  
    235.         return keyMap.get(RSA_PRIVATE_KEY).getEncoded();  
    236.     }  
    237.       
    238.     /** 
    239.      * 取得公钥 
    240.      *  
    241.      * @param keyMap 
    242.      *            密钥Map 
    243.      * @return key 公钥 
    244.      * @throws Exception 
    245.      */  
    246.     public static Key getPublicKey(Map<String, Key> keyMap)  
    247.             throws Exception {  
    248.         return keyMap.get(RSA_PUBLIC_KEY);  
    249.     }  
    250.       
    251.     /** 
    252.      * 取得公钥 
    253.      *  
    254.      * @param keyMap 
    255.      *            密钥Map 
    256.      * @return byte[] 公钥 
    257.      * @throws Exception 
    258.      */  
    259.     public static byte[] getPublicKeyByte(Map<String, Key> keyMap)  
    260.             throws Exception {  
    261.         return keyMap.get(RSA_PUBLIC_KEY).getEncoded();  
    262.     }  
    263.       
    264.     /** 
    265.      * 初始化密钥 
    266.      * @param byte[] seed 种子 
    267.      * @return Map 密钥Map 
    268.      * @throws Exception 
    269.      */  
    270.     public static Map<String,Key> initKey(byte[] seed)throws Exception{  
    271.         // 实例化密钥对生成器  
    272.         KeyPairGenerator keyPairGen = KeyPairGenerator  
    273.                 .getInstance(KEY_ALGORITHM_RSA);  
    274.   
    275.         // 初始化密钥对生成器  
    276.         keyPairGen.initialize(KEY_SIZE, new SecureRandom(seed) );  
    277.   
    278.         // 生成密钥对  
    279.         KeyPair keyPair = keyPairGen.generateKeyPair();  
    280.   
    281.         // 公钥  
    282.         RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();  
    283.   
    284.         // 私钥  
    285.         RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();  
    286.   
    287.         // 封装密钥  
    288.         Map<String, Key> keyMap = new HashMap<String, Key>(2);  
    289.   
    290.         keyMap.put(RSA_PUBLIC_KEY, publicKey);  
    291.         keyMap.put(RSA_PRIVATE_KEY, privateKey);  
    292.   
    293.         return keyMap;  
    294.     }  
    295.       
    296.     /** 
    297.      * 初始化密钥 
    298.      * @param seed 种子 
    299.      * @return Map 密钥Map 
    300.      * @throws Exception 
    301.      */  
    302.     public static Map<String,Key> initKey(String seed)throws Exception{  
    303.         return initKey(seed.getBytes());  
    304.     }  
    305.   
    306.     /** 
    307.      * 初始化密钥 
    308.      *  
    309.      * @return Map 密钥Map 
    310.      * @throws Exception 
    311.      */  
    312.     public static Map<String, Key> initKey() throws Exception {  
    313.         return initKey(UUID.randomUUID().toString().getBytes());  
    314.     }  
    315.       
    316.     public static PublicKey getPublicRSAKey(String key) throws Exception {  
    317.         X509EncodedKeySpec x509 = new X509EncodedKeySpec(Base64.decode(key));  
    318.         KeyFactory kf = KeyFactory.getInstance(KEY_ALGORITHM_RSA);  
    319.         return kf.generatePublic(x509);  
    320.     }  
    321.   
    322.     public static PrivateKey getPrivateRSAKey(String key) throws Exception {  
    323.         PKCS8EncodedKeySpec pkgs8 = new PKCS8EncodedKeySpec(Base64.decode(key));  
    324.         KeyFactory kf = KeyFactory.getInstance(KEY_ALGORITHM_RSA);  
    325.         return kf.generatePrivate(pkgs8);  
    326.     }  
    327.   
    328. } 

    https://www.cnblogs.com/jpfss/p/8567001.html
  • 相关阅读:
    MySQL远程登陆
    一键安装LAMP wordpress
    编译安装httpd2.4.46
    RDB转化AOF 花式删库
    3周作业
    2周作业
    1周作业
    预习第三周作业
    预习第二周作业
    预习第一周作业
  • 原文地址：https://www.cnblogs.com/tiancai/p/10076913.html
Copyright © 2011-2022 走看看