「java加密存储」java 加密文件

admin 2023-03-19 13:56:08 342

今天给各位分享java加密存储的知识，其中也会对java 加密文件进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

1、求教：Java 用户的密码该怎么加密存储
2、如何用java对数据加密，生成的密文是唯一的
3、java开发人事系统，需要对敏感数据进行加密存储，为了不影响统计分析和查询功能，大家有好的实现方案吗？
4、java 用^进行加密
5、Java 用户的密码该怎么加密存储
6、java密码加密与解密

求教：Java 用户的密码该怎么加密存储

密码字段一般会用MD5进行加密, 或者明文加密钥进行MD5加密, 例如明文是: 123456

MD5("xxx" + 123456)

如何用java对数据加密，生成的密文是唯一的

用户提供的是明文，数据库里面存储的是密文

不管怎么样，加密也好，解密也好，如果要比较相等性，这两个过程肯定要有一个，这个是没有选择的，需要提高性能的话只能做两点：

1、将用户的明文加密为密文后再与数据库中的比较，原因是这样只加密一次就可以，如果解密的话就要把数据库的密文全部解密，这是不现实的

2、在密文所在的列上建立索引，增加搜索速度，这个速度增长是很显著的，虽然会失去一些插入性能。

3、将对应的SQL写成存储过程。省去预编译的时间。这个速度的提高也是很明显的。

至于你说的“怎么能保证不一样得明文加密后生成不一样得密文”

MD5就可以

MD5有两个特性：

1、任意两段明文数据，加密以后的密文不会是相同的

2、任意一段明文数据，经过加密以后，其结果永远是不变的

网上MD5加密的类应该有写好的

大致上方法就是这样了，都做到的话应该没有问题了，不会影响你的性能的

java开发人事系统，需要对敏感数据进行加密存储，为了不影响统计分析和查询功能，大家有好的实现方案吗？

没错，数据库中存的ID项加密。查询匹配时使用js或后台将用户输入的内容加密后去数据库匹配。查询到加密的数据库数据后在后台解密在发送到前台。如果对于安全要求较高就不要在js中解密。最后，类似于ID的数据加密模式和敏感信息的加密模式要不一致，这样可以保护你需要保护的敏感信息，即使有人通过js破解了你的ID等数据的加密，也无法获取真正的敏感信息。

java 用^进行加密

import java.util.Scanner;

public class Test {

public static final int KEY = 8;

public static void main(String[] args) {

String str = "十点进攻";

StringBuffer str2 = new StringBuffer(); //存储加密后的字符串

StringBuffer str3 = new StringBuffer(); //存储解密后的字符串

//加密过程

for(int i=0;istr.length();i++)

{

char c = (char)(str.charAt(i) ^ KEY);

str2.append(c);

}

//解密过程

for(int i=0;istr2.length();i++)

{

char c = (char)(str2.charAt(i) ^ KEY);

str3.append(c);

}

System.out.println("原始的字符串为:" + str);

System.out.println("加密后的字符串为:" + str2);

System.out.println("解密后的字符串为:" + str3);

}

Java 用户的密码该怎么加密存储

你可以选择用md5，将密码转成另外一个字符串加密，也可以自己写一个加密的算法。

java密码加密与解密

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

加密 CryptHelper encrypt（password）

解密 CrypHelper decrypt（password）

代码如下

CryptUtils java

[java]

package gdie lab crypt;

import java io IOException;

import javax crypto Cipher;

import javax crypto KeyGenerator;

import javax crypto SecretKey;

import apache xerces internal impl dv util Base ;

public class CryptUtils {

private static String Algorithm = DES ;

private static byte[] DEFAULT_KEY=new byte[] { };

private static String VALUE_ENCODING= UTF ;

/**

* 生成密钥

* @return byte[] 返回生成的密钥

* @throws exception

* 扔出异常

public static byte[] getSecretKey（） throws Exception {

KeyGenerator keygen = KeyGenerator getInstance（Algorithm）

SecretKey deskey = keygen generateKey（）

// if （debug ） System out println （生成密钥 +byte hex （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 （加密前的二进串 +byte hex （input ））

// System out println （加密前的字符串 +new String （input ））

// }

Cipher c = Cipher getInstance（Algorithm）

c init（Cipher ENCRYPT_MODE deskey）

byte[] cipherByte = c doFinal（input）

// if （debug ） System out println （加密后的二进串 +byte hex （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 （解密前的信息 +byte hex （input ））

Cipher c = Cipher getInstance（Algorithm）

c init（Cipher DECRYPT_MODE deskey）

byte[] clearByte = c doFinal（input）

// if （debug ）

// {

// System out println （解密后的二进串 +byte hex （clearByte ））

// System out println （解密后的字符串 +（new String （clearByte ）））

// }

return clearByte;

}

public static byte[] decryptData（byte[] input） throws Exception {

return decryptData（input DEFAULT_KEY）

}

/**

* 字节码转换成进制字符串

* @param byte[] b 输入要转换的字节码

* @return String 返回转换后的进制字符串

public static String byte hex（byte[] bytes） {

StringBuilder hs = new StringBuilder（）

for（byte b : bytes）

hs append（String format（ % $ X b））

return hs toString（）

}

public static byte[] hex byte（String content） {

int l=content length（）》 ;

byte[] result=new byte[l];

for（int i= ;il;i++） {

int j=i《 ;

String s=content substring（j j+ ）

result[i]=Integer valueOf（s ） byteValue（）

}

return result;

}

/**

* 将字节数组转换为base 编码字符串

* @param buffer

* @return

public static String bytesToBase （byte[] buffer） {

//BASE Encoder en=new BASE Encoder（）

return Base encode（buffer）

// return encoder encode（buffer）

}

/**

* 将base 编码的字符串解码为字节数组

* @param value

* @return

* @throws IOException

public static byte[] base ToBytes（String value） throws IOException {

//return Base decodeToByteArray（value）

// System out println（decoder decodeBuffer（value））

// return decoder decodeBuffer（value）

return Base decode（value）

}

/**

* 加密给定的字符串

* @param value

* @return 加密后的base 字符串

public static String encryptString（String value） {

return encryptString（value DEFAULT_KEY）

}

/**

* 根据给定的密钥加密字符串

* @param value 待加密的字符串

* @param key 以BASE 形式存在的密钥

* @return 加密后的base 字符串

* @throws IOException

public static String encryptString（String value String key） throws IOException {

return encryptString（value base ToBytes（key））

}

/**

* 根据给定的密钥加密字符串

* @param value 待加密的字符串

* @param key 字节数组形式的密钥

* @return 加密后的base 字符串

public static String encryptString（String value byte[] key） {

try {

byte[] data=value getBytes（VALUE_ENCODING）

data=CryptUtils encryptData（data key）

return bytesToBase （data）

} catch （Exception e） {

// TODO Auto generated catch block

e printStackTrace（）

return null;

}

/**

* 解密字符串

* @param value base 形式存在的密文

* @return 明文

public static String decryptString（String value） {

return decryptString（value DEFAULT_KEY）

}

/**

* 解密字符串

* @param value base 形式存在的密文

* @param key base 形式存在的密钥

* @return 明文

* @throws IOException

public static String decryptString（String value String key） throws IOException {

String s=decryptString（value base ToBytes（key））

return s;

}

/**

* 解密字符串

* @param value base 形式存在的密文

* @param key 字节数据形式存在的密钥

* @return 明文

public static String decryptString（String value byte[] key） {

try {

byte[] data=base ToBytes（value）

data=CryptUtils decryptData（data key）

return new String（data VALUE_ENCODING）

}catch（Exception e） {

e printStackTrace（）

return null;

}

package gdie lab crypt;

import java io IOException;

import javax crypto Cipher;

import javax crypto KeyGenerator;

import javax crypto SecretKey;

import apache xerces internal impl dv util Base ;

public class CryptUtils {

private static String Algorithm = DES ;

private static byte[] DEFAULT_KEY=new byte[] { };

private static String VALUE_ENCODING= UTF ;

/**

* 生成密钥

* @return byte[] 返回生成的密钥

* @throws exception

* 扔出异常

public static byte[] getSecretKey（） throws Exception {

KeyGenerator keygen = KeyGenerator getInstance（Algorithm）

SecretKey deskey = keygen generateKey（）

// if （debug ） System out println （生成密钥 +byte hex （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 （加密前的二进串 +byte hex （input ））

// System out println （加密前的字符串 +new String （input ））

// }

Cipher c = Cipher getInstance（Algorithm）

c init（Cipher ENCRYPT_MODE deskey）

byte[] cipherByte = c doFinal（input）

// if （debug ） System out println （加密后的二进串 +byte hex （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 （解密前的信息 +byte hex （input ））

Cipher c = Cipher getInstance（Algorithm）

c init（Cipher DECRYPT_MODE deskey）

byte[] clearByte = c doFinal（input）

// if （debug ）

// {

// System out println （解密后的二进串 +byte hex （clearByte ））

// System out println （解密后的字符串 +（new String （clearByte ）））

// }

return clearByte;

}

public static byte[] decryptData（byte[] input） throws Exception {

return decryptData（input DEFAULT_KEY）

}

/**

* 字节码转换成进制字符串

* @param byte[] b 输入要转换的字节码

* @return String 返回转换后的进制字符串

public static String byte hex（byte[] bytes） {

StringBuilder hs = new StringBuilder（）

for（byte b : bytes）

hs append（String format（ % $ X b））

return hs toString（）

}

public static byte[] hex byte（String content） {

int l=content length（）》 ;

byte[] result=new byte[l];

for（int i= ;il;i++） {

int j=i《 ;

String s=content substring（j j+ ）

result[i]=Integer valueOf（s ） byteValue（）

}

return result;

}

/**

* 将字节数组转换为base 编码字符串

* @param buffer

* @return

public static String bytesToBase （byte[] buffer） {

//BASE Encoder en=new BASE Encoder（）

return Base encode（buffer）

// return encoder encode（buffer）

}

/**

* 将base 编码的字符串解码为字节数组

* @param value

* @return

* @throws IOException

public static byte[] base ToBytes（String value） throws IOException {

//return Base decodeToByteArray（value）

// System out println（decoder decodeBuffer（value））

// return decoder decodeBuffer（value）

return Base decode（value）

}

/**

* 加密给定的字符串

* @param value

* @return 加密后的base 字符串

public static String encryptString（String value） {

return encryptString（value DEFAULT_KEY）

}

/**

* 根据给定的密钥加密字符串

* @param value 待加密的字符串

* @param key 以BASE 形式存在的密钥

* @return 加密后的base 字符串

* @throws IOException

public static String encryptString（String value String key） throws IOException {

return encryptString（value base ToBytes（key））

}

/**

* 根据给定的密钥加密字符串

* @param value 待加密的字符串

* @param key 字节数组形式的密钥

* @return 加密后的base 字符串

public static String encryptString（String value byte[] key） {

try {

byte[] data=value getBytes（VALUE_ENCODING）

data=CryptUtils encryptData（data key）

return bytesToBase （data）

} catch （Exception e） {

// TODO Auto generated catch block

e printStackTrace（）

return null;

}

/**

* 解密字符串

* @param value base 形式存在的密文

* @return 明文

public static String decryptString（String value） {

return decryptString（value DEFAULT_KEY）

}

/**

* 解密字符串

* @param value base 形式存在的密文

* @param key base 形式存在的密钥

* @return 明文

* @throws IOException

public static String decryptString（String value String key） throws IOException {

String s=decryptString（value base ToBytes（key））

return s;

}

/**

* 解密字符串

* @param value base 形式存在的密文

* @param key 字节数据形式存在的密钥

* @return 明文

public static String decryptString（String value byte[] key） {

try {

byte[] data=base ToBytes（value）

data=CryptUtils decryptData（data key）

return new String（data VALUE_ENCODING）

}catch（Exception e） {

e printStackTrace（）

return null;

}

CryptHelper java

[java]

package 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 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 md DigestAsHex（CRYPT_KEY getBytes（）） toUpperCase（）

KEY = KEY substring（）

byte[] bytes = KEY getBytes（）

DESKeySpec ks = new DESKeySpec（bytes）

SecretKeyFactory skf = SecretKeyFactory getInstance（ DES ）

SecretKey sk = skf generateSecret（ks）

IvParameterSpec iv = new IvParameterSpec（bytes）

ecip = Cipher getInstance（ DES/CBC/PKCS Padding ）

ecip init（Cipher ENCRYPT_MODE sk iv ）

dcip = Cipher getInstance（ DES/CBC/PKCS Padding ）

dcip init（Cipher DECRYPT_MODE sk iv ）

}catch（Exception ex） {

ex printStackTrace（）

}

public static String encrypt（String content） throws Exception {

byte[] bytes = ecip doFinal（content getBytes（ ascii ））

return CryptUtils byte hex（bytes）

}

public static String decrypt（String content） throws Exception {

byte[] bytes = CryptUtils hex byte（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））

}

package 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 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 md DigestAsHex（CRYPT_KEY getBytes（）） toUpperCase（）

KEY = KEY substring（）

byte[] bytes = KEY getBytes（）

DESKeySpec ks = new DESKeySpec（bytes）

SecretKeyFactory skf = SecretKeyFactory getInstance（ DES ）

SecretKey sk = skf generateSecret（ks）

IvParameterSpec iv = new IvParameterSpec（bytes）

ecip = Cipher getInstance（ DES/CBC/PKCS Padding ）

ecip init（Cipher ENCRYPT_MODE sk iv ）

dcip = Cipher getInstance（ DES/CBC/PKCS Padding ）

dcip init（Cipher DECRYPT_MODE sk iv ）

}catch（Exception ex） {

ex printStackTrace（）

}

public static String encrypt（String content） throws Exception {

byte[] bytes = ecip doFinal（content getBytes（ ascii ））

return CryptUtils byte hex（bytes）

}

public static String decrypt（String content） throws Exception {

byte[] bytes = CryptUtils hex byte（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））

}

lishixinzhi/Article/program/Java/hx/201311/26449

关于java加密存储和java 加密文件的介绍到此就结束了，不知道你从中找到你需要的信息了吗？如果你还想了解更多这方面的信息，记得收藏关注本站。

标签：java加密存储