精华内容
下载资源
问答
  • oracle DES加密解密Java DES加密解密

    千次阅读 2021-06-14 14:55:04
    oracleDES加密函数 create or replace function encrypt_des(p_text varchar2, p_key varchar2) return varchar2 is v_text varchar2(4000); v_enc varchar2(4000); raw_input RAW(128) ; key_input RAW(128) ...

    有时间加密信息里会包含特殊字符,DES在处理特殊字符的时候会报错

    我的处理是先把内容转化成base64再去加密DES 

    内容转换成 base64

    CREATE OR REPLACE function
    encrypt_base64(p_text varchar2) return varchar2 is
        v_enc varchar2(8000);
        begin
        v_enc := utl_raw.cast_to_varchar2(utl_encode.base64_encode(utl_raw.cast_to_raw(p_text)));
        return v_enc;
    end;

    base64 转换回内容 

    CREATE OR REPLACE function 
    decrypt_base64(p_text varchar2) return varchar2 is
        v_enc varchar2(4000);
        begin
        v_enc := utl_raw.cast_to_varchar2(utl_encode.base64_decode(utl_raw.cast_to_raw(p_text)));
        return v_enc;
    end;

    oracle DES加密函数

    CREATE OR REPLACE function encrypt_des(p_text varchar2, p_key varchar2)
    return varchar2 
    is
        v_text varchar2(8000);
        v_enc  varchar2(8000);
        v_source varchar2(8000);
        raw_input RAW(256) ;
        key_input RAW(256) ;
        decrypted_raw RAW(4048);
    begin
        v_text := rpad( encrypt_base64(p_text), (trunc(length(encrypt_base64(p_text))/8)+1)*8, chr(0));
        raw_input := UTL_RAW.CAST_TO_RAW(v_text);
        key_input := UTL_RAW.CAST_TO_RAW(p_key);    
        dbms_obfuscation_toolkit.DESEncrypt(input => raw_input,key => key_input,encrypted_data =>decrypted_raw);
        v_enc := rawtohex(decrypted_raw);
        dbms_output.put_line(v_enc);
        return v_enc;
    end;

    oracle DES解密函数

    CREATE OR REPLACE function decrypt_des(p_text varchar2,p_key varchar2) return varchar2 is
        v_text varchar2(2000);
    begin
       IF p_text is null or p_text='' THEN  
           return  '';
       ELSE
          begin 
             dbms_obfuscation_toolkit.DESDECRYPT(input_string => UTL_RAW.CAST_TO_varchar2(p_text),key_string =>p_key,decrypted_string=> v_text);
             v_text := rtrim(v_text,chr(0));
             dbms_output.put_line(v_text);
             return decrypt_base64(v_text);
          end;
       END IF;
    end;

     

    Java DES加密解密

    
    import lombok.extern.slf4j.Slf4j;
    import org.apache.commons.codec.binary.Hex;
    
    import javax.crypto.*;
    import javax.crypto.spec.DESKeySpec;
    import javax.crypto.spec.IvParameterSpec;
    import javax.xml.bind.DatatypeConverter;
    
    @Slf4j
    public class DESUtil {
    
        public static final String originKey = "密匙";
    
        public static void main(String[] args) throws Exception {
    //        // 明文
            String plainText = "测试";
            log.info("明文---{}---" , plainText);
            String a = encrypt(plainText);
            log.info("加密---{}---" , a);
            log.info("解密---{}---" , decryptValue(a));
        }
    
        /**
         * 加密
         * @param plainText
         * @return
         * @throws Exception
         */
        public static String encrypt(String plainText) throws Exception{
            DESKeySpec desKey;
            SecretKey securekey;
            Cipher cipher;
            try {
                desKey = new DESKeySpec(originKey.getBytes());
                securekey = SecretKeyFactory.getInstance("DES").generateSecret(desKey);
                cipher = Cipher.getInstance("DES/CBC/NoPadding");
                cipher.init(Cipher.ENCRYPT_MODE, securekey, new IvParameterSpec(new byte[8]));
                byte[] inBytes = new byte[((int) (plainText.length() / 8) + 1) * 8];
                for (int i = 0; i < plainText.length(); i++) {
                    inBytes[i] = plainText.getBytes()[i];
                }
                byte[] enBytes = cipher.doFinal(inBytes);
                String hexStr = DatatypeConverter.printHexBinary(enBytes);
                return hexStr;
    
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
    
            return null;
        }
    
        /**
         * 解密
         * @param encode
         * @return
         * @throws Exception
         */
        public static String decryptValue(String encode){
            DESKeySpec desKey;
            SecretKey securekey;
            Cipher cipher;
            try {
                desKey = new DESKeySpec(originKey.getBytes());
                securekey = SecretKeyFactory.getInstance("DES").generateSecret(desKey);
                cipher = Cipher.getInstance("DES/CBC/NoPadding");
                cipher.init(Cipher.DECRYPT_MODE, securekey, new IvParameterSpec(new byte[8]));
                byte[] decryptBytes = cipher.doFinal(Hex.decodeHex(encode.toCharArray()));
                return new String(decryptBytes).trim();
    
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            return null;
        }
    }
    
    
    
    

    展开全文
  • Java批量加密解密文件简单小程序

    千次阅读 2013-07-02 12:26:16
    今天突然想起来要把我的一些文件(文本,图片文件等都可以)给加密了,那就写了一个加密解密的小程序,并不牵涉什么很厉害的算法(所以大牛勿喷),就是把一些数据加减一个固定数这么简单加密解密,不过还是很实用...

           今天突然想起来要把我的一些文件(文本,图片文件等都可以)给加密了,那就写了一个加密解密的小程序,并不牵涉什么很厉害的算法(所以大牛勿喷),就是把一些数据加减一个固定数这么简单的加密解密,不过还是很实用的,可以批量的把当前目录下的所有文件给加密了,同时可以用解密文件把加密后的文件给解密了,程序很简单就不多解释了,很基础但扩展性和参考性还是很高的,先上图,后上源码:


    运行加密文件lock.java,提示输入加密秘钥,输入任意“数字”即可,但要记住啊,因为解密时要输入这个秘钥,否者是解不开的,然后回车,就可加密,当加密成功会有提示输出“加密成功”


    当加密成功后,我们就可发现java文件夹(包括子文件夹)下的所有文件(不包括程序文件)都有一个新文件产生文件名+Lock,这就是加密后的文件,打开是乱码,只有对其再解密才行。


    解密的和加密的类似,故不写了,直接写源代码(代码很简单,而且我已经加注释,就不多解释了):

    加密文件Lock.java

    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Scanner;
    
    public class Lock{
    
    	/**
    	 * @param args
    	 */
    	private static List<String> listPath=null;//源文件地址
    	private static List<String> listNew=null;//加密后新文件地址
    	private static int lock_Num=0;//加密的密钥
    	public static void main(String[] args) throws IOException{
    		Scanner sc = new Scanner(System.in); 
    		listPath = new ArrayList<String>();
    		listNew = new ArrayList<String>();
    
            System.out.print("加密秘钥:");
            lock_Num = sc.nextInt(); 
    		//System.out.println(System.getProperty("user.dir"));//user.dir指定了当前的路径
            getFile(System.getProperty("user.dir"));
    		preWork();
    		lockFile();
    	}
    	 //取得当前文件夹下的所有文件的路径和名称(不包括加密解密文件)
    	   private static void getFile(String path){   
    	        // get file list where the path has   
    	        File file = new File(path);   
    	        // get the folder list   
    	        File[] array = file.listFiles();   
    	          
    	        for(int i=0;i<array.length;i++){   
    	            if(array[i].isFile()){
    					if(!(array[i].getName().startsWith("Lock")||array[i].getName().startsWith("UnLock"))){
    	            	listPath.add(array[i].getPath());
    					//listName.add(array[i].getName());
    					} 
    	            }else if(array[i].isDirectory()){   
    	                getFile(array[i].getPath());   
    	            }   
    	        }   
    	    }
    		//Creak new Files to save 预处理,取得加密后新文件的保存地址 
    		private static void preWork(){
    			for(int i=0;i<listPath.size();i++){
    			String splitF[] =listPath.get(i).split("\\.");
                listNew.add(splitF[0]+"Lock"+"."+splitF[1]);
                }
    		}
            //加密
    		public static void lockFile() throws IOException{
             for(int i=0;i<listPath.size();i++){
    		    File soure = new File(listPath.get(i));
    			File save = new File(listNew.get(i));
                FileInputStream fis = new FileInputStream(soure);
    			FileOutputStream fos = new FileOutputStream(save);
    			int b = 0;
    			while ((b = fis.read()) != -1) {
    				fos.write(b - lock_Num);
    				fos.flush();
    			}
    			fos.close();
    			fis.close();
    
    		 }
    		 System.out.println("加密完成");
    		}
    
    }

    解密文件UnLock.java


    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Scanner;
    
    public class UnLock{
    
    	/**
    	 * @param args
    	 */
    	private static List<String> listPath=null;//保存源文件地址
    	private static List<String> listNew=null;//保存解密新文件地址
    	private static int unLock_Num=0;//解密秘钥
    	public static void main(String[] args) throws IOException{
    		Scanner sc = new Scanner(System.in); 
    		listPath = new ArrayList<String>();
    		listNew = new ArrayList<String>();
    
            System.out.print("解密秘钥:");
            unLock_Num = sc.nextInt(); 
    		//System.getProperty("user.dir") user.dir指定了当前的路径
            getFile(System.getProperty("user.dir"));
    		preWork();
    		unLockFile();
    	}
    	   //取得当前文件夹下的所有文件的路径和名称(不包括加密解密文件)
    	   private static void getFile(String path){   
    	        // get file list where the path has   
    	        File file = new File(path);   
    	        // get the folder list   
    	        File[] array = file.listFiles();   
    	          
    	        for(int i=0;i<array.length;i++){   
    	            if(array[i].isFile()){
    					if(!(array[i].getName().startsWith("Lock")||array[i].getName().startsWith("UnLock"))){
    	            	listPath.add(array[i].getPath());
    					//listName.add(array[i].getName());
    					} 
    	            }else if(array[i].isDirectory()){   
    	                getFile(array[i].getPath());   
    	            }   
    	        }   
    	    }
    		//Creak new Files to save 预处理,取得解密后新文件的保存地址
    		private static void preWork(){
    			for(int i=0;i<listPath.size();i++){
    			String splitF[] =listPath.get(i).split("\\.");
                listNew.add(splitF[0]+"UnLock"+"."+splitF[1]);
                }
    		}
            //解密
    		public static void unLockFile() throws IOException{
             for(int i=0;i<listPath.size();i++){
    		    File soure = new File(listPath.get(i));
    			File save = new File(listNew.get(i));
                FileInputStream fis = new FileInputStream(soure);
    			FileOutputStream fos = new FileOutputStream(save);
    			int b = 0;
    			while ((b = fis.read()) != -1) {
    				fos.write(b + unLock_Num);
    				fos.flush();
    			}
    			fos.close();
    			fis.close();
    
    		 }
    		 System.out.println("解密完成");
    		}
    
    }


    展开全文
  • Java实现DES加密解密

    万次阅读 2018-11-09 16:27:01
    DES(Data Encryption Standard)是一种对称加密算法,所谓对称加密就是加密解密都是使用同一个密钥。 加密原理: DES 使用一个 56 位的密钥以及附加的 8 位奇偶校验位,产生最大 64 位的分组大小。这是一个迭代的...

    DES(Data Encryption Standard)是一种对称加密算法,所谓对称加密就是加密和解密都是使用同一个密钥

    加密原理:

    DES 使用一个 56 位的密钥以及附加的 8 位奇偶校验位,产生最大 64 位的分组大小。这是一个迭代的分组密码,使用 Feistel 技术,将其中加密的文本块分成两半,实现了子密钥对其中一半应用循环功能,然后将输出与另一半进行"异或"运算;接着交换这两半,这一过程会继续下去,但最后一个循环不交换。DES 使用 16 个循环,使用异或,置换,代换,移位操作四种基本运算。

    不过,DES已可破解,所以针对保密级别特别高的数据推荐使用非对称加密算法。

    下面介绍基于Java实现的DES加解密方法,该方法同样适用于Android平台,使用的是JDK1.8。

    public class DESUtil {
    
        /**
         * 偏移变量,固定占8位字节
         */
        private final static String IV_PARAMETER = "12345678";
        /**
         * 密钥算法
         */
        private static final String ALGORITHM = "DES";
        /**
         * 加密/解密算法-工作模式-填充模式
         */
        private static final String CIPHER_ALGORITHM = "DES/CBC/PKCS5Padding";
        /**
         * 默认编码
         */
        private static final String CHARSET = "utf-8";
    
        /**
         * 生成key
         *
         * @param password
         * @return
         * @throws Exception
         */
        private static Key generateKey(String password) throws Exception {
            DESKeySpec dks = new DESKeySpec(password.getBytes(CHARSET));
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ALGORITHM);
            return keyFactory.generateSecret(dks);
        }
    
    
        /**
         * DES加密字符串
         *
         * @param password 加密密码,长度不能够小于8位
         * @param data 待加密字符串
         * @return 加密后内容
         */
        public static String encrypt(String password, String data) {
            if (password== null || password.length() < 8) {
                throw new RuntimeException("加密失败,key不能小于8位");
            }
            if (data == null)
                return null;
            try {
                Key secretKey = generateKey(password);
                Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
                IvParameterSpec iv = new IvParameterSpec(IV_PARAMETER.getBytes(CHARSET));
                cipher.init(Cipher.ENCRYPT_MODE, secretKey, iv);
                byte[] bytes = cipher.doFinal(data.getBytes(CHARSET));
    
                //JDK1.8及以上可直接使用Base64,JDK1.7及以下可以使用BASE64Encoder
                //Android平台可以使用android.util.Base64
                return new String(Base64.getEncoder().encode(bytes));
    
            } catch (Exception e) {
                e.printStackTrace();
                return data;
            }
        }
    
        /**
         * DES解密字符串
         *
         * @param password 解密密码,长度不能够小于8位
         * @param data 待解密字符串
         * @return 解密后内容
         */
        public static String decrypt(String password, String data) {
            if (password== null || password.length() < 8) {
                throw new RuntimeException("加密失败,key不能小于8位");
            }
            if (data == null)
                return null;
            try {
                Key secretKey = generateKey(password);
                Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
                IvParameterSpec iv = new IvParameterSpec(IV_PARAMETER.getBytes(CHARSET));
                cipher.init(Cipher.DECRYPT_MODE, secretKey, iv);
                return new String(cipher.doFinal(Base64.getDecoder().decode(data.getBytes(CHARSET))), CHARSET);
            } catch (Exception e) {
                e.printStackTrace();
                return data;
            }
        }
    
        /**
         * DES加密文件
         *
         * @param srcFile  待加密的文件
         * @param destFile 加密后存放的文件路径
         * @return 加密后的文件路径
         */
        public static String encryptFile(String password, String srcFile, String destFile) {
    
            if (password== null || password.length() < 8) {
                throw new RuntimeException("加密失败,key不能小于8位");
            }
            try {
                IvParameterSpec iv = new IvParameterSpec(IV_PARAMETER.getBytes(CHARSET));
                Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
                cipher.init(Cipher.ENCRYPT_MODE, generateKey(key), iv);
                InputStream is = new FileInputStream(srcFile);
                OutputStream out = new FileOutputStream(destFile);
                CipherInputStream cis = new CipherInputStream(is, cipher);
                byte[] buffer = new byte[1024];
                int r;
                while ((r = cis.read(buffer)) > 0) {
                    out.write(buffer, 0, r);
                }
                cis.close();
                is.close();
                out.close();
                return destFile;
            } catch (Exception ex) {
                ex.printStackTrace();
            }
            return null;
        }
    
        /**
         * DES解密文件
         *
         * @param srcFile  已加密的文件
         * @param destFile 解密后存放的文件路径
         * @return 解密后的文件路径
         */
        public static String decryptFile(String password, String srcFile, String destFile) {
            if (password== null || password.length() < 8) {
                throw new RuntimeException("加密失败,key不能小于8位");
            }
            try {
                File file = new File(destFile);
                if (!file.exists()) {
                    file.getParentFile().mkdirs();
                    file.createNewFile();
                }
                IvParameterSpec iv = new IvParameterSpec(IV_PARAMETER.getBytes(CHARSET));
                Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
                cipher.init(Cipher.DECRYPT_MODE, generateKey(key), iv);
                InputStream is = new FileInputStream(srcFile);
                OutputStream out = new FileOutputStream(destFile);
                CipherOutputStream cos = new CipherOutputStream(out, cipher);
                byte[] buffer = new byte[1024];
                int r;
                while ((r = is.read(buffer)) >= 0) {
                    cos.write(buffer, 0, r);
                }
                cos.close();
                is.close();
                out.close();
                return destFile;
            } catch (Exception ex) {
                ex.printStackTrace();
            }
            return null;
        }
    }
    

     

    展开全文
  • Java 加密解密基础

    2016-05-27 23:20:51
    Java 加密解密基础 Java byte数组与十六进制字符串互转 Java BASE64加密解密 Java 加密解密之消息摘要算法(MD5 SHA MAC) Java 加密解密之对称加密算法DES Java 加密解密之对称加密算法DESede Java 加密解密...

    Java加密解密系列

    Java 加密解密基础
    Java byte数组与十六进制字符串互转
    Java BASE64加密解密
    Java 加密解密之消息摘要算法(MD5 SHA MAC)
    Java 加密解密之对称加密算法DES
    Java 加密解密之对称加密算法DESede
    Java 加密解密之对称加密算法AES
    Java 加密解密之对称加密算法PBE

    Java 加密解密基础

    密码学是研究编制密码和破译密码的技术科学。研究密码变化的客观规律,应用于编制密码以保守通信秘密的,称为编码学;应用于破译密码以获取通信情报的,称为破译学,总称密码学。

    密码学常用术语

    明文: 待加密数据。
    密文: 明文经过加密后数据。
    加密: 将明文转换为密文的过程。
    加密算法: 将明文转换为密文的转换算法。
    加密密钥: 通过加密算法进行加密操作的密钥。
    解密: 将密文转换为铭文的过程。
    解密算法: 将密文转换为明文的转换算法。
    解密密钥: 通过解密短发进行解密操作的密钥。

    密码学分类

    1. 按时间分
      • 古典密码:以字符为基本加密单元。
      • 现代密码:以信息块为基本加密单元。
    2. 按保密内容的算法划分
      • 受限制算法:算法的保密性基于保持算法的秘密。
      • 基于密钥算法:算法的保密性基于对密钥的保密。
    3. 按密钥体制划分
      • 对称密码体制:也叫单钥或私钥密码体制,加密过程与解密过程使用同一套密钥。对应的算法就是对称加密算法,例如 DES , AES 。
      • 非对称密码体制:也叫双钥或公钥密码体制,加密过程与解密过程使用不同的密钥。对应的算法就是非对称加密算法,例如 RSA 。
    4. 按明文处理方式划分

      • 流密码:也称为序列密码,加密时每次加密一位或者一个字节的明文。例如 RC4 算法。
      • 分组密码:加密时将明文分成固定长度的组,用同一个密钥和算法对每一组进行加密输出也是固定长度的明文。当最后一组大小不满足指定的分组大小时,
        有两种处理模式:

        • 无填充模式,直接对剩余数据进行加密,此组加密后大小与剩余数据有关;
        • 有填充模式,对于不满足指定长度分组的进行数据填充;如果恰巧最后一组数据与指定分组大小相同,那么直接添加一个指定大小的分组;填充的最后一个字节记录了填充的字节数。

    分组密码工作模式简介

    1. 电子密码本模–ECB
      将明文的各个分组独立的使用相同的密钥进行加密,这种方式加密时各分组的加密独立进行互不干涉,因而可并行进行。同样因为各分组独立加密的缘故,相同的明文分组加密之后具有相同的密文。该模式容易暴露明文分组的统计规律和结构特征。不能防范替换攻击。
      其实照实现来看, ECB 的过程只是把明文进行分组,然后分别加密,最后串在一起的过程。当消息长度超过一个分组时,不建议使用该模式。在每个分组中增加随机位 ( 如 128 位分组中 96 位为有效明文, 32 位的随机数 ) 则可稍微提高其安全性 , 但这样无疑造成了加密过程中数据的扩张。
      优点 :

      • 简单;
      • 有利于并行计算;
      • 误差不会被传送;

      缺点 :

      • 不能隐藏明文的模式;
      • 可能对明文进行主动攻击;
    2. 密码分组链接模 – CBC

      需要一个初始化向量 IV ,第一组明文与初始化向量进行异或运算后再加密,以后的每组明文都与前一组的密文进行异或运算后再加密。 IV 不需要保密,它可以明文形式与密文一起传送。
      优点:

      • 不容易主动攻击,安全性好于ECB,适合传输长度长的报文,是SSL、IPSec的标准。

      缺点:

      • 不利于并行计算;
      • 误差传递;
      • 需要初始化向量IV
    3. 密文反馈模式–CFB

      需要一个初始化向量IV ,加密后与第一个分组明文进行异或运算产生第一组密文,然后对第一组密文加密后再与第二组明文进行异或运算缠身第二组密文,一次类推,直到加密完毕。
      优点:

      • 隐藏了明文模式;
      • 分组密码转化为流模式;
      • 可以及时加密传送小于分组的数据;

      缺点 :

      • 不利于并行计算;
      • 误差传送:一个明文单元损坏影响多个单元;
      • 唯一的IV;
    4. 输出反馈模式–OFB

      需要一个初始化向量IV ,加密后得到第一次加密数据,此加密数据与第一个分组明文进行异或运算产生第一组密文,然后对第一次加密数据进行第二次加密,得到第二次加密数据,第二次加密数据再与第二组明文进行异或运算产生第二组密文,一次类推,直到加密完毕。
      优点 :

      • 隐藏了明文模式;
      • 分组密码转化为流模式;
      • 可以及时加密传送小于分组的数据;

      缺点 :

      • 不利于并行计算;
      • 对明文的主动攻击是可能的 ;
      • 误差传送:一个明文单元损坏影响多个单元 ;
    5. 计数器模式–CTR

      使用计数器,计数器初始值加密后与第一组明文进行异或运算产生第一组密文,
      计数器增加,然后,加密后与下一组明文进行异或运算产生下一组密文,以此类推,直到加密完毕
      优点 :

      • 可并行计算 ;
      • 安全性至少与CBC 模式一样好 ;
      • 加密与解仅涉及密码算法的加密 ;

      缺点 :

      • 没有错误传播,不易确保数据完整性 ;
    6. 分组密码填充方式简介

      • PKCS5 :
        填充字符串由一个值为 5 的字节序列组成,每个字节填充该字节序列的长度。 明确定义 Block 的大小是 8 位
      • PKCS7 :
        填充字符串由一个值为 7 的字节序列组成,每个字节填充该字节序列的长度。 对于块的大小是不确定的,可以在 1-255 之间
      • ISO10126:
        填充字符串由一个字节序列组成,此字节序列的最后一个字节填充字节序列的长度,其余字节填充随机数据。
    展开全文
  • package com.doshr.app.common.util; import java.io.UnsupportedEncodingException; import ... public class ArcFour {  /**  * 加密解密 参数为byte[]数组(byte[] da
  • JavaDES加密解密算法

    千次阅读 2014-05-25 16:19:18
    JavaDES加密解密算法 import java.nio.ByteBuffer; import java.security.SecureRandom; import javax.crypto.Cipher; import javax.crypto.SecretKey; import javax.crypto.SecretKeyFactory; import javax....
  • Java常用加密解密核心算法

    千次阅读 2020-08-24 16:55:38
    最近面试被问到了一些常见的加密解密算法,特此整理记录。 加密算法我们整体可以分为:可逆加密算法和不可逆加密算法。可逆加密算法又可以分为:对称加密算法和非对称加密算法。 一、不可逆加密算法 常见的不可逆...
  • Java简单实现DES加密解密算法

    千次阅读 2019-04-02 11:14:30
    Java简单实现DES加密解密算法 文章目录Java简单实现DES加密解密算法DES算法介绍实现相关java类代码实现 DES算法介绍 DEC加密算法属于对称加密,即利用指定的密钥,按照密码的长度截取数据,分成数据块,和密钥进行...
  • Java中文加密解密

    千次阅读 2017-12-08 17:00:02
    import java.io.UnsupportedEncodingException; import java.math.BigInteger; public class ChineseTrans { public static void main(String[] args) throws UnsupportedEncodingException { String Mtext="ninhao
  • Java BASE64加密解密

    千次阅读 2016-05-27 23:02:22
    Java加密解密系列 Java 加密解密基础 Java byte数组与十六进制字符串互转 Java BASE64加密解密 Java 加密解密之消息摘要算法(MD5 SHA MAC) Java 加密解密之对称加密算法DES Java 加密解密之对称加密算法...
  • JAVA加密C++解密简单方法

    千次阅读 2015-11-16 16:10:25
    java加密C++解密:【key可以随机生成】需要KEY需要一样(如果需要更为复杂的加密可以在加密器初始化是传入一个盐值,具体实现方法可以网上搜很多),java加密的填充方式 和C++解密填充方式要一样,其中加密解密返回...
  • Java RSA加密解密

    万次阅读 2017-04-10 12:23:30
    Exception in thread “main” at sun.security.rsa.RSAPadding.unpadV15(RSAPadding.java:380) at sun.security.rsa.RSAPadding.unpad(RSAPadding.java:291) at com.sun.crypto.provider.RSACipher.do
  • java ECC 加密 解密算法

    千次阅读 2018-12-18 15:55:40
    公司最近需要使用非对称加密算法进行数据加密,本来打算采用RSA的,但是CTO强制使用ECC加密算法;没办法,硬着头皮整吧! 网上的千篇一律,写法都差不多,但是有一个问题,公钥和私钥永远不会发生变法,这就比较...
  • # 使用aes算法,进行加密解密操作 # 为跟java实现同样的编码,注意PADDING符号自定义 def encrypt_aes(sourceStr): generator = AES.new(key, AES.MODE_CBC, iv) crypt = generator.encrypt(pad_it(sourceStr)) ...
  • java DES加密解密文件

    千次阅读 2012-08-16 16:28:44
    在android开发中或者java开发中,经常用一些加密或者解密文件的,下面是我最近测试的一个DES加密解密文件的方式,记录一下,防止以后忘记了! 下面直接贴代码把,详细的注释都写有: package com.spring.des; ...
  • java密码加密解密

    千次阅读 热门讨论 2018-10-26 10:44:37
    package ... import java.security.Key; import java.security.NoSuchAlgorithmException; import java.security.SecureRandom; import javax.crypto.Cipher; import javax.crypto.KeyGenera...
  • Java AES加密解密

    千次阅读 2019-03-21 15:22:58
    import java.io.IOException; import java.io.UnsupportedEncodingException; import java.security.InvalidKeyException; import java.security.NoSuchAlgorithmException; import java.security.SecureRandom; imp...
  • java AES加密解密

    万次阅读 2012-04-12 22:05:38
    import java.security.InvalidKeyException; import java.security.Key; import java.security.NoSuchAlgorithmException; import javax.crypto.*; import javax.crypto.spec.*; /** * * @author wchun *
  • java汉字加密解密

    千次阅读 2012-06-11 23:14:46
    import java.io.UnsupportedEncodingException; import java.math.BigInteger; public class ChineseTrans { public static void main(String[] args) throws UnsupportedEncodingException { String Mtext="n
  • Java 加密解密之对称加密算法DES

    千次阅读 2016-05-27 23:31:12
    Java 加密解密基础 Java byte数组与十六进制字符串互转 Java BASE64加密解密 Java 加密解密之消息摘要算法(MD5 SHA MAC) Java 加密解密之对称加密算法DES Java 加密解密之对称加密算法DESede Java 加密解密...
  • C#与Java同步加密解密DES算法

    千次阅读 2016-12-30 10:21:10
    在实际项目中,往往前端和后端使用不同的语言。比如使用C#开发客户端,使用Java开发服务器端。有时出于安全性考虑需要将字符加密传输后,由服务器解密获取。本文介绍一种采用DES算法的C#与Java同步加密解密的代码。
  • Java 加密解密之对称加密算法DESede

    千次阅读 2016-05-27 23:33:06
    Java 加密解密基础 Java byte数组与十六进制字符串互转 Java BASE64加密解密 Java 加密解密之消息摘要算法(MD5 SHA MAC) Java 加密解密之对称加密算法DES Java 加密解密之对称加密算法DESede Java 加密解密...
  • Java 加密解密之对称加密算法AES

    千次阅读 2016-05-27 23:35:44
    Java 加密解密基础 Java byte数组与十六进制字符串互转 Java BASE64加密解密 Java 加密解密之消息摘要算法(MD5 SHA MAC) Java 加密解密之对称加密算法DES Java 加密解密之对称加密算法DESede Java 加密解密...
  • java DES 加密解密DEMO

    千次阅读 2011-04-21 15:40:00
    import java.security.SecureRandom; import javax.crypto.Cipher; import javax.crypto.SecretKey; import javax.crypto.SecretKeyFactory;... * 加解密接口,根据参数flag进行加密解密操作
  • JAVA各种加密解密方式

    万次阅读 多人点赞 2019-08-30 15:59:43
    之前有兴趣研究了一下java的加密与解密的方法,发现市面上有好多种加密解密方式,在这里整理了一下。 目录 1.BASE64加密/解密 2.MD5(Message Digest Algorithm)加密/解密 3.DES(Data Encryption Standard)...
  • java加密解密研究

    2014-07-19 15:25:54
    java加密解密研究2、Bouncy Castle和Commons Codec加密组件 java加密解密研究3、Base64算法 java加密解密研究4、UrlBase64算法 java加密解密研究5、消息摘要算法简介 java加密解密研究6...
  • java实现RSA的简单加密解密

    万次阅读 热门讨论 2018-01-18 09:55:53
    RSAUtil   ... ...import java.io.IOException; import java.security.KeyFactory; import java.security.KeyPair; import java.security.KeyPairGenerator; import java.security.PrivateKey;...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 84,223
精华内容 33,689
关键字:

java简单加密解密

java 订阅