因为作业不会写,大中午的难过得大哭了一场。后来没放弃·~用了2个下午的时间,终于实现了完整的DES加密解密。
算法看明白后还有实现,也是比较简单,做下去之后,发现常用的很多都不会,一边重新学一边做。
写程序,不是在和什么做斗争,是时时刻刻都要面对焦虑、无人可求助、总是觉得无能为力的自己,只是需要一点耐心和一点平常心,慢慢做,总会解决的。
期间参考了这几个地方:
------------------------------DES加密解密---------------------------(写得比较复杂,但是比较容易理解,import没贴上,可执行,数据表事先准备好)----------------------------------------
//DES加密 main
public class TestJia {
public static void main(String[] args) {
showHomwork showHomwork = new showHomwork();
ArrayList<homwork> list = showHomwork.getAllStus();
for(homwork s: list){ //遍历集合数据
System.out.println("原数据:"+s.getName()+"\t"+s.getIdCardNo()+"\t"+s.getBirthday()+"\t"+s.getPay());
}
ArrayList<homwork> listMi = showHomwork.setIntoDESAll(list);//加密
System.out.println("加密成功");
}
}
//DES解密 main
public class TestJie {
public static void main(String[] args) {
showHomwork showHomwork = new showHomwork();
ArrayList<homwork> list = showHomwork.getAllStus();
for(homwork s: list){ //遍历集合数据
System.out.println("原数据:"+s.getName()+"\t"+s.getIdCardNo()+"\t"+s.getBirthday()+"\t"+s.getPay());
}
ArrayList<homwork> listJie = showHomwork.setOutDESAll(list);//解密
System.out.println("解密成功");
}
}
//测试加解密
public class DesUtil {
private final static String DES = "DES";
public static void main(String[] args) throws Exception {
String data = "hello <xml > 测试!";
String key = "!@#$%qqqqqqwwww";
System.out.println(encrypt(data, key));
System.out.println(decrypt(encrypt(data, key), key));
}
/**
* Description 根据键值进行加密
* @param data
* @param key 加密键byte数组
* @return
* @throws Exception
*/
public static String encrypt(String data, String key) throws Exception {
byte[] bt = encrypt(data.getBytes(), key.getBytes());
String strs = new BASE64Encoder().encode(bt);
return strs;
}
/**
* Description 根据键值进行解密
* @param data
* @param key 加密键byte数组
* @return
* @throws IOException
* @throws Exception
*/
public static String decrypt(String data, String key) throws IOException,
Exception {
if (data == null)
return null;
BASE64Decoder decoder = new BASE64Decoder();
byte[] buf = decoder.decodeBuffer(data);
byte[] bt = decrypt(buf,key.getBytes());
return new String(bt);
}
/**
* Description 根据键值进行加密
* @param data
* @param key 加密键byte数组
* @return
* @throws Exception
*/
private static byte[] encrypt(byte[] data, byte[] key) throws Exception {
// 生成一个可信任的随机数源
SecureRandom sr = new SecureRandom();
// 从原始密钥数据创建DESKeySpec对象
DESKeySpec dks = new DESKeySpec(key);
// 创建一个密钥工厂,然后用它把DESKeySpec转换成SecretKey对象
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);
SecretKey securekey = keyFactory.generateSecret(dks);
// Cipher对象实际完成加密操作
Cipher cipher = Cipher.getInstance(DES);
// 用密钥初始化Cipher对象
cipher.init(Cipher.ENCRYPT_MODE, securekey, sr);
return cipher.doFinal(data);
}
/**
* Description 根据键值进行解密
* @param data
* @param key 加密键byte数组
* @return
* @throws Exception
*/
private static byte[] decrypt(byte[] data, byte[] key) throws Exception {
// 生成一个可信任的随机数源
SecureRandom sr = new SecureRandom();
// 从原始密钥数据创建DESKeySpec对象
DESKeySpec dks = new DESKeySpec(key);
// 创建一个密钥工厂,然后用它把DESKeySpec转换成SecretKey对象
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);
SecretKey securekey = keyFactory.generateSecret(dks);
// Cipher对象实际完成解密操作
Cipher cipher = Cipher.getInstance(DES);
// 用密钥初始化Cipher对象
cipher.init(Cipher.DECRYPT_MODE, securekey, sr);
return cipher.doFinal(data);
}
}
//连接数据库 查询修改
public class showHomwork {
public static void main(String[] args) {
ArrayList<homwork> list = getAllStus();
if(list.size() == 0){
System.out.println("暂无数据");
}else{
for(homwork s: list){ //遍历集合数据 System.out.println(s.getName()+"\t"+s.getIdCardNo()+"\t"+s.getBirthday()+"\t"+s.getPay());
}
}
}
//采用集合的方法,返回数据集合,查询
public static ArrayList<homwork> getAllStus(){
ArrayList<homwork> stulist = new ArrayList<homwork>();
String url = "com.mysql.jdbc.Driver"; //加载驱动包
String connectSql = "jdbc:mysql://localhost:3306/demo"; //链接MySQL数据库
String sqlUser = "root"; //数据库账号
String sqlPasswd = "x5"; //你的数据库密码
Connection con = null;
PreparedStatement psm = null;
ResultSet rs = null;
System.out.println("连接数据库成功!");
try {
//加载驱动包
Class.forName(url);
//连接MYSQL
con = DriverManager.getConnection(connectSql,sqlUser,sqlPasswd);
//执行MYSQL语句
psm = con.prepareStatement("select * from homwork");
rs = psm.executeQuery();
System.out.println("姓名"+"\t"+"身份证号码"+"\t"+"出生日期"+"\t"+"薪资");
while(rs.next()){
homwork s = new homwork();
s.setName(rs.getString(3));
s.setIdCardNo(rs.getString(2));
s.setBirthday(rs.getString(5));
s.setPay(rs.getString(7));
stulist.add(s);
}
//关闭数据库连接
rs.close();
psm.close();
con.close();
} catch (Exception e) {
System.out.println("显示所有数据报错,原因:"+e.getMessage());
}
return stulist;
}
//采用集合的方法,修改数据内容,DES加密
public ArrayList<homwork> setIntoDESAll(ArrayList<homwork> homworklist){
String url = "com.mysql.jdbc.Driver"; //加载驱动包
String connectSql = "jdbc:mysql://localhost:3306/demo"; //链接MySQL
String sqlUser = "root"; //数据库账号
String sqlPasswd = "x5"; //你的数据库密码
Connection con = null;
PreparedStatement psm = null;
ResultSet rs = null;
System.out.println("连接数据库成功!");
try {
//加载驱动包
Class.forName(url);
//连接MYSQL
con = DriverManager.getConnection(connectSql,sqlUser,sqlPasswd);
//执行MYSQL语句
psm = con.prepareStatement("select * from homwork");
rs = psm.executeQuery();
if(homworklist.size() == 0){
return (ArrayList<homwork>) homworklist;
}
String key = "我是加密秘钥";
for(homwork s: (ArrayList<homwork>)homworklist){ //遍历集合数据
DesUtil des = new DesUtil();
String birthdaykey = null;
String paykey = null;
try {
birthdaykey = des.encrypt(s.getBirthday(), key);
paykey = des.encrypt(s.getPay(), key);
} catch (Exception e) {
e.printStackTrace();
}
String updateNamesql = "UPDATE homwork SET birthday=REPLACE(birthday,'"+s.getBirthday() +"','"+birthdaykey+"'); ";
String updatePaysql = "UPDATE homwork SET pay=REPLACE(pay,'"+s.getPay() +"','"+paykey+"'); ";
PreparedStatement stmt = con.prepareStatement(updateNamesql);
PreparedStatement stmt2 = con.prepareStatement(updatePaysql);
stmt.executeUpdate();
stmt2.executeUpdate();
System.out.println("加密生日成功!加密生日为:"+birthdaykey+ "加密工资成功!加密工资为:"+paykey);
}
//关闭数据库连接
rs.close();
psm.close();
con.close();
} catch (Exception e) {
System.out.println("显示所有数据报错,原因:"+e.getMessage());
}
return homworklist;
}
//采用集合的方法,修改数据内容,DES解密
public ArrayList<homwork> setOutDESAll(ArrayList<homwork> homworklist){
String url = "com.mysql.jdbc.Driver"; //加载驱动包
String connectSql = "jdbc:mysql://localhost:3306/demo"; //链接MySQL String sqlUser = "root"; //数据库账号
String sqlPasswd = "x5"; //你的数据库密码
Connection con = null;
PreparedStatement psm = null;
ResultSet rs = null;
System.out.println("连接数据库成功!");
try {
//加载驱动包
Class.forName(url);
//连接MYSQL
con = DriverManager.getConnection(connectSql,sqlUser,sqlPasswd);
//执行MYSQL语句
psm = con.prepareStatement("select * from homwork");
rs = psm.executeQuery();
if(homworklist.size() == 0){
return (ArrayList<homwork>) homworklist;
}
String key = "我是加密秘钥";
for(homwork s: (ArrayList<homwork>)homworklist){ //遍历集合数据
DesUtil des = new DesUtil();
String birthdaykey = null;
String paykey = null;
try {
birthdaykey = des.decrypt(s.getBirthday(), key);
paykey = des.decrypt(s.getPay(), key);
} catch (Exception e) {
e.printStackTrace();
}
String updatesql = "UPDATE homwork SET birthday=REPLACE(birthday,'"+s.getBirthday() +"','"+birthdaykey+"'); ";
String updatesql2 = "UPDATE homwork SET pay=REPLACE(pay,'"+s.getPay() +"','"+paykey+"'); ";
PreparedStatement stmt = con.prepareStatement(updatesql);
PreparedStatement stmt2 = con.prepareStatement(updatesql2);
stmt.executeUpdate();
stmt2.executeUpdate();
System.out.println("解密生日成功!解密生日为:"+birthdaykey);
System.out.println("解密工资成功!解密工资为:"+paykey);
}
//关闭数据库连接
rs.close();
psm.close();
con.close();
} catch (Exception e) {
System.out.println("显示所有数据报错,原因:"+e.getMessage());
}
return homworklist;
}
}
//实体类
public class homwork {
private int Id;
private String idCardNo;
private String name;
private String gender;
private String birthday;
private String workday;
private String pay;
public int getId() {
return Id;
}
public void setId(int id) {
Id = id;
}
public String getIdCardNo() {
return idCardNo;
}
public void setIdCardNo(String idCardNo) {
this.idCardNo = idCardNo;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public String getBirthday() {
return birthday;
}
public void setBirthday(String birthday) {
this.birthday = birthday;
}
public String getWorkday() {
return workday;
}
public void setWorkday(String workday) {
this.workday = workday;
}
public String getPay() {
return pay;
}
public void setPay(String pay) {
this.pay = pay;
}
public homwork(){
}
public homwork(int Id,String idCardNo,String name,String gender, String birthday,String workday,String pay) {
this.Id = Id;
this.idCardNo = idCardNo;
this.name = name;
this.gender = gender;
this.birthday = birthday;
this.workday = workday;
this.pay = pay;
}
}
----------------------------------------------------------------------------结束----------------(结果就不贴了)--------------------------------------------------------------------------------
-------------------------------------------------------------------RSA加密解密------------(加密可执行,解密出了点小问题,没来得及调整)---------------------------------------------------------
RSA加密
public class main {
public static void main(String[] args) throws Exception {
todoRSA todoRSA = new todoRSA();
ArrayList<homwork> list = todoRSA.getAllStus();
for(homwork s: list){ //遍历集合数据
System.out.println("原数据:"+s.getName()+"\t"+s.getIdCardNo()+"\t"+s.getBirthday()+"\t"+s.getPay());
}
ArrayList<homwork> miRSA = todoRSA.setIntoRASAll(list);
System.out.println("加密成功");
for(homwork s: miRSA){ //遍历集合数据
System.out.println("加密后数据:"+s.getName()+"\t"+s.getIdCardNo()+"\t"+s.getBirthday()+"\t"+s.getPay());
}
}
}
RSA解密
public class mainJie {
public static void main(String[] args) throws Exception {
todoRSA todoRSA = new todoRSA();
ArrayList<homwork> list = todoRSA.getAllStus();
for(homwork s: list){ //遍历集合数据
System.out.println("原数据:"+s.getName()+"\t"+s.getIdCardNo()+"\t"+s.getBirthday()+"\t"+s.getPay());
}
ArrayList<homwork> jieRSA = todoRSA.setOutRSA(list);
System.out.println("解密成功");
for(homwork s: jieRSA){ //遍历集合数据
System.out.println("解密后数据:"+s.getName()+"\t"+s.getIdCardNo()+"\t"+s.getBirthday()+"\t"+s.getPay());
}
}
}
public class RSAUtils {
/**
* 生成公钥和私钥
* @throws NoSuchAlgorithmException
*
*/
public static HashMap<String, Object> getKeys() throws NoSuchAlgorithmException{
HashMap<String, Object> map = new HashMap<String, Object>();
KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
keyPairGen.initialize(1024);
KeyPair keyPair = keyPairGen.generateKeyPair();
RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
map.put("public", publicKey);
map.put("private", privateKey);
return map;
}
/**
* 使用模和指数生成RSA公钥
* 注意:【此代码用了默认补位方式,为RSA/None/PKCS1Padding,不同JDK默认的补位方式可能不同,如Android默认是RSA
* /None/NoPadding】
*
* @param modulus
* 模
* @param exponent
* 指数
* @return
*/
public static RSAPublicKey getPublicKey(String modulus, String exponent) {
try {
BigInteger b1 = new BigInteger(modulus);
BigInteger b2 = new BigInteger(exponent);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
RSAPublicKeySpec keySpec = new RSAPublicKeySpec(b1, b2);
return (RSAPublicKey) keyFactory.generatePublic(keySpec);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 使用模和指数生成RSA私钥
* 注意:【此代码用了默认补位方式,为RSA/None/PKCS1Padding,不同JDK默认的补位方式可能不同,如Android默认是RSA
* /None/NoPadding】
*
* @param modulus
* 模
* @param exponent
* 指数
* @return
*/
public static RSAPrivateKey getPrivateKey(String modulus, String exponent) {
try {
BigInteger b1 = new BigInteger(modulus);
BigInteger b2 = new BigInteger(exponent);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(b1, b2);
return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 公钥加密
*
* @param data
* @param publicKey
* @return
* @throws Exception
*/
public static String encryptByPublicKey(String data, RSAPublicKey publicKey)
throws Exception {
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
// 模长
int key_len = publicKey.getModulus().bitLength() / 8;
// 加密数据长度 <= 模长-11
String[] datas = splitString(data, key_len - 11);
String mi = "";
//如果明文长度大于模长-11则要分组加密
for (String s : datas) {
mi += bcd2Str(cipher.doFinal(s.getBytes()));
}
return mi;
}
/**
* 私钥解密
*
* @param data
* @param privateKey
* @return
* @throws Exception
*/
public static String decryptByPrivateKey(String data, RSAPrivateKey privateKey)
throws Exception {
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.DECRYPT_MODE, privateKey);
//模长
int key_len = privateKey.getModulus().bitLength() / 8;
byte[] bytes = data.getBytes();
byte[] bcd = ASCII_To_BCD(bytes, bytes.length);
System.err.println(bcd.length);
//如果密文长度大于模长则要分组解密
String ming = "";
byte[][] arrays = splitArray(bcd, key_len);
for(byte[] arr : arrays){
ming += new String(cipher.doFinal(arr));
}
return ming;
}
/**
* ASCII码转BCD码
*
*/
public static byte[] ASCII_To_BCD(byte[] ascii, int asc_len) {
byte[] bcd = new byte[asc_len / 2];
int j = 0;
for (int i = 0; i < (asc_len + 1) / 2; i++) {
bcd[i] = asc_to_bcd(ascii[j++]);
bcd[i] = (byte) (((j >= asc_len) ? 0x00 : asc_to_bcd(ascii[j++])) + (bcd[i] << 4));
}
return bcd;
}
public static byte asc_to_bcd(byte asc) {
byte bcd;
if ((asc >= '0') && (asc <= '9'))
bcd = (byte) (asc - '0');
else if ((asc >= 'A') && (asc <= 'F'))
bcd = (byte) (asc - 'A' + 10);
else if ((asc >= 'a') && (asc <= 'f'))
bcd = (byte) (asc - 'a' + 10);
else
bcd = (byte) (asc - 48);
return bcd;
}
/**
* BCD转字符串
*/
public static String bcd2Str(byte[] bytes) {
char temp[] = new char[bytes.length * 2], val;
for (int i = 0; i < bytes.length; i++) {
val = (char) (((bytes[i] & 0xf0) >> 4) & 0x0f);
temp[i * 2] = (char) (val > 9 ? val + 'A' - 10 : val + '0');
val = (char) (bytes[i] & 0x0f);
temp[i * 2 + 1] = (char) (val > 9 ? val + 'A' - 10 : val + '0');
}
return new String(temp);
}
/**
* 拆分字符串
*/
public static String[] splitString(String string, int len) {
int x = string.length() / len;
int y = string.length() % len;
int z = 0;
if (y != 0) {
z = 1;
}
String[] strings = new String[x + z];
String str = "";
for (int i=0; i<x+z; i++) {
if (i==x+z-1 && y!=0) {
str = string.substring(i*len, i*len+y);
}else{
str = string.substring(i*len, i*len+len);
}
strings[i] = str;
}
return strings;
}
/**
*拆分数组
*/
public static byte[][] splitArray(byte[] data,int len){
int x = data.length / len;
int y = data.length % len;
int z = 0;
if(y!=0){
z = 1;
}
byte[][] arrays = new byte[x+z][];
byte[] arr;
for(int i=0; i<x+z; i++){
arr = new byte[len];
if(i==x+z-1 && y!=0){
System.arraycopy(data, i*len, arr, 0, y);
}else{
System.arraycopy(data, i*len, arr, 0, len);
}
arrays[i] = arr;
}
return arrays;
}
}
public class todoRSA {
public static void main(String[] args) {
ArrayList<homwork> list = getAllStus();
if(list.size() == 0){
System.out.println("暂无数据");
}else{
for(homwork s: list){ //遍历集合数据
System.out.println(s.getName()+"\t"+s.getIdCardNo()+"\t"+s.getBirthday()+"\t"+s.getPay());
}
}
}
//采用集合的方法,返回数据集合,查询
public static ArrayList<homwork> getAllStus(){
ArrayList<homwork> stulist = new ArrayList<homwork>();
String url = "com.mysql.jdbc.Driver"; //加载驱动包
String connectSql = "jdbc:mysql://localhost:3306/demo"; //链接MySQL数据库
String sqlUser = "root"; //数据库账号
String sqlPasswd = "x5"; //你的数据库密码
Connection con = null;
PreparedStatement psm = null;
ResultSet rs = null;
System.out.println("连接数据库成功!");
try {
//加载驱动包
Class.forName(url);
//连接MYSQL
con = DriverManager.getConnection(connectSql,sqlUser,sqlPasswd);
//执行MYSQL语句
psm = con.prepareStatement("select * from homwork");
rs = psm.executeQuery();
System.out.println("姓名"+"\t"+"身份证号码"+"\t"+"出生日期"+"\t"+"薪资");
while(rs.next()){
homwork s = new homwork();
s.setName(rs.getString(3));
s.setIdCardNo(rs.getString(2));
s.setBirthday(rs.getString(5));
s.setPay(rs.getString(7));
stulist.add(s);
}
//关闭数据库连接
rs.close();
psm.close();
con.close();
} catch (Exception e) {
System.out.println("显示所有数据报错,原因:"+e.getMessage());
}
return stulist;
}
//采用集合的方法,修改数据内容,RAS加密
public ArrayList<homwork> setIntoRASAll(ArrayList<homwork> homworklist){
String url = "com.mysql.jdbc.Driver"; //加载驱动包
String connectSql = "jdbc:mysql://localhost:3306/demo"; //链接MySQL数据库
String sqlUser = "root"; //数据库账号
String sqlPasswd = "x5"; //你的数据库密码
Connection con = null;
PreparedStatement psm = null;
ResultSet rs = null;
System.out.println("连接数据库成功!");
try {
//加载驱动包
Class.forName(url);
//连接MYSQL
con = DriverManager.getConnection(connectSql,sqlUser,sqlPasswd);
//执行MYSQL语句
psm = con.prepareStatement("select * from homwork");
rs = psm.executeQuery();
if(homworklist.size() == 0){
return (ArrayList<homwork>) homworklist;
}
HashMap<String, Object> map = RSAUtils.getKeys();
//生成公钥和私钥
RSAPublicKey publicKey = (RSAPublicKey) map.get("public");
//模
String modulus = publicKey.getModulus().toString();
//公钥指数
String public_exponent = publicKey.getPublicExponent().toString();
for(homwork s: (ArrayList<homwork>)homworklist){ //遍历集合数据
//明文
String mingBirth = s.getBirthday();
String mingPay = s.getPay();
//使用模和指数生成公钥和私钥
RSAPublicKey pubKey = RSAUtils.getPublicKey(modulus, public_exponent);
//加密后的密文
String miBirth = RSAUtils.encryptByPublicKey(mingBirth, pubKey);
String miPay = RSAUtils.encryptByPublicKey(mingPay, pubKey);
//数据库执行
String updateNamesql = "UPDATE homwork SET birthday=REPLACE(birthday,'"+s.getBirthday() +"','"+miBirth+"'); ";
String updatePaysql = "UPDATE homwork SET pay=REPLACE(pay,'"+s.getPay() +"','"+miPay+"'); ";
PreparedStatement stmt = con.prepareStatement(updateNamesql);
PreparedStatement stmt2 = con.prepareStatement(updatePaysql);
stmt.executeUpdate();
stmt2.executeUpdate();
System.out.println("加密生日成功!加密生日为:"+miBirth+ "加密工资成功!加密工资为:"+miPay);
}
//关闭数据库连接
rs.close();
psm.close();
con.close();
} catch (Exception e) {
System.out.println("显示所有数据报错,原因:"+e.getMessage());
}
return homworklist;
}
//采用集合的方法,修改数据内容,RSA解密
public ArrayList<homwork> setOutRSA(ArrayList<homwork> homworklist){
String url = "com.mysql.jdbc.Driver"; //加载驱动包
String connectSql = "jdbc:mysql://localhost:3306/demo"; //链接MySQL数据库
String sqlUser = "root"; //数据库账号
String sqlPasswd = "x5"; //你的数据库密码
Connection con = null;
PreparedStatement psm = null;
ResultSet rs = null;
System.out.println("连接数据库成功!");
try {
//加载驱动包
Class.forName(url);
//连接MYSQL
con = DriverManager.getConnection(connectSql,sqlUser,sqlPasswd);
//执行MYSQL语句
psm = con.prepareStatement("select * from homwork");
rs = psm.executeQuery();
if(homworklist.size() == 0){
return (ArrayList<homwork>) homworklist;
}
for(homwork s: (ArrayList<homwork>)homworklist){ //遍历集合数据
HashMap<String, Object> map = RSAUtils.getKeys();
//生成公钥和私钥
RSAPublicKey publicKey = (RSAPublicKey) map.get("public");
RSAPrivateKey privateKey = (RSAPrivateKey) map.get("private");
//模
String modulus = publicKey.getModulus().toString();
//私钥指数
String private_exponent = privateKey.getPrivateExponent().toString();
//使用模和指数生成私钥
RSAPrivateKey priKey = RSAUtils.getPrivateKey(modulus, private_exponent);
String miBirth=s.getBirthday();
String miPay=s.getPay();
//解密后的明文
String jieBirth = RSAUtils.decryptByPrivateKey(miBirth, priKey);
String jiePay = RSAUtils.decryptByPrivateKey(miPay, priKey);
String updatesql = "UPDATE homwork SET birthday=REPLACE(birthday,'"+s.getBirthday() +"','"+jieBirth+"'); ";
String updatesql2 = "UPDATE homwork SET pay=REPLACE(pay,'"+s.getPay() +"','"+jiePay+"'); ";
PreparedStatement stmt = con.prepareStatement(updatesql);
PreparedStatement stmt2 = con.prepareStatement(updatesql2);
stmt.executeUpdate();
stmt2.executeUpdate();
System.out.println("解密生日成功!解密生日为:"+jieBirth);
System.out.println("解密工资成功!解密工资为:"+jiePay);
}
//关闭数据库连接
rs.close();
psm.close();
con.close();
} catch (Exception e) {
System.out.println("显示所有数据报错,原因:"+e.getMessage());
}
return homworklist;
}
public ArrayList Key(String Ming, String Mi) throws Exception{
HashMap<String, Object> map;
try {
map = RSAUtils.getKeys();
//生成公钥和私钥
RSAPublicKey publicKey = (RSAPublicKey) map.get("public");
RSAPrivateKey privateKey = (RSAPrivateKey) map.get("private");
//模
String modulus = publicKey.getModulus().toString();
//公钥指数
String public_exponent = publicKey.getPublicExponent().toString();
//私钥指数
String private_exponent = privateKey.getPrivateExponent().toString();
//使用模和指数生成公钥和私钥
RSAPublicKey pubKey = RSAUtils.getPublicKey(modulus, public_exponent);
RSAPrivateKey priKey = RSAUtils.getPrivateKey(modulus, private_exponent);
//加密后的密文
String jiaMi = RSAUtils.encryptByPublicKey(Ming, pubKey);
//解密后的明文
String jieMing = RSAUtils.decryptByPrivateKey(Mi, priKey);
ArrayList keyList= new ArrayList();
keyList.add(jiaMi);
keyList.add(jieMing);
return keyList;
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
return null;
}
}
----------------------------------------------------------------RSA加密解密,结束---------------------------------------------------------------------
--------------------------------------------------------RSA 加密解密,另一种写法,没仔细尝试----------------------------------------------------
RSA加密
public class testRSAmainJiami {
public static void main(String[] args) throws Exception {
ArrayList<homwork> list = homeworkQuery.getAllStus();
keyofRSA testInOutRSA= new keyofRSA();
if(list.size() == 0){
System.out.println("暂无数据");
return;
}
for(homwork s: list){ //遍历集合数据
System.out.println(s.getName()+"\t"+s.getIdCardNo()+"\t"+s.getBirthday()+"\t"+s.getPay());
//加密String
String birth = testInOutRSA.stringInRSA(s.getBirthday());
String pay = testInOutRSA.stringInRSA(s.getPay());
s.setBirthday(birth);
s.setPay(pay);
savehomwork.saveHomwork(s);
}
}
}
RSA解密
public class testRSAJiemi {
public static void main(String[] args) throws Exception {
ArrayList<homwork> list = homeworkQuery.getAllStus();
keyofRSA testInOutRSA= new keyofRSA();
if(list.size() == 0){
System.out.println("暂无数据");
return;
}
for(homwork s: list){ //遍历集合数据
System.out.println(s.getName()+"\t"+s.getIdCardNo()+"\t"+s.getBirthday()+"\t"+s.getPay());
//加密String
String birth = testInOutRSA.stringOutRSA(s.getBirthday());
String pay = testInOutRSA.stringOutRSA(s.getPay());
s.setBirthday(birth);
s.setPay(pay);
savehomwork.saveHomwork(s);
}
}
}
查找
public class homeworkQuery {
public static void main(String[] args) {
ArrayList<homwork> list = getAllStus();
if(list.size() == 0){
System.out.println("暂无数据");
}else{
for(homwork s: list){ //遍历集合数据
System.out.println(s.getName()+"\t"+s.getIdCardNo()+"\t"+s.getBirthday()+"\t"+s.getPay());
}
}
}
public static ArrayList<homwork> getAllStus(){
ArrayList<homwork> stulist = new ArrayList<homwork>();
String url = "com.mysql.jdbc.Driver"; //加载驱动包
String connectSql = "jdbc:mysql://localhost:3306/demo"; //链接MySQL数据库
String sqlUser = "root"; //数据库账号
String sqlPasswd = "x5"; //你的数据库密码
Connection con = null;
PreparedStatement psm = null;
ResultSet rs = null;
System.out.println("连接数据库成功!");
try {
//加载驱动包
Class.forName(url);
//连接MYSQL
con = DriverManager.getConnection(connectSql,sqlUser,sqlPasswd);
//执行MYSQL语句
psm = con.prepareStatement("select * from homwork");
rs = psm.executeQuery();
System.out.println("姓名"+"\t"+"身份证号码"+"\t"+"出生日期"+"\t"+"薪资");
while(rs.next()){
homwork s = new homwork();
s.setName(rs.getString(3));
s.setIdCardNo(rs.getString(2));
s.setBirthday(rs.getString(5));
s.setPay(rs.getString(7));
stulist.add(s);
}
//修改数据的代码
String sql="update homwork set pay=100 where Id=1 ";//生成一条mysql语句
Statement stmt=con.createStatement();//创建一个Statement对象
stmt.executeUpdate(sql);//执行SQL语句
System.out.println("修改数据库成功!!!");
//关闭数据库连接
rs.close();
psm.close();
con.close();
} catch (Exception e) {
System.out.println("显示所有数据报错,原因:"+e.getMessage());
}
return stulist;
}
}
public class keyofRSA {
public RSAPublicKey publicKey() throws NoSuchAlgorithmException{ //创建公钥KEY
HashMap<String, Object> map = RSAUtils.getKeys();
//生成公钥
RSAPublicKey publicKey = (RSAPublicKey) map.get("public");
return publicKey;
}
public RSAPrivateKey privateKey() throws NoSuchAlgorithmException{ //创建私钥KEY
HashMap<String, Object> map = RSAUtils.getKeys();
//生成私钥
RSAPrivateKey privateKey = (RSAPrivateKey) map.get("private");
return privateKey;
}
//加密String
public String stringInRSA(String stringIn) throws Exception{
System.out.println("明文为:"+stringIn);//明文
RSAPublicKey publicKey = publicKey();
String modulus = publicKey.getModulus().toString(); //模
String public_exponent = publicKey.getPublicExponent().toString(); //公钥指数
RSAPublicKey pubKey = RSAUtils.getPublicKey(modulus, public_exponent); //使用模和指数生成公钥和私钥
String mi = RSAUtils.encryptByPublicKey(stringIn, pubKey); //加密后的密文
System.err.println("加密后的密文:"+mi);
return mi;
}
//解密String
public String stringOutRSA(String stringMi) throws Exception{
RSAPrivateKey privateKey = privateKey();
String modulus = privateKey.getModulus().toString(); //模
//私钥指数
String private_exponent = privateKey.getPrivateExponent().toString();
//使用模和指数生成公钥和私钥
RSAPrivateKey priKey = RSAUtils.getPrivateKey(modulus, private_exponent);
String ming = RSAUtils.decryptByPrivateKey(stringMi, priKey);
System.err.println("解密后的密文:"+ming);
return ming;
}
}
//保存
public class savehomwork {
public static ArrayList<homwork> saveHomwork(homwork homwork){
ArrayList<homwork> stulist = new ArrayList<homwork>();
String url = "com.mysql.jdbc.Driver"; //加载驱动包
String connectSql = "jdbc:mysql://localhost:3306/demo"; //链接MySQL数据库
String sqlUser = "root"; //数据库账号
String sqlPasswd = "x5"; //你的数据库密码
Connection con = null;
PreparedStatement psm = null;
ResultSet rs = null;
System.out.println("连接数据库成功!");
try {
//加载驱动包
Class.forName(url);
//连接MYSQL
con = DriverManager.getConnection(connectSql,sqlUser,sqlPasswd);
System.out.println("修改数据库成功!!!");
String updateNamesql = "UPDATE homwork SET birthday="+homwork.getBirthday() +"; ";
String updatePaysql = "UPDATE homwork SET pay="+homwork.getPay() +"; ";
PreparedStatement stmt = con.prepareStatement(updateNamesql);
PreparedStatement stmt2 = con.prepareStatement(updatePaysql);
stmt.executeUpdate();
stmt2.executeUpdate();
//关闭数据库连接
rs.close();
psm.close();
con.close();
} catch (Exception e) {
System.out.println("显示所有数据报错,原因:"+e.getMessage());
}
return stulist;
}
}
--------------------------------------------------RSA加密解密结束---------------------------------------------------------------------