精华内容
下载资源
问答
  • java密码加密解密

    2018-10-26 11:10:03
    java代码编写的密码加密类,可以解密。根据自己需求改变秘钥,更安全。windows和Linux环境密文不一致问题解决方案见我的博客https://blog.csdn.net/yang1393214887/article/details/83411051#comments
  • java密码加密解密算法代码实现

    热门讨论 2011-12-29 14:10:28
    例如,在Java Persistence系统Hibernate中,就采用了Base64来将一个较长的唯一标识符(一般为128-bit的UUID)编码为一个字符串,用作HTTP表单和HTTP GET URL中的参数。在其他应用程序中,也常常需要把二进制数据编码...
  • 主要为大家详细介绍了java实现置换密码加密解密,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 主要为大家详细介绍了java实现仿射密码加密解密的相关资料,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • Java换位密码加密解密

    2014-01-17 19:43:44
    Java图形用户界面实现的“换位密码算法的加密解密”算法
  • 由于数据库连接池的用户密码需要加密,并且在安装包中存在有连接数据库,因此需要sping重写、用户密码在java和c#加密解密等 ...sping配置重写思路_用户密码加密解密JAVA和C#加密解密同步)sping2.0以上
  • java密码加密解密

    千次阅读 2013-04-27 11:18:08
    以下两个类可以很方便的完成字符串的加密解密加密:CryptHelper.encrypt(password) 解密:CrypHelper.decrypt(password)   代码如下: CryptUtils.java package com.gdie.lab.crypt; import java.io....

    以下两个类可以很方便的完成字符串的加密和解密:

    加密:CryptHelper.encrypt(password)

    解密:CrypHelper.decrypt(password)

     

    代码如下:

    CryptUtils.java

    package com.gdie.lab.crypt;
    
    import java.io.IOException;
    
    import javax.crypto.Cipher;
    import javax.crypto.KeyGenerator;
    import javax.crypto.SecretKey;
    
    import com.sun.org.apache.xerces.internal.impl.dv.util.Base64;
    
    
    public class CryptUtils {
    	private static String Algorithm = "DES";
    	private static byte[] DEFAULT_KEY=new byte[] {-53, 122, -42, -88, -110, -123, -60, -74};
    	private static String VALUE_ENCODING="UTF-8";
    
    	
    	/**
    	 * 生成密钥
    	 * 
    	 * @return byte[] 返回生成的密钥
    	 * @throws exception
    	 *             扔出异常.
    	 */
    	public static byte[] getSecretKey() throws Exception {
    		KeyGenerator keygen = KeyGenerator.getInstance(Algorithm);
    		SecretKey deskey = keygen.generateKey();
    		// if (debug ) System.out.println ("生成密钥:"+byte2hex (deskey.getEncoded
    		// ()));
    		return deskey.getEncoded();
    
    	}
    
    	/**
    	 * 将指定的数据根据提供的密钥进行加密
    	 * 
    	 * @param input
    	 *            需要加密的数据
    	 * @param key
    	 *            密钥
    	 * @return byte[] 加密后的数据
    	 * @throws Exception
    	 */
    	public static byte[] encryptData(byte[] input, byte[] key) throws Exception {
    		SecretKey deskey = new javax.crypto.spec.SecretKeySpec(key, Algorithm);
    		// if (debug )
    		// {
    		// System.out.println ("加密前的二进串:"+byte2hex (input ));
    		// System.out.println ("加密前的字符串:"+new String (input ));
    		//
    		// }
    		Cipher c1 = Cipher.getInstance(Algorithm);
    		c1.init(Cipher.ENCRYPT_MODE, deskey);
    		byte[] cipherByte = c1.doFinal(input);
    		// if (debug ) System.out.println ("加密后的二进串:"+byte2hex (cipherByte ));
    		return cipherByte;
    
    	}
    	
    	public static byte[] encryptData(byte[] input) throws Exception {
    		return encryptData(input, DEFAULT_KEY);
    	}
    
    	/**
    	 * 将给定的已加密的数据通过指定的密钥进行解密
    	 * 
    	 * @param input
    	 *            待解密的数据
    	 * @param key
    	 *            密钥
    	 * @return byte[] 解密后的数据
    	 * @throws Exception
    	 */
    	public static byte[] decryptData(byte[] input, byte[] key) throws Exception {
    		SecretKey deskey = new javax.crypto.spec.SecretKeySpec(key, Algorithm);
    		// if (debug ) System.out.println ("解密前的信息:"+byte2hex (input ));
    		Cipher c1 = Cipher.getInstance(Algorithm);
    		c1.init(Cipher.DECRYPT_MODE, deskey);
    		byte[] clearByte = c1.doFinal(input);
    		// if (debug )
    		// {
    		// System.out.println ("解密后的二进串:"+byte2hex (clearByte ));
    		// System.out.println ("解密后的字符串:"+(new String (clearByte )));
    		//
    		// }
    		return clearByte;
    
    	}
    	
    	public static byte[] decryptData(byte[] input) throws Exception {
    		return decryptData(input, DEFAULT_KEY);
    	}
    
    	/**
    	 * 字节码转换成16进制字符串
    	 * 
    	 * @param byte[] b 输入要转换的字节码
    	 * @return String 返回转换后的16进制字符串
    	 */
    	public static String byte2hex(byte[] bytes) {
    		StringBuilder hs = new StringBuilder();
    		for(byte b : bytes)
    			hs.append(String.format("%1$02X", b));
    		return hs.toString();
    	}
    
    	public static byte[] hex2byte(String content) {
    		int l=content.length()>>1;
    		byte[] result=new byte[l];
    		for(int i=0;i<l;i++) {
    			int j=i<<1;
    			String s=content.substring(j, j+2);
    			result[i]=Integer.valueOf(s, 16).byteValue();
    		}
    		return result;
    	}
    	
    	/**
    	 * 将字节数组转换为base64编码字符串
    	 * @param buffer
    	 * @return
    	 */
    	public static String bytesToBase64(byte[] buffer) {
    		//BASE64Encoder en=new BASE64Encoder();
    		return Base64.encode(buffer);
    //		return encoder.encode(buffer);
    	}
    	
    	/**
    	 * 将base64编码的字符串解码为字节数组
    	 * @param value
    	 * @return
    	 * @throws IOException 
    	 */
    	public static byte[] base64ToBytes(String value) throws IOException {
    		//return Base64.decodeToByteArray(value);
    //		System.out.println(decoder.decodeBuffer(value));
    //		return decoder.decodeBuffer(value);
    		return Base64.decode(value);
    	}
    	
    	/**
    	 * 加密给定的字符串
    	 * @param value
    	 * @return 加密后的base64字符串
    	 */
    	public static String encryptString(String value) {
    		return encryptString(value, DEFAULT_KEY);
    	}
    	
    	/**
    	 * 根据给定的密钥加密字符串
    	 * @param value 待加密的字符串
    	 * @param key 以BASE64形式存在的密钥
    	 * @return 加密后的base64字符串
    	 * @throws IOException 
    	 */
    	public static String encryptString(String value, String key) throws IOException {
    		return encryptString(value, base64ToBytes(key));
    	}
    	
    	/**
    	 * 根据给定的密钥加密字符串
    	 * @param value 待加密的字符串
    	 * @param key 字节数组形式的密钥
    	 * @return 加密后的base64字符串
    	 */
    	public static String encryptString(String value, byte[] key) {
    		try {
    			byte[] data=value.getBytes(VALUE_ENCODING);
    			data=CryptUtils.encryptData(data, key);
    			return bytesToBase64(data);
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    			return null;
    		}
    	}
    	
    	/**
    	 * 解密字符串
    	 * @param value base64形式存在的密文
    	 * @return 明文
    	 */
    	public static String decryptString(String value) {
    		return decryptString(value, DEFAULT_KEY);
    	}
    	
    	/**
    	 * 解密字符串
    	 * @param value base64形式存在的密文
    	 * @param key base64形式存在的密钥
    	 * @return 明文
    	 * @throws IOException 
    	 */
    	public static String decryptString(String value, String key) throws IOException {
    		String s=decryptString(value, base64ToBytes(key));
    		return s; 
    	}
    	
    	/**
    	 * 解密字符串
    	 * @param value base64形式存在的密文
    	 * @param key 字节数据形式存在的密钥
    	 * @return 明文
    	 */
    	public static String decryptString(String value, byte[] key) {
    		try {
    			byte[] data=base64ToBytes(value);
    			data=CryptUtils.decryptData(data, key);
    			return new String(data, VALUE_ENCODING);
    		}catch(Exception e) {
    			e.printStackTrace();
    			return null;
    		}
    	}
    }


     

    CryptHelper.java

    package com.gdie.lab.crypt;
    
    import javax.crypto.Cipher;
    import javax.crypto.SecretKey;
    import javax.crypto.SecretKeyFactory;
    import javax.crypto.spec.DESKeySpec;
    import javax.crypto.spec.IvParameterSpec;
    
    import org.springframework.util.DigestUtils;
    
    public class CryptHelper{
    	
    	private static String CRYPT_KEY = "zhongqian";
    	
    	//加密
    	private static Cipher ecip;
    	//解密
    	private static Cipher dcip;
    	
    	static {
    		try {
    			String KEY = DigestUtils.md5DigestAsHex(CRYPT_KEY.getBytes()).toUpperCase();
    			KEY = KEY.substring(0, 8);
    			byte[] bytes = KEY.getBytes();
    			DESKeySpec ks = new DESKeySpec(bytes); 
    			SecretKeyFactory skf = SecretKeyFactory.getInstance("DES"); 
    			SecretKey sk = skf.generateSecret(ks); 
    			IvParameterSpec iv2 = new IvParameterSpec(bytes); 
    
    			ecip = Cipher.getInstance("DES/CBC/PKCS5Padding");
    			ecip.init(Cipher.ENCRYPT_MODE, sk, iv2);
    
    			dcip = Cipher.getInstance("DES/CBC/PKCS5Padding");
    			dcip.init(Cipher.DECRYPT_MODE, sk, iv2);
    		}catch(Exception ex) {
    			ex.printStackTrace();
    		}
    	}
    	
    	public static String encrypt(String content) throws Exception {
    		byte[] bytes = ecip.doFinal(content.getBytes("ascii"));
    		return CryptUtils.byte2hex(bytes);
    	}
    	
    	public static String decrypt(String content) throws Exception {
    		byte[] bytes  = CryptUtils.hex2byte(content);
    		bytes = dcip.doFinal(bytes);
    		return new String(bytes, "ascii");
    	}
    	//test
    	public static void main(String[] args) throws Exception {
    		String password = "gly";
    		String en = encrypt(password);
    		System.out.println(en);
    		System.out.println(decrypt(en));
    		
    	}
    }
    


     

    展开全文
  • Hill密码加密解密java代码-附件资源
  • Java实现仿射密码加密解密

    千次阅读 热门讨论 2019-01-17 13:49:36
    Java实现仿射密码加密解密 仿射密码 加密:将明文转化为对应的数字,如 ‘a’-&gt; 0, ‘b’-&gt;1,…,’1’-&gt;26,’2’-&gt;27,…然后将数字进行仿射运算,求取出来的数字再转化为字符。即 密文=...

    Java实现仿射密码加密解密


    仿射密码
    加密:将明文转化为对应的数字,如 ‘a’-> 0, ‘b’->1,…,’1’->26,’2’->27,…然后将数字进行仿射运算,求取出来的数字再转化为字符。即 密文=(K1*明文+K2)mod36
    解密:密文转化为对应数字,然后进行仿射的逆运算,得到对应数字,然后将其转化为字符明文。解密 K3是K1的乘法逆元

    import java.util.Scanner;
    
    public class Affine{
        public static void main(String[] args) {
            char[] form = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
                    'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '0'
                    , '1', '2', '3', '4', '5', '6', '7', '8', '9'};
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入待加密的明文:");
            String MingWen = sc.nextLine();
            MingWen=MingWen.toUpperCase();//将输入的明文全部大写
            final int K1 = 103;
            final int K2 = 103;
            final int K3 = 7;
            int [] cipherNum=new int[MingWen.length()];//用来存储数字化的密文
            encryption(MingWen,form,K1,K2,cipherNum);
            decryption(form,MingWen,K2,K3,cipherNum);
    
        }
        public static void encryption(String MingWen,char[] form,int K1,int K2,int[] cipherNum){
            //第一步:将明文存入数组
            char[] pla=new char[MingWen.length()];
            for (int i = 0; i <MingWen.length() ; i++) {
                pla[i]=MingWen.charAt(i);
            }//已将明文存入字符数组pla中
            //第二步:通过脚标找到明文中每个字符对应的数,参与加密运算
            int[] MingWenNumber=new int[pla.length];
            for (int i = 0; i <pla.length ; i++) {
                for (int j = 0; j <form.length ; j++) {
                    if (form[j]==pla[i]) {
                        MingWenNumber[i] = j;
                    }
                }
            }
           //通过脚标将明文全部转化为数字
            char[] cipher = new char[MingWen.length()];//cipher密码数组  用来存储密文
            for (int i = 0; i <MingWen.length() ; i++) {
                int a= Math.floorMod((K1*MingWenNumber[i]+K2),36);
                cipherNum[i]=a;
                cipher[i]=form[a];
                //计算密文并存入数组中
            }
            System.out.println("加密结果是:");
            System.out.println(cipher);
        }
    
        public static void decryption(char[] form,String Mingwen,int K2,int K3,int[] cipherNum){
            char[] JieMI=new char[Mingwen.length()];
            for (int i =0;i<Mingwen.length();i++){
                JieMI[i]=form[Math.floorMod(K3*(cipherNum[i]-K2),36)];
            }
            System.out.println("解密结果是:");
            System.out.println(JieMI);
        }
    }
    
    
    展开全文
  • Hill密码加密解密java代码

    千次阅读 2015-07-18 14:26:13
    本篇文章,我要通过java代码实现Hill加密解密。在上一篇,我们通过java代码实现了逆矩阵,这个是实现Hill密码的前提 首先我们实现加密,然后再通过加密的密文来进行解密过程。 1、Hill加密我们将明文"paymoremoney...

    本篇文章,我要通过java代码实现Hill加密解密。

    在上一篇,我们通过java代码实现了逆矩阵,这个是实现Hill密码的前提
    首先我们实现加密,然后再通过加密的密文来进行解密过程。
    

    1、Hill加密

    我们将明文"paymoremoney"通过加密密钥K进行Hill加密 
      |17 17 5 |
    K=|21 18 21|
      |2  2  19|
    每三个字母进行转换,依次转换结束。
    
    private static String getEncrypttext(String plainttext) {
            // TODO Auto-generated method stub
            int temp1 = 0, temp2, temp3;
            StringBuilder cipertext = new StringBuilder();
            for(int i=0; i<plainttext.length(); i+=3) {
                temp1 = key[0][0]*(plainttext.charAt(i) - 'A')
                        + key[0][1]*(plainttext.charAt(i+1) - 'A')
                        + key[0][2]*(plainttext.charAt(i+2) - 'A');
                temp2 = key[1][0]*(plainttext.charAt(i) - 'A')
                        + key[1][1]*(plainttext.charAt(i+1) - 'A')
                        + key[1][2]*(plainttext.charAt(i+2) - 'A');
                temp3 = key[2][0]*(plainttext.charAt(i) - 'A')
                        + key[2][1]*(plainttext.charAt(i+1) - 'A')
                        + key[2][2]*(plainttext.charAt(i+2) - 'A');
                cipertext.append((char)('A'+temp1%26));
                cipertext.append((char)('A'+temp2%26));
                cipertext.append((char)('A'+temp3%26)); 
            }
    
            return cipertext.toString();
        }

    2、Hill解密

    首先我们必须求出逆矩阵,由于里面的数字必须为0-25之间
    所以上一节求逆矩阵不能用,我们使用穷举法。
    
     /*
        这里使用满足逆矩阵与原矩阵相乘必为单位矩阵
     */
     private int[][] getReverseMartrix(int[][] key2) {
            // TODO Auto-generated method stub
            int[][] key = new int[key2.length][key2[0].length];
            for(int num=0; num<3; num++)
                for(int i=0; i<26; i++)
                    for(int j=0; j<26; j++)
                        for(int k=0; k<26; k++) {
                            if((i*17+j*21+k*2)%26 == temp[num%3] 
                                    && ((i*17+j*18+k*2)%26 == temp[(num+2)%3])
                                    && ((i*5+j*21+k*19)%26 == temp[(num+1)%3])) {
                                key[num][0] = i;
                                key[num][1] = j;
                                key[num][2] = k;
                            }
                        }
            return key;
        }
    下面是解密代码
    
      private String getDncrypttext(String ciphertext) {
            // TODO Auto-generated method stub
            int[][] key2 = new int[key.length][key[0].length];
            key2 = getReverseMartrix(key);
            System.out.println("加密密钥逆矩阵为:");
            showMartrix(key2);
            return getDecrypttext(key2, ciphertext);    
        }
    
    
        private String getDecrypttext(int[][] key2, String ciphertext) {
            // TODO Auto-generated method stub
            int temp1, temp2, temp3;
            StringBuilder plainttext = new StringBuilder();
            for(int i=0; i<ciphertext.length(); i+=3) {
                temp1 = key2[0][0]*(ciphertext.charAt(i) - 'A')
                        + key2[0][1]*(ciphertext.charAt(i+1) - 'A')
                        + key2[0][2]*(ciphertext.charAt(i+2) - 'A');
                temp2 = key2[1][0]*(ciphertext.charAt(i) - 'A')
                        + key2[1][1]*(ciphertext.charAt(i+1) - 'A')
                        + key2[1][2]*(ciphertext.charAt(i+2) - 'A');
                temp3 = key2[2][0]*(ciphertext.charAt(i) - 'A')
                        + key2[2][1]*(ciphertext.charAt(i+1) - 'A')
                        + key2[2][2]*(ciphertext.charAt(i+2) - 'A');
                plainttext.append((char)('A'+temp1%26));
                plainttext.append((char)('A'+temp2%26));
                plainttext.append((char)('A'+temp3%26));    
            }
    
            return plainttext.toString();
        }

    这里写图片描述

    最后,需要源代码的,请去云盘下载吧
    Hill密码源代码 链接: http://pan.baidu.com/s/1i3J8BlV 密码: dyeq

    展开全文
  • java_加密解密简单实现
  • Java实现置换密码加密解密

    千次阅读 2018-12-20 15:30:59
    Java实现置换密码加密解密思路代码 思路 置换密码只不过是简单的换位而已,这里写的是一个分组长度为7的置换密码因为所学知识有限,写的比较麻烦,这里先简单介绍一下思路: 1.因为置换密码首先要将其进行分组,这里...

    Java实现置换密码加密解密

    思路

    置换密码只不过是简单的换位而已,这里写的是一个分组长度为7的置换密码因为所学知识有限,写的比较麻烦,这里先简单介绍一下思路:
    1.因为置换密码首先要将其进行分组,这里分组长度为7,不足的位数补0,可以选取二维数组进行操作,定义二维数组,明文有多少个分组二维数组中就有多少个一维数组,其中一维的长度就是分组长度
    2.定义一个一维数组key作为加密用的秘钥,一个一维数组trankey作为解密秘钥,这里其中的元素是自己写的
    3.输入明文,现将其存入扩容好的新建的一维数组中但此时填充位是空字符’\0’,再将其替换为’0’,存入二维数组中
    4.加密,用秘钥key中的顺序对明文进行加密并存入二维数组miwen中
    5.解密,用解密秘钥trankey中的顺序对密文解密存入二维数组arr中
    6.消去填充的0,算出填充了多少个0,然后用分组长度减去0的个数就是二维数组中最后一个一维数组中非填充位的个数,将其存入一维数组中,在用此一维数组替换最后一个一维数组,这样就消去了所有的填充的0

    代码

    import java.util.Scanner;
    
    public class replacement {
    
    
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入带加密的明文:");
            String plaintexts = sc.nextLine();
            int len = plaintexts.length() % 7 == 0 ? plaintexts.length() / 7 : (plaintexts.length() / 7) + 1;//定义二维数组是要用到,主要作用是确定二维数组中一维数组的个数
            char[] plaintext_char = new char[7 * len];//先将明文存入一维数组中,在后面再将其存入二维数组中
            char[][] arr = new char[len][7];//存放明文和解密后的明文的二维数组
            char[][] miwen = new char[len][7];//存放密文的二维数组
            char[] n=new char[7];//在解密过程中用来消掉多余的填充的0
            int[] key = {6, 3, 0, 4, 1, 5, 2};//加密秘钥
            int[] transkey = {2, 4, 6, 1, 3, 5, 0};//解密秘钥
    
            fill(plaintexts, plaintext_char, len, arr);
            encryption(len, miwen, arr, key);
            System.out.println("加密后的明文是:");
            for (int i = 0; i < len; i++) {
                for (int j = 0; j < miwen[i].length; j++) {
                    System.out.print(miwen[i][j]);
                }
            }//输出密文
            System.out.println(" ");
            System.out.println("按下1解密或按其他任意键退出:");
            String a=sc.nextLine();
            if (a.equals("1")){
                decryption(n,len, miwen, arr, transkey,plaintexts);
                for (int i = 0; i < len; i++) {
                    for (int j = 0; j < arr[i].length; j++) {
                        System.out.print(arr[i][j]);
                    }
                }
            }else {
                System.out.println("退出!");
            }//输出明文或退出
        }
    
        public static void fill(String plaintexts, char[] plaintext_char, int len, char[][] arr) {
            for (int i = 0; i < plaintexts.length(); i++) {
                plaintext_char[i] = plaintexts.charAt(i);
            }//将输入的字符串存入扩充好的一维数组中,此时数组长度已达到标准,但是多出来的填充为是'\0'
            for (int i = 0; i < plaintext_char.length; i++) {
                if (plaintext_char[i] == '\u0000') {
                    plaintext_char[i] = '0';
                }//将字符串数组中的空字符'\0'替换为0
       	for (int i = 0; i < len; i++) {
                for (int j = i * 7, k = 0; j < 7 * (i + 1) && k < 7; j++, k++) {
                    arr[i][k] = plaintext_char[j];
                }
            }//将扩充后的明文存入二维数组中,每七个一个一维数组
        }
    
        public static void encryption(int len, char[][] miwen, char[][] arr, int[] key) {
            for (int i = 0; i < len; i++) {
                for (int j = 0; j < 7; j++) {
                    miwen[i][j] = arr[i][key[j]];
                }
            }
        }//加密方法
        public static void decryption(char[] n,int len, char[][] miwen, char[][] arr, int[] trankey,String plaintexts) {
            for (int i = 0; i < len; i++) {
                for (int j = 0; j < 7; j++) {
                    arr[i][j] = miwen[i][trankey[j]];
                }
            }
            for (int i = 0; i <7-(7*len-plaintexts.length()); i++) {
                n[i]=arr[arr.length-1][i];
            }//7-(7*len-plaintexts.length())是二维数组中最后一个一维数组中的非填充位的个数,将非填充位加到n中
            arr[len-1]=n;//用n取代二维数组中最后一个数组,相当于将填充的0消去
        }//解密方法
    }
    

    运行结果

    请输入带加密的明文:
    jdlalsdkpa1548796
    加密后的明文是:
    dajldsl81k5p4a0070906 
    按下1解密或按其他任意键退出:
    1
    jdlalsdkpa1548796
    
    展开全文
  • vue+java密码AES加密解密

    千次阅读 2019-09-29 15:12:16
    在开发中需要对用户提交的密码进行加密处理,前后端分离的...加密解密工具类AESUtil: import org.apache.commons.codec.binary.Base64; import javax.crypto.Cipher; import javax.crypto.spec.IvParameterSpec;...
  • java维吉尼亚加密解密用户设计界面 java维吉尼亚加密解密用户设计界面
  • 仿射密码 加密 解密

    2012-04-14 10:20:04
    仿射密码 加密 解密 java 图形界面
  • Java 加密解密基础

    2016-05-27 23:20:51
    Java 加密解密基础 Java byte数组与十六进制字符串互转 Java BASE64加密解密 Java 加密解密之消息摘要算法(MD5 SHA MAC...Java 加密解密之对称加密算法PBEJava 加密解密基础密码学是研究编制密码和破译密码的技术科
  • Java Jct 加密解密工具包源码,WDSsoft免费源代码,java加密解密编程常用工具包 JCT 1.0,作者吴东升 常蕴秋,BlowfishTool.java封装同Blowfish对称加密算法有关的方法,包括了使用创建Blowfish密码,使用Blowfish加密...
  • Java实现DES加密解密

    万次阅读 多人点赞 2018-11-09 16:27:01
    DES(Data Encryption Standard)是一种对称加密算法,所谓对称加密就是加密解密都是使用同一个密钥。 加密原理: DES 使用一个 56 位的密钥以及附加的 8 位奇偶校验位,产生最大 64 位的分组大小。这是一个迭代的...
  • 在密码学中,恺撒密码(英语:Caesar cipher),或称恺撒加密、恺撒变换、变换加密,是一种最简单且最广为人知的加密技术。...本课程设计是用java语言实现的凯撒密码加密解密程序。 可直接提交!高分模板!
  • js,java,加密解密

    2016-06-05 12:24:55
    JCryptoJS v3.1.2和JAVA解密,支持AES,MD5等,其中AES有实例已在...在使用时js对明文密码加密再提交,后台java解密。 随机生成key放到session中,js用该key加密,java用该key解密。 可实现数据的保密性与完整性校验。
  • JAVA实现古典置换密码加密解密
  • 包括java自定义加密解密实例,异或加密解密实例,AES加密解密,DES加密解密 对文件加密建议使用DES方式 技术学习交流:635278789
  • 栅栏密码加密解密工具
  • JAVA Cipher 实现DES 加密解密、生成秘钥 JAVA 加密使用的库是Cipher javax.crypto.Cipher 是java原生的类库,用来做加密解密的。 官网描述 ...此类提供用于加密和解密的密码算法的功能。它构成了Java加密扩展(JCE)...
  • 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....
  • 栅栏密码加密解密

    热门讨论 2012-05-27 12:07:44
    栅栏密码加密解密,26栏以上通过测试,不必整除栏数,可以任意加密解密。 MV 开源设计工作室
  • Java常用加密解密核心算法

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

    2014-01-09 22:08:02
    public class HuffmanCode { private String path;//文件的输入路径 private byte byteCount[] = new byte[256];//每个字节的计数 hfmNode root=null;//定义的根节点 //private int fileLen;...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 40,796
精华内容 16,318
关键字:

java密码加密解密

java 订阅