java 加解密

 

import javax.crypto.*;
import javax.crypto.spec.SecretKeySpec;
import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Base64;
import java.util.Random;

public class EncryptUtil {
   
    public static String MD5Purity(String plainText) {
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
            md.update(plainText.getBytes());
            byte b[] = md.digest();
            int i;
            StringBuffer buf = new StringBuffer("");
            for (int offset = 0; offset < b.length; offset++) {
                i = b[offset];
                if (i < 0) {
                    i += 256;
                }
                if (i < 16) {
                    buf.append("0");
                }
                buf.append(Integer.toHexString(i));
            }
            plainText = buf.toString();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return plainText.toLowerCase();
    }

    public static int GetRandom(int max, int min) {
        Random random = new Random();
        int s = random.nextInt(max) % (max - min + 1) + min;
        return s;
    }
 
    public static String aesEncrypt(String str, String key) throws Exception {
        if (str == null || key == null) {
            return null;
        }
        str = ZipUtils.gzip(str);
        Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
        cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(key.getBytes("utf-8"), "AES"));
        byte[] bytes = cipher.doFinal(str.getBytes("utf-8"));
        return Base64.getEncoder().encodeToString(bytes);
    }

 
    public static String aesDecrypt(String str, String key) throws Exception {
        if (str == null || key == null) {
            return null;
        }
        Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
        cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(key.getBytes("utf-8"), "AES"));
        byte[] bytes = Base64.getDecoder().decode(str);
        bytes = cipher.doFinal(bytes);
        return ZipUtils.gunzip(new String(bytes, "utf-8"));
    }

     
    public static String MwEncrypt(String shopguid, String token, String seed, String data) throws Exception {
        int start = GetRandom(9, 3);
        int end = GetRandom(9, 3);
        String keyseed = shopguid + token + seed.substring(start * end, start * end + end);
        String key = EncryptUtil.MD5Purity(keyseed);
        String encry = EncryptUtil.aesEncrypt(System.currentTimeMillis() + data, key);
        if (encry.indexOf("==") == encry.length() - 2) {
            encry = "2" + encry.substring(0, encry.indexOf("=="));
            ;
        } else if (encry.indexOf("=") == encry.length() - 1) {
            encry = "1" + encry.substring(0, encry.indexOf("="));
        } else {
            encry = "a" + encry;
        }
        String autograph = EncryptUtil.MD5Purity(encry);
        autograph = start + autograph + end;
        encry = autograph.toUpperCase() + encry;
        return encry;
    }

     
    public static String MwEncryptaut(String shopguid, String token, String seed, String data) throws Exception {
        int start = GetRandom(9, 3);
        int end = GetRandom(9, 3);
        System.out.println("start = [" + start + "], end = [" + end + "]");
        String keyseed = shopguid + token + seed.substring(start * end, start * end + end);
        String key = EncryptUtil.MD5Purity(keyseed);
        String encry = ZipUtils.gzip(System.currentTimeMillis() + data);
        // EncryptUtil.aesEncrypt(System.currentTimeMillis()+data, key);
        if (encry.indexOf("==") == encry.length() - 2) {
            encry = "2" + encry.substring(0, encry.indexOf("=="));
            ;
        } else if (encry.indexOf("=") == encry.length() - 1) {
            encry = "1" + encry.substring(0, encry.indexOf("="));
        } else {
            encry = "a" + encry;
        }
        String autograph = EncryptUtil.MD5Purity(encry + key);
        autograph = start + autograph + end;
        encry = autograph.toUpperCase() + encry;
        return encry;
    }
    public static String MwDecryptaut(String shopguid, String token, String seed, String data) throws Exception {
        //System.out.println("body_str:"+data);
        if (data.length() < 35) {
            throw new Exception("601");
        }
        String autograph = data.substring(0, 34);
        int start = Integer.parseInt(autograph.substring(0, 1));
        int end = Integer.parseInt(autograph.substring(33, 34));
        //System.out.println("start:"+start+":::end:"+end);
        String keyseed = shopguid + token + seed.substring(start * end, start * end + end);
        String key = EncryptUtil.MD5Purity(keyseed);
        autograph = autograph.substring(1, 33);
        data = data.substring(34, data.length());
        String autograph_ne = EncryptUtil.MD5Purity(data + key).toUpperCase();
        if (!autograph_ne.equals(autograph)) {
            throw new Exception("602");
        }
        String vl = data.substring(0, 1);
        data = data.substring(1, data.length());
        if (vl.equals("2")) {
            data = data + "==";
        } else if (vl.equals("1")) {
            data = data + "=";
        }
        String Decryptstr = ZipUtils.gunzip(data);
        long stl = Long.parseLong(Decryptstr.substring(0, 13));
        long ltl = System.currentTimeMillis();
        long lp = (ltl - stl) / (1000 * 60);

        if (Math.abs(lp) > 10) {
            throw new Exception("603");
        }
        Decryptstr = Decryptstr.substring(13, Decryptstr.length());
        return Decryptstr;
    }
    public static void main(String[] args) throws Exception {
        String str = MwEncryptaut("0001", "0c5f6f217aabb2ea742b0944cd5020f3", "yW2we6Vqf73Qd3pg4mE209949t968lB6957n981i3LtQezfF9z0LDi08d9Li2c52X8h7v5MY3l7000537foITmq49yie8a71lM40", "1");
        System.out.println(str);
        String destr= MwDecryptaut("0001", "0c5f6f217aabb2ea742b0944cd5020f3", "yW2we6Vqf73Qd3pg4mE209949t968lB6957n981i3LtQezfF9z0LDi08d9Li2c52X8h7v5MY3l7000537foITmq49yie8a71lM40",str );
        System.out.println(destr);
    }
    */
    public static String MwDecrypt(String shopguid, String token, String seed, String data) throws Exception {
        if (data.length() < 35) {
            throw new Exception("601");
        }
        String autograph = data.substring(0, 34);
        int start = Integer.parseInt(autograph.substring(0, 1));
        int end = Integer.parseInt(autograph.substring(33, 34));
        //System.out.println("start:"+start+":::end:"+end);
        autograph = autograph.substring(1, 33);
        data = data.substring(34, data.length());
        String autograph_ne = EncryptUtil.MD5Purity(data).toUpperCase();
        if (!autograph_ne.equals(autograph)) {
            throw new Exception("602");
        }
        String vl = data.substring(0, 1);
        data = data.substring(1, data.length());
        if (vl.equals("2")) {
            data = data + "==";
        } else if (vl.equals("1")) {
            data = data + "=";
        }
        //System.out.println("data:"+data);
        //System.out.println("seed:"+seed);
        String keyseed = shopguid + token + seed.substring(start * end, start * end + end);
        String key = EncryptUtil.MD5Purity(keyseed);
        //System.out.println("key:"+key);
        String Decryptstr = EncryptUtil.aesDecrypt(data, key);
        long stl = Long.parseLong(Decryptstr.substring(0, 13));
        long ltl = System.currentTimeMillis();
        long lp = (ltl - stl) / (1000 * 60);
        if (Math.abs(lp) > 10) {
            throw new Exception("603");
        }
        Decryptstr = Decryptstr.substring(13, Decryptstr.length());
        return Decryptstr;
    }

    public static byte[] encrypt(String content, String password) {
        try {
            KeyGenerator kgen = KeyGenerator.getInstance("AES");
            kgen.init(128, new SecureRandom(password.getBytes()));
            SecretKey secretKey = kgen.generateKey();
            byte[] enCodeFormat = secretKey.getEncoded();
            SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");
            Cipher cipher = Cipher.getInstance("AES");
            byte[] byteContent = content.getBytes("utf-8");
            cipher.init(Cipher.ENCRYPT_MODE, key);
            byte[] result = cipher.doFinal(byteContent);
            return result; // ����
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        }
        return null;
    }

     
    public static byte[] decrypt(byte[] content, String password) {
        try {
            KeyGenerator kgen = KeyGenerator.getInstance("AES");
            kgen.init(128, new SecureRandom(password.getBytes()));
            SecretKey secretKey = kgen.generateKey();
            byte[] enCodeFormat = secretKey.getEncoded();
            SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");
            Cipher cipher = Cipher.getInstance("AES");
            cipher.init(Cipher.DECRYPT_MODE, key);
            byte[] result = cipher.doFinal(content);
            return result; // ����
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        }
        return null;
    }

     
    public static String parseByte2HexStr(byte buf[]) {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < buf.length; i++) {
            String hex = Integer.toHexString(buf[i] & 0xFF);
            if (hex.length() == 1) {
                hex = '0' + hex;
            }
            sb.append(hex.toUpperCase());
        }
        return sb.toString();
    }

     
    public static byte[] parseHexStr2Byte(String hexStr) {
        if (hexStr.length() < 1) {
            return null;
        }
        byte[] result = new byte[hexStr.length() / 2];
        for (int i = 0; i < hexStr.length() / 2; i++) {
            int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);
            int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2), 16);
            result[i] = (byte) (high * 16 + low);
        }
        return result;
    }

    /*****************************************************************************************************************/
 
    private static String encryptAes(String input, String key) {
        byte[] crypted = null;
        try {
            SecretKeySpec skey = new SecretKeySpec(key.getBytes(), "AES");
            Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
            cipher.init(Cipher.ENCRYPT_MODE, skey);
            crypted = cipher.doFinal(input.getBytes());
        } catch (Exception e) {
            System.out.println(e.toString());
        }
        return replaceSpecial(Base64.getEncoder().encodeToString(crypted));
    }

  
    public static String replaceSpecial(String s) {
        s = s.replaceAll("=", "-Z");
        s = s.replaceAll("\\+", "Y-B");
        s = s.replaceAll("/", "X-C");
        return s;
    }

 
    public static String encrypt(String data) {
        String key = "!@#$won9)6*^43^2";
        return encryptAes(data, key);
    }
 
    public static String encryptPassword(String password) {
        if (password.isEmpty()) {
            return "";
        }
        String val = password + "cardmwee";
        MessageDigest sh1 = null;
        try {
            sh1 = MessageDigest.getInstance("SHA-1");
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        sh1.update(val.getBytes());
        byte[] m = sh1.digest(); 
        return byte2hex(m);
    }
 
    public static String byte2hex(byte[] b) {
        String hs = "";
        String stmp = "";
        for (int n = 0; n < b.length; n++) {
            stmp = (java.lang.Integer.toHexString(b[n] & 0XFF));
            if (stmp.length() == 1) {
                hs = hs + "0" + stmp;
            } else {
                hs = hs + stmp;
            }
        }
        return hs;
    }

    public static String sha1(String decript) {
        try {
            MessageDigest digest = java.security.MessageDigest
                    .getInstance("SHA-1");
            digest.update(decript.getBytes());
            byte messageDigest[] = digest.digest();
            // Create Hex String
            StringBuffer hexString = new StringBuffer();
        
            for (int i = 0; i < messageDigest.length; i++) {
                String shaHex = Integer.toHexString(messageDigest[i] & 0xFF);
                if (shaHex.length() < 2) {
                    hexString.append(0);
                }
                hexString.append(shaHex);
            }
            return hexString.toString();

        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return "";
    }
}

 

package mpos.api.cloud.crypt;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.Base64;
import java.util.zip.*;

public class ZipUtils {

    public static String gzip(String primStr) {
        if (primStr == null || primStr.length() == 0) {
            return primStr;
        }

        ByteArrayOutputStream out = new ByteArrayOutputStream();

        GZIPOutputStream gzip = null;
        try {
            gzip = new GZIPOutputStream(out);

            gzip.write(primStr.getBytes("UTF-8"));
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (gzip != null) {
                try {
                    gzip.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

//        return new sun.misc.BASE64Encoder().encode(out.toByteArray());

        return Base64.getEncoder().encodeToString(out.toByteArray());
    }


    public static String gunzip(String compressedStr) {
        if (compressedStr == null) {
            return null;
        }

        ByteArrayOutputStream out = new ByteArrayOutputStream();
        ByteArrayInputStream in = null;
        GZIPInputStream ginzip = null;
        byte[] compressed = null;
        String decompressed = null;
        try {
//            compressed = new sun.misc.BASE64Decoder().decodeBuffer(compressedStr);
            compressed = Base64.getDecoder().decode(compressedStr);
            in = new ByteArrayInputStream(compressed);
            ginzip = new GZIPInputStream(in);

            byte[] buffer = new byte[1024];
            int offset = -1;
            while ((offset = ginzip.read(buffer)) != -1) {
                out.write(buffer, 0, offset);
            }

            decompressed = out.toString("UTF-8");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (ginzip != null) {
                try {
                    ginzip.close();
                } catch (IOException e) {
                }
            }
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                }
            }
            if (out != null) {
                try {
                    out.close();
                } catch (IOException e) {
                }
            }
        }

        return decompressed;
    }


    public static final String zip(String str) {
        if (str == null) {
            return null;
        }
        byte[] compressed;
        ByteArrayOutputStream out = null;
        ZipOutputStream zout = null;
        String compressedStr = null;
        try {
            out = new ByteArrayOutputStream();
            zout = new ZipOutputStream(out);
            zout.putNextEntry(new ZipEntry("0"));
            zout.write(str.getBytes("UTF-8"));
            zout.closeEntry();
            compressed = out.toByteArray();
//            compressedStr = new sun.misc.BASE64Encoder().encodeBuffer(compressed);
            compressedStr = Base64.getEncoder().encodeToString(compressed);
        } catch (IOException e) {
            compressed = null;
        } finally {
            if (zout != null) {
                try {
                    zout.close();
                } catch (IOException e) {
                }
            }
            if (out != null) {
                try {
                    out.close();
                } catch (IOException e) {
                }
            }
        }
        return compressedStr;
    }


    public static final String unzip(String compressedStr) {
        if (compressedStr == null) {
            return null;
        }

        ByteArrayOutputStream out = null;
        ByteArrayInputStream in = null;
        ZipInputStream zin = null;
        String decompressed = null;
        try {
//            byte[] compressed = new sun.misc.BASE64Decoder().decodeBuffer(compressedStr);
            byte[] compressed = Base64.getDecoder().decode(compressedStr);
            out = new ByteArrayOutputStream();
            in = new ByteArrayInputStream(compressed);
            zin = new ZipInputStream(in);
            zin.getNextEntry();
            byte[] buffer = new byte[1024];
            int offset = -1;
            while ((offset = zin.read(buffer)) != -1) {
                out.write(buffer, 0, offset);
            }
            decompressed = out.toString("UTF-8");
        } catch (IOException e) {
            decompressed = null;
        } finally {
            if (zin != null) {
                try {
                    zin.close();
                } catch (IOException e) {
                }
            }
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                }
            }
            if (out != null) {
                try {
                    out.close();
                } catch (IOException e) {
                }
            }
        }
        return decompressed;
    }
}