精华内容
下载资源
问答
  • 主要介绍了Java加密解密和数字签名完整代码示例,具有一定参考价值,需要的朋友可以了解下。
  • 这是本人完成的课程设计,内容是用java语言实现对文件的加密解密操作,算法采用的是3DES
  • 设计到的方法如下: DigitalSign init getInstance SignMsgByRelativePath SignMsgByInputStream signMsgByAbsolutePath verifyMsgByInputSteam verifyMsgByAbsolutePath verifyMsgByRelativePath ...
  • 主要介绍了Java加密解密工具,适用于JavaSE/JavaEE/Android,感兴趣的小伙伴们可以参考一下
  • java加密解密zip压缩包

    2017-05-27 15:11:30
    楼上兄弟太黑,特意找的源码,2分处理,完美解决Java加密解密zip文件
  • java加密解密的方法

    2019-03-25 14:54:46
    java加密解密的方法,利用指定的密钥,可逆的。密钥必须16位。
  • java加密解密技术代码及使用
  • 前台页面通过引入提供的两个js,实现AES加密解密。后端java代码通过压缩包里的博客信息配置AESUtil.java公共类。
  • java加密解密算法大全

    热门讨论 2012-11-29 13:52:42
    java代码写的流行的加密解密算法的实现
  • java加密解密程序

    2018-08-15 21:24:26
    采用MyEclipse编写的一个java加密解密程序,算法是凯撒加密法,欢迎有兴趣的朋友下载
  • java加密解密工具

    2011-07-05 20:39:26
    java加密解密工具,java加密解密工具
  • Java加密解密

    2014-08-04 14:43:03
    这是一个加密解密Java软件,含代码,大家可以将它导入Eclipse中参考一下。
  • 本文给大家分享的是一个java纯数字加密解密技术,加密和解密本身就是一对共生体,缺一不可,需要的朋友可以参考下
  • js/java加密解密

    千次阅读 2019-08-15 11:56:10
    怎么给文字加密? js代码: encrypt.js /* *功能:对url加密算法(只针对window.location.href跳转,不针对post表单提交及ajax方式) *算法:对于暴露在浏览器地址栏中的属性值进行加密,如一个属性为agentID=1, * ...

    怎么给文字加密?
    js代码:
    encrypt.js

    /*
    *功能:对url加密算法(只针对window.location.href跳转,不针对post表单提交及ajax方式)
    *算法:对于暴露在浏览器地址栏中的属性值进行加密,如一个属性为agentID=1,
    *     若对1加密后为k230101io934jksd32r4,说明如下:
    *     前三位为随机数;
    *     第四到第五位为要加密字符转换成16进制的位数,
    *       如:要加密字符为15转换成16进制为f,位数为1,则第四、五位为01;
    *     第六位标识要加密字符为何种字符,0:纯数字,1:字符
    *       若是字符和数字的混合,则不加密;
    *     从第七位开始为16进制转换后的字符(字母和非数字先转换成asc码);
    *     若加密后的字符总位数不足20位,则用随机数补齐到20位,若超出20位,则不加随机数。
    *     即加密后总位数至少为20位。
    */
    function encode16(str){
        str=str.toLowerCase();
        if (str.match(/^[-+]?\d*$/) == null){//非整数字符,对每一个字符都转换成16进制,然后拼接
            var s=str.split("");
            var temp="";
            for(var i=0;i<s.length;i++){
                s[i]=s[i].charCodeAt();//先转换成Unicode编码
                s[i]=s[i].toString(16);
                temp=temp+s[i];
            }
            return temp+"{"+1;//1代表字符
        }else{//数字直接转换成16进制
            str=parseInt(str).toString(16);
        }
        return str+"{"+0;//0代表纯数字
    }
     
     
    function produceRandom(n){
        var num=""; 
        for(var i=0;i<n;i++) 
        { 
            num+=Math.floor(Math.random()*10);
        } 
        return num;
    }
     
    //主加密函数
    function encrypt(str){
        var encryptStr="";//最终返回的加密后的字符串
        encryptStr+=produceRandom(3);//产生3位随机数
         
        var temp=encode16(str).split("{");//对要加密的字符转换成16进制
        var numLength=temp[0].length;//转换后的字符长度
        numLength=numLength.toString(16);//字符长度换算成16进制
        if(numLength.length==1){//如果是1,补一个0
            numLength="0"+numLength;
        }else if(numLength.length>2){//转换后的16进制字符长度如果大于2位数,则返回,不支持
            return "";
        }
        encryptStr+=numLength;
         
        if(temp[1]=="0"){
            encryptStr+=0;
        }else if(temp[1]=="1"){
            encryptStr+=1;
        }
         
        encryptStr+=temp[0];
         
        if(encryptStr.length<20){//如果小于20位,补上随机数
            var ran=produceRandom(20-encryptStr.length);
            encryptStr+=ran;
        }
        return encryptStr;
    }
    

    java代码:
    Decode.java

    public class Decode {
    	
    	/*
    	*解密为加密的逆过程
    	*/
    	public static String decodeValue(String value){
    	    if(value.equals("")){
    	        throw new NullPointerException();
    	    }
    	    if(value.length()<20){
    	        throw new NullPointerException();
    	    }
    	    String charLength=value.substring(3, 5);//加密后的字符有多少位
    	    int charLen=Integer.parseInt(charLength,16);//转换成10进制
    	    int type=Integer.parseInt(value.substring(5, 6));//加密字符的类型(0:数字,1:字符串)
    	    String valueEnc=value.substring(6, 6+charLen);//16进制字符串
    	    if(type==0){
    	        int trueValue=Integer.parseInt(valueEnc,16);
    	        return String.valueOf(trueValue);
    	    }else{
    	        StringBuffer sb=new StringBuffer();
    	        String[] valueEncArray=valueEnc.split("");
    	        for(int i=1;i<valueEncArray.length;i+=2){
    	            int value10=Integer.parseInt(valueEncArray[i]+valueEncArray[i+1],16);//转换成10进制的asc码
    	            sb.append(String.valueOf((char)value10));//asc码转换成字符
    	        }
    	        return sb.toString();
    	    }
    	}
    }
    

    使用
    前端:

    encrypt(data_id);

    后端:

    String applyid = Decode.decodeValue(map.get(“applyid”);

    展开全文
  • 在 JavaEE 配置文件中,例如 XML 或者 properties 文件,由于某些敏感信息不希望普通人员看见,则可以采用加密的方式存储,程序读取后进行解密
  • 近期互联网上频频爆出网站数据库被脱裤,造成大量的敏感数据的失窃和丢失,给很多企业带来重大损失,本加密解密组件(jar包)可以帮助开发者,快速对应用中的敏感数据进行加密解密,尽可能的帮助开发人员提高应用的...
  • 加密解密过程,需要传递四个变量。 加密的四个变量依次为:明文,代码1,代码2,代码3 解密的四个变量依次为:密文,代码1,代码2,代码3
  • 一、常用的加密/解密算法 1.Base64  严格来说Base64并不是一种加密/解密算法,而是一种编码方式。Base64不生成密钥,通过Base64编码后的密文就可以直接“翻译”为明文,但是可以通过向明文中添加混淆字符来达到...
  • java加密解密方法大全

    2014-12-19 12:44:16
    本文档介绍java实现加密解密的方法,描述很详细,推荐给又需要的人。
  • java加密解密的艺术.mobi,比pdf更加便于阅读,还可以在移动设备上观看
  • java加密解密示例分享

    2020-09-04 16:16:38
    想要创造一个只有自己能看懂的文件吗?那就是对数据加密吧,下面分享一个java的数据加密解密示例
  • Java加密解密工具类(实用)

    千次阅读 2019-06-14 17:42:05
    * 对使用DES加密算法的密文进行解密(可逆) * @param res 需要解密的密文 * @param key 秘钥 * @return */ public String DESdecode(String res, String key) { return keyGeneratorES(res, DES, key, ...
    import com.sun.org.apache.xerces.internal.impl.dv.util.Base64;
    
    import javax.crypto.Cipher;
    import javax.crypto.KeyGenerator;
    import javax.crypto.Mac;
    import javax.crypto.SecretKey;
    import javax.crypto.spec.SecretKeySpec;
    import java.security.MessageDigest;
    import java.security.SecureRandom;
    
    public class EncryptUtil {
        public static final String MD5 = "MD5";
        public static final String SHA1 = "SHA1";
        public static final String HmacMD5 = "HmacMD5";
        public static final String HmacSHA1 = "HmacSHA1";
        public static final String DES = "DES";
        public static final String AES = "AES";
    
        /**编码格式;默认使用uft-8*/
        public String charset = "utf-8";
        /**DES*/
        public int keysizeDES = 0;
        /**AES*/
        public int keysizeAES = 128;
    
        public static EncryptUtil me;
    
        private EncryptUtil(){
            //单例
        }
        //双重锁
        public static EncryptUtil getInstance(){
            if (me==null) {
                synchronized (EncryptUtil.class) {
                    if(me == null){
                        me = new EncryptUtil();
                    }
                }
            }
            return me;
        }
    
        /**
         * 使用MessageDigest进行单向加密(无密码)
         * @param res 被加密的文本
         * @param algorithm 加密算法名称
         * @return
         */
        private String messageDigest(String res,String algorithm){
            try {
                MessageDigest md = MessageDigest.getInstance(algorithm);
                byte[] resBytes = charset==null?res.getBytes():res.getBytes(charset);
                return base64(md.digest(resBytes));
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * 使用KeyGenerator进行单向/双向加密(可设密码)
         * @param res 被加密的原文
         * @param algorithm  加密使用的算法名称
         * @param key 加密使用的秘钥
         * @return
         */
        private String keyGeneratorMac(String res,String algorithm,String key){
            try {
                SecretKey sk = null;
                if (key==null) {
                    KeyGenerator kg = KeyGenerator.getInstance(algorithm);
                    sk = kg.generateKey();
                }else {
                    byte[] keyBytes = charset==null?key.getBytes():key.getBytes(charset);
                    sk = new SecretKeySpec(keyBytes, algorithm);
                }
                Mac mac = Mac.getInstance(algorithm);
                mac.init(sk);
                byte[] result = mac.doFinal(res.getBytes());
                return base64(result);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * 使用KeyGenerator双向加密,DES/AES,注意这里转化为字符串的时候是将2进制转为16进制格式的字符串,不是直接转,因为会出错
         * @param res 加密的原文
         * @param algorithm 加密使用的算法名称
         * @param key  加密的秘钥
         * @param keysize
         * @param isEncode
         * @return
         */
        private String keyGeneratorES(String res,String algorithm,String key,int keysize,boolean isEncode){
            try {
                KeyGenerator kg = KeyGenerator.getInstance(algorithm);
                if (keysize == 0) {
                    byte[] keyBytes = charset==null?key.getBytes():key.getBytes(charset);
                    kg.init(new SecureRandom(keyBytes));
                }else if (key==null) {
                    kg.init(keysize);
                }else {
                    byte[] keyBytes = charset==null?key.getBytes():key.getBytes(charset);
                    kg.init(keysize, new SecureRandom(keyBytes));
                }
                SecretKey sk = kg.generateKey();
                SecretKeySpec sks = new SecretKeySpec(sk.getEncoded(), algorithm);
                Cipher cipher = Cipher.getInstance(algorithm);
                if (isEncode) {
                    cipher.init(Cipher.ENCRYPT_MODE, sks);
                    byte[] resBytes = charset==null?res.getBytes():res.getBytes(charset);
                    return parseByte2HexStr(cipher.doFinal(resBytes));
                }else {
                    cipher.init(Cipher.DECRYPT_MODE, sks);
                    return new String(cipher.doFinal(parseHexStr2Byte(res)));
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    
        private String base64(byte[] res){
            return Base64.encode(res);
        }
    
        /**将二进制转换成16进制 */
        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();
        }
        /**将16进制转换为二进制*/
        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;
        }
    
        /**
         * md5加密算法进行加密(不可逆)
         * @param res 需要加密的原文
         * @return
         */
        public String MD5(String res) {
            return messageDigest(res, MD5);
        }
    
        /**
         * md5加密算法进行加密(不可逆)
         * @param res  需要加密的原文
         * @param key  秘钥
         * @return
         */
        public String MD5(String res, String key) {
            return keyGeneratorMac(res, HmacMD5, key);
        }
    
        /**
         * 使用SHA1加密算法进行加密(不可逆)
         * @param res 需要加密的原文
         * @return
         */
        public String SHA1(String res) {
            return messageDigest(res, SHA1);
        }
    
        /**
         * 使用SHA1加密算法进行加密(不可逆)
         * @param res 需要加密的原文
         * @param key 秘钥
         * @return
         */
        public String SHA1(String res, String key) {
            return keyGeneratorMac(res, HmacSHA1, key);
        }
    
        /**
         * 使用DES加密算法进行加密(可逆)
         * @param res 需要加密的原文
         * @param key 秘钥
         * @return
         */
        public String DESencode(String res, String key) {
            return keyGeneratorES(res, DES, key, keysizeDES, true);
        }
    
        /**
         * 对使用DES加密算法的密文进行解密(可逆)
         * @param res 需要解密的密文
         * @param key 秘钥
         * @return
         */
        public String DESdecode(String res, String key) {
            return keyGeneratorES(res, DES, key, keysizeDES, false);
        }
    
        /**
         * 使用AES加密算法经行加密(可逆)
         * @param res 需要加密的密文
         * @param key 秘钥
         * @return
         */
        public String AESencode(String res, String key) {
            return keyGeneratorES(res, AES, key, keysizeAES, true);
        }
    
        /**
         * 对使用AES加密算法的密文进行解密
         * @param res 需要解密的密文
         * @param key 秘钥
         * @return
         */
        public String AESdecode(String res, String key) {
            return keyGeneratorES(res, AES, key, keysizeAES, false);
        }
    
        /**
         * 使用异或进行加密
         * @param res 需要加密的密文
         * @param key 秘钥
         * @return
         */
        public String XORencode(String res, String key) {
            byte[] bs = res.getBytes();
            for (int i = 0; i < bs.length; i++) {
                bs[i] = (byte) ((bs[i]) ^ key.hashCode());
            }
            return parseByte2HexStr(bs);
        }
    
        /**
         * 使用异或进行解密
         * @param res 需要解密的密文
         * @param key 秘钥
         * @return
         */
        public String XORdecode(String res, String key) {
            byte[] bs = parseHexStr2Byte(res);
            for (int i = 0; i < bs.length; i++) {
                bs[i] = (byte) ((bs[i]) ^ key.hashCode());
            }
            return new String(bs);
        }
    
        /**
         * 直接使用异或(第一调用加密,第二次调用解密)
         * @param res 密文
         * @param key 秘钥
         * @return
         */
        public int XOR(int res, String key) {
            return res ^ key.hashCode();
        }
    
        /**
         * 使用Base64进行加密
         * @param res 密文
         * @return
         */
        public String Base64Encode(String res) {
            return Base64.encode(res.getBytes());
        }
    
        /**
         * 使用Base64进行解密
         * @param res
         * @return
         */
        public String Base64Decode(String res) {
            return new String(Base64.decode(res));
        }
    }

     

    展开全文
  • 经过本人修改,简化并完善了别人的代码,使其更加的容易理解和学习! 此为一个完整的项目,...功能:服务端随机生成密钥,JS用公钥加密,服务端用私钥解密。用到的JS加密文件是从官网下载的最新版,速度快,稳定性好!
  • java加密解密

    2013-10-18 11:36:20
    java加密解密
  • 针对java对数据的加密解密
  • 主要介绍了java常用工具类之DES和Base64加密解密类,需要的朋友可以参考下
  • Java加密解密工具类

    千次阅读 2018-05-05 20:25:43
    工具类作用域 ...由于接触到的项目有这么一个要求,超级管理员在页面填写的数据库帐号密码要保存到后台,保存的不能是明文,要是密文,如果取出的话先进行解密再返回前端,于是这个工具类就产生了。 ...

    工具类作用域

    现在不管web或者后端的一些项目里,难免要对数据进行加密,往简单了讲,前端要将用户的密码传送到后台数据库进行保存,后台保存的肯定不能是明文,要在插入数据库之前,将传入的密码进行一次加密,再存入到数据库里

    由于接触到的项目有这么一个要求,超级管理员在页面填写的数据库帐号密码要保存到后台,保存的不能是明文,要是密文,如果取出的话先进行解密再返回前端,于是这个工具类就产生了。

    工具类代码

    import org.apache.commons.codec.binary.Base64;
    
    import javax.crypto.Cipher;
    import javax.crypto.KeyGenerator;
    import java.security.Key;
    import java.security.SecureRandom;
    
    /**
     * DES加密解密工具类
     *
     * @Author: ChenBin
     * @Date: 2018/5/4/0004 11:49
     */
    public class CryptoUtil {
        private static Key DEFAULT_KEY;
        /**
         * 默认密钥
         */
        private static final String DEFAULT_SECRET_KEY = "1qaz2wsx3edc$RFV%TGB^YHN&UJM";
        /**
         * 加密模式
         */
        private static final String DES = "DES";
        /**
         * 加密解密格式
         */
        private static final String format = "DES/ECB/PKCS5Padding";
    
        /**
         * 优先加载获得key
         */
        static {
            DEFAULT_KEY = obtainKey(DEFAULT_SECRET_KEY);
        }
    
        /**
         * 获得key
         **/
        private static Key obtainKey(String key) {
            //如果key等于null 使用默认密钥
            if (key == null) {
                return DEFAULT_KEY;
            }
            KeyGenerator generator = null;
            try {
                generator = KeyGenerator.getInstance(DES);
                //防止linux下 随机生成key
                SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
                secureRandom.setSeed(key.getBytes("UTF-8"));
                generator.init(secureRandom);
            } catch (Exception e) {
                e.printStackTrace();
            }
    
            return generator.generateKey();
        }
    
    
    
        /**
         * null key 加密 使用默认密钥加密
         * String明文输入,String密文输出
         */
        public static String encode(String str) {
            return encode(null, str);
        }
    
        /**
         * 加密
         * String明文输入,String密文输出
         */
        public static String encode(String key, String str) {
            return Base64.encodeBase64URLSafeString(obtainEncode(key, str.getBytes()));
            // return Hex.encodeHexString(obtainEncode(key, str.getBytes()));
            // 可以转化为16进制数据
        }
    
        /**
         * null key 解密 使用默认密钥解密
         * 以String密文输入,String明文输出
         */
        public static String decode(String str) {
            return decode(null, str);
        }
    
        /**
         * 解密
         * 以String密文输入,String明文输出
         */
        public static String decode(String key, String str) {
            return new String(obtainDecode(key, Base64.decodeBase64(str)));
            // 可以转化为16进制的数据
    //      try {
    //          return new String(obtainDecode(key, Hex.decodeHex(str.toCharArray())));
    //      } catch (DecoderException e) {
    //          // TODO Auto-generated catch block
    //          e.printStackTrace();
    //      }
        }
    
    
        /**
         * 底层加密方法
         * 以byte[]明文输入,byte[]密文输出
         */
        private static byte[] obtainEncode(String key, byte[] str) {
            byte[] byteFina = null;
            Cipher cipher;
            try {
                Key key1 = obtainKey(key);
                cipher = Cipher.getInstance(format);
                cipher.init(Cipher.ENCRYPT_MODE, key1);
                byteFina = cipher.doFinal(str);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return byteFina;
        }
    
        /**
         * 底层解密方法
         * 以byte[]密文输入,以byte[]明文输出
         */
        private static byte[] obtainDecode(String key, byte[] str) {
            Cipher cipher;
            byte[] byteFina = null;
            try {
                Key key1 = obtainKey(key);
                cipher = Cipher.getInstance(format);
                cipher.init(Cipher.DECRYPT_MODE, key1);
                byteFina = cipher.doFinal(str);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return byteFina;
        }
    
    }

    采用的是DES加密的方式,这个工具类复制过去基本就能直接用的,演示一下

    public static void main(String[] args) {
            String key = "ruxuanwo";
            String content = "abc123";
            System.out.println("加密前:" + content);
            String a = CryptoUtil.encode(key, content);
            System.out.println("加密后:" + a);
            String b = CryptoUtil.decode(key, a);
            System.out.println("解密后:" + b);
        }

    效果

    加密前:abc123
    加密后:qqmD0mR5KYc
    解密后:abc123  
    展开全文
  • 一个Base64.java加密解密类文件,对字符串或文件进行Base64编码的加密或解密,这个类可实现此种功能。Base64应该算是比较常用的加密方法了,不但在Java编程中常见,其它编程语言VC、Delphi、VB等,也都经常用到,这...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 87,718
精华内容 35,087
关键字:

java加密解密

java 订阅