package utils;
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
public final class ConnectionSafer {
private static int length = 16;
/** 指定默认存放路径 ,默认为C:ConnectionSafer */
private static String defaultPath = "C:ConnectionSafer";
/** 指定默认存放路径 ,默认为C:ConnectionSafer */
private static String namespace = "";
/** 指定用户名存放文件 名 */
private static String USERNAME = "UESRNAME";
/** 指定密码存放文件 名 */
private static String PASSWORD = "PASSWORD";
/** 指定密码存放文件 名 */
private static String Certificate = "Certificate";
private static String KEY = "KEY";
private static String key;
private static Map<String, byte[]> userCertificate = new HashMap<String, byte[]>();
private static File Certificate_FILE;
private static Random randGen = null;
private static char[] numberAndLetters = null;
/** 储存密钥对的变量 */
private static String Key_Store;
/** 储存解密的用户名的变量 */
private static byte[] Username_Decrypt_Store;
/** 储存解密的密码的变量 */
private static byte[] Password_Decrypt_Store;
private static ConnectionSafer INSTANCE;
private static String generateKey(int length) {
if (length < 1) {
return null;
}
if (randGen == null) {
randGen = new Random();
numberAndLetters = ("0123456789abcdefghijklmnopqrstuvwxyz"
+ "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ").toCharArray();
}
char[] randBuffer = new char[length];
for (int i = 0; i < randBuffer.length; i++) {
randBuffer[i] = numberAndLetters[randGen.nextInt(71)];
}
return new String(randBuffer);
}
/**
*
* 存储加密的用户名密码到本地（默认为C:ConnectionSafer）
*
* @throws Exception
*/
private static void saveCertificate() throws Exception {
if (!Certificate_FILE.getParentFile().exists()) {
Certificate_FILE.getParentFile().mkdirs();
}
FileOutputStream fos = new FileOutputStream(new File(
Certificate_FILE.getPath()));
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(userCertificate);
fos.flush();
fos.close();
System.out.println("Certificate_FILE IS SAVED AT : "
+ Certificate_FILE.getPath());
}
/**
*
* 读取本地（默认为C:ConnectionSafer）的加密的密码（默认为C:ConnectionSafer）
*
* @throws Exception
*/
@SuppressWarnings("unchecked")
private static void loadCertificate() throws Exception {
FileInputStream fis = new FileInputStream(Certificate_FILE.getPath());
ObjectInputStream ois = new ObjectInputStream(fis);
userCertificate = (Map<String, byte[]>) ois.readObject();
fis.close();
ois.close();
System.out.println("Certificate_FILE IS LOADED FROM: "
+ Certificate_FILE.getPath());
}
private static boolean isinitiated() {
if (INSTANCE == null) {
Builder.builder.build();
}
return Certificate_FILE.exists();
}
private ConnectionSafer() {
defaultPath = Builder.path;
namespace = Builder.namespace;
Certificate_FILE = new File(new File(defaultPath), Certificate + "_"
+ namespace);
}
/**
*
* 删除本地（默认为C:ConnectionSafer）的加密的用户名密码（默认为C:ConnectionSafer）
*
*
*/
public static void removeCertificate() {
if (isinitiated()) {
Certificate_FILE.delete();
System.out.println("Certificate_FILE IS SUCCESSFUL DELETED FROM: "
+ Certificate_FILE.getPath());
} else {
System.out.println("Certificate_FILE IS FAIL DELETED FROM: "
+ Certificate_FILE.getPath());
}
}
/**
*
* 初始化用户名密码，产生密钥对并储存到本地（默认为C:ConnectionSafer），然后加密数据储存到本地（默认为C:
* ConnectionSafer ）
*
* @throws Exception
*/
public static void initConnection() throws Exception {
isinitiated();
// 生成公钥及私钥
Key_Store = generateKey(length);
System.out.println("Input your username:");
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
Username_Decrypt_Store = br.readLine().getBytes();
System.out.println("Input your password:");
Password_Decrypt_Store = br.readLine().getBytes();
System.out.println("Input to set your Certificate Passworld:");
key = br.readLine();
if (!key.trim().equals("")) {
key = key.trim();
userCertificate.put(KEY, Crypt.encrypt(Key_Store.getBytes(), key));
} else {
userCertificate.put(KEY, Key_Store.getBytes());
}
userCertificate.put(USERNAME,
Crypt.encrypt(Username_Decrypt_Store, Key_Store));
userCertificate.put(PASSWORD,
Crypt.encrypt(Password_Decrypt_Store, Key_Store));
saveCertificate();
}
public static Connection getConnection(String Driver, String Url)
throws Exception {
if (!isinitiated()) {
initConnection();
} else if (key==null||Key_Store==null) {
loadCertificate();
Class.forName(Driver);
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.println("Input your Certificate Pass:");
key = br.readLine();
}
if (!key.trim().equals("")) {
key = key.trim();
Key_Store = new String(Crypt.decrypt(userCertificate.get(KEY), key));
} else {
Key_Store = new String(userCertificate.get(KEY));
}
String usr = new String(Crypt.decrypt(userCertificate.get(USERNAME),
Key_Store)).trim();
String pwd = new String(Crypt.decrypt(userCertificate.get(PASSWORD),
Key_Store)).trim();
Connection con = DriverManager.getConnection(Url, usr, pwd);
return con;
}
public static enum Builder {
builder;
private static String path = "C:ConnectionSafer";
private static String namespace = "defaultname";
public Builder setPath(String path) {
if (path != null && !path.trim().equals("")) {
Builder.path = path;
}
build();
return this;
}
public Builder setNamespace(String namespace) {
if (namespace != null && !namespace.trim().equals("")) {
Builder.namespace = namespace;
}
build();
return this;
}
public void build(){
INSTANCE = new ConnectionSafer();
}
}
private static class Crypt {
private static final String CHARSET = "UTF-8";
public static byte[] decrypt(byte[] data, String key)
throws IOException {
return new AES().decrypt(data, key.getBytes(CHARSET));
}
public static byte[] encrypt(byte[] data, String key)
throws IOException {
return new AES().encrypt(data, key.getBytes(CHARSET));
}
}
private static class AES {
private final static int[] sbox = { 0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B,
0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,
0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4,
0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0, 0xB7, 0xFD, 0x93, 0x26,
0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8,
0x31, 0x15, 0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A,
0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75, 0x09, 0x83,
0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3,
0x29, 0xE3, 0x2F, 0x84, 0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC,
0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9,
0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8, 0x51, 0xA3, 0x40, 0x8F,
0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF,
0xF3, 0xD2, 0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17,
0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73, 0x60, 0x81,
0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14,
0xDE, 0x5E, 0x0B, 0xDB, 0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06,
0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,
0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56,
0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08, 0xBA, 0x78, 0x25, 0x2E,
0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD,
0x8B, 0x8A, 0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E,
0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E, 0xE1, 0xF8,
0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9,
0xCE, 0x55, 0x28, 0xDF, 0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6,
0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16 };
private final static int[] isbox = { 0x52, 0x09, 0x6A, 0xD5, 0x30,
0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7,
0xFB, 0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, 0x34,
0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB, 0x54, 0x7B, 0x94,
0x32, 0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B, 0x42,
0xFA, 0xC3, 0x4E, 0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24,
0xB2, 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25, 0x72,
0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xD4, 0xA4, 0x5C,
0xCC, 0x5D, 0x65, 0xB6, 0x92, 0x6C, 0x70, 0x48, 0x50, 0xFD,
0xED, 0xB9, 0xDA, 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D,
0x84, 0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, 0xF7,
0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06, 0xD0, 0x2C, 0x1E,
0x8F, 0xCA, 0x3F, 0x0F, 0x02, 0xC1, 0xAF, 0xBD, 0x03, 0x01,
0x13, 0x8A, 0x6B, 0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC,
0xEA, 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73, 0x96,
0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9, 0x37,
0xE8, 0x1C, 0x75, 0xDF, 0x6E, 0x47, 0xF1, 0x1A, 0x71, 0x1D,
0x29, 0xC5, 0x89, 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE,
0x1B, 0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 0x9A,
0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4, 0x1F, 0xDD, 0xA8,
0x33, 0x88, 0x07, 0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59, 0x27,
0x80, 0xEC, 0x5F, 0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A,
0x0D, 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF, 0xA0,
0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, 0xC8, 0xEB, 0xBB,
0x3C, 0x83, 0x53, 0x99, 0x61, 0x17, 0x2B, 0x04, 0x7E, 0xBA,
0x77, 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C,
0x7D };
private final static int[] LogTable = { 0, 0, 25, 1, 50, 2, 26, 198,
75, 199, 27, 104, 51, 238, 223, 3, 100, 4, 224, 14, 52, 141,
129, 239, 76, 113, 8, 200, 248, 105, 28, 193, 125, 194, 29,
181, 249, 185, 39, 106, 77, 228, 166, 114, 154, 201, 9, 120,
101, 47, 138, 5, 33, 15, 225, 36, 18, 240, 130, 69, 53, 147,
218, 142, 150, 143, 219, 189, 54, 208, 206, 148, 19, 92, 210,
241, 64, 70, 131, 56, 102, 221, 253, 48, 191, 6, 139, 98, 179,
37, 226, 152, 34, 136, 145, 16, 126, 110, 72, 195, 163, 182,
30, 66, 58, 107, 40, 84, 250, 133, 61, 186, 43, 121, 10, 21,
155, 159, 94, 202, 78, 212, 172, 229, 243, 115, 167, 87, 175,
88, 168, 80, 244, 234, 214, 116, 79, 174, 233, 213, 231, 230,
173, 232, 44, 215, 117, 122, 235, 22, 11, 245, 89, 203, 95,
176, 156, 169, 81, 160, 127, 12, 246, 111, 23, 196, 73, 236,
216, 67, 31, 45, 164, 118, 123, 183, 204, 187, 62, 90, 251, 96,
177, 134, 59, 82, 161, 108, 170, 85, 41, 157, 151, 178, 135,
144, 97, 190, 220, 252, 188, 149, 207, 205, 55, 63, 91, 209,
83, 57, 132, 60, 65, 162, 109, 71, 20, 42, 158, 93, 86, 242,
211, 171, 68, 17, 146, 217, 35, 32, 46, 137, 180, 124, 184, 38,
119, 153, 227, 165, 103, 74, 237, 222, 197, 49, 254, 24, 13,
99, 140, 128, 192, 247, 112, 7 };
private final static int[] AlogTable = { 1, 3, 5, 15, 17, 51, 85, 255,
26, 46, 114, 150, 161, 248, 19, 53, 95, 225, 56, 72, 216, 115,
149, 164, 247, 2, 6, 10, 30, 34, 102, 170, 229, 52, 92, 228,
55, 89, 235, 38, 106, 190, 217, 112, 144, 171, 230, 49, 83,
245, 4, 12, 20, 60, 68, 204, 79, 209, 104, 184, 211, 110, 178,
205, 76, 212, 103, 169, 224, 59, 77, 215, 98, 166, 241, 8, 24,
40, 120, 136, 131, 158, 185, 208, 107, 189, 220, 127, 129, 152,
179, 206, 73, 219, 118, 154, 181, 196, 87, 249, 16, 48, 80,
240, 11, 29, 39, 105, 187, 214, 97, 163, 254, 25, 43, 125, 135,
146, 173, 236, 47, 113, 147, 174, 233, 32, 96, 160, 251, 22,
58, 78, 210, 109, 183, 194, 93, 231, 50, 86, 250, 21, 63, 65,
195, 94, 226, 61, 71, 201, 64, 192, 91, 237, 44, 116, 156, 191,
218, 117, 159, 186, 213, 100, 172, 239, 42, 126, 130, 157, 188,
223, 122, 142, 137, 128, 155, 182, 193, 88, 232, 35, 101, 175,
234, 37, 111, 177, 200, 67, 197, 84, 252, 31, 33, 99, 165, 244,
7, 9, 27, 45, 119, 153, 176, 203, 70, 202, 69, 207, 74, 222,
121, 139, 134, 145, 168, 227, 62, 66, 198, 81, 243, 14, 18, 54,
90, 238, 41, 123, 141, 140, 143, 138, 133, 148, 167, 242, 13,
23, 57, 75, 221, 124, 132, 151, 162, 253, 28, 36, 108, 180,
199, 82, 246, 1 };
private final static int[][] rcon = {
{ 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1B, 0x36 },
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } };
private final static int NUMROUNDS = 10;
private byte[][] state;
private byte[][] keys;
private void setKey(byte[] key) {
for (int i = 0; i < keys.length; i++) {
for (int j = 0; j < keys[0].length / (NUMROUNDS + 1); j++) {
if (i * keys.length + j < key.length) {
keys[j][i] = key[i * keys.length + j];
} else {
break;
}
}
}
int rconIndex = 0;
for (int i = 4; i < 4 * (NUMROUNDS + 1); i++) {
byte[] col = getColumn(keys, i - 1);
if (i % 4 == 0) {
col = rotateWord(col);
col = subBytesKey(col);
col = xorBytes(col, getColumn(keys, i - 4));
col = xorRcon(col, rconIndex);
rconIndex++;
} else {
col = xorBytes(col, getColumn(keys, i - 4));
}
columnCopy(keys, i, col);
}
}
private byte[] getColumn(byte[][] mat, int pos) {
byte[] result = new byte[mat.length];
for (int i = 0; i < 4; i++)
result[i] = mat[i][pos];
return result;
}
private void columnCopy(byte[][] mat, int pos, byte[] col) {
for (int i = 0; i < col.length; i++) {
mat[i][pos] = col[i];
}
}
private byte[] rotateWord(byte[] arr) {
byte[] result = new byte[arr.length];
for (int i = 0; i < arr.length - 1; i++)
result[i] = arr[i + 1];
result[result.length - 1] = arr[0];
return result;
}
private byte[] subBytesKey(byte[] arr) {
byte[] result = new byte[arr.length];
for (int i = 0; i < arr.length; i++) {
int j = arr[i];
result[i] = (byte) (sbox[j & 0x000000FF] & 0xFF);
}
return result;
}
private byte[] xorBytes(byte[] m, byte[] n) {
byte[] result = new byte[m.length];
for (int i = 0; i < m.length; i++)
result[i] = (byte) (m[i] ^ n[i]);
return result;
}
private byte[] xorRcon(byte[] arr, int index) {
arr[0] = (byte) (arr[0] ^ (rcon[0][index] & 0xff));
return arr;
}
private void subBytes() {
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
byte b = state[i][j];
state[i][j] = (byte) (sbox[b & 0x000000FF] & 0xFF);
}
}
}
private void shiftRows() {
byte[] row = new byte[4];
int shift = 0;
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
row[j] = state[i][j];
}
for (int j = 0; j < 4; j++) {
state[i][j] = row[(j + shift) % 4];
}
shift++;
}
}
private byte mul(int a, byte b) {
int inda = (a < 0) ? (a + 256) : a;
int indb = (b < 0) ? (b + 256) : b;
if ((a != 0) && (b != 0)) {
int index = (LogTable[inda] + LogTable[indb]);
byte val = (byte) (AlogTable[index % 255]);
return val;
} else
return 0;
}
private void mixColumn(int c) {
byte a[] = new byte[4];
for (int i = 0; i < 4; i++)
a[i] = state[i][c];
state[0][c] = (byte) (mul(2, a[0]) ^ a[2] ^ a[3] ^ mul(3, a[1]));
state[1][c] = (byte) (mul(2, a[1]) ^ a[3] ^ a[0] ^ mul(3, a[2]));
state[2][c] = (byte) (mul(2, a[2]) ^ a[0] ^ a[1] ^ mul(3, a[3]));
state[3][c] = (byte) (mul(2, a[3]) ^ a[1] ^ a[2] ^ mul(3, a[0]));
}
private void mixColumnInverse(int c) {
byte a[] = new byte[4];
for (int i = 0; i < 4; i++)
a[i] = state[i][c];
state[0][c] = (byte) (mul(0xE, a[0]) ^ mul(0xB, a[1])
^ mul(0xD, a[2]) ^ mul(0x9, a[3]));
state[1][c] = (byte) (mul(0xE, a[1]) ^ mul(0xB, a[2])
^ mul(0xD, a[3]) ^ mul(0x9, a[0]));
state[2][c] = (byte) (mul(0xE, a[2]) ^ mul(0xB, a[3])
^ mul(0xD, a[0]) ^ mul(0x9, a[1]));
state[3][c] = (byte) (mul(0xE, a[3]) ^ mul(0xB, a[0])
^ mul(0xD, a[1]) ^ mul(0x9, a[2]));
}
private void mixColumns() {
for (int i = 0; i < 4; i++)
mixColumn(i);
}
private void mixColumnsInverse() {
for (int i = 0; i < 4; i++)
mixColumnInverse(i);
}
private void addRoundKey(int currentRound) {
byte[] col;
int j = 0;
for (int i = 0; i < 4; i++) {
col = xorBytes(getColumn(state, i),
getColumn(keys, currentRound * 4 + j));
columnCopy(state, i, col);
j++;
}
}
private void subBytesInverse() {
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
byte b = state[i][j];
state[i][j] = (byte) (isbox[b & 0x000000FF] & 0xFF);
}
}
}
private void shiftRowsInverse() {
byte[] row = new byte[4];
int shift = 0;
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
row[(j + shift) % 4] = state[i][j];
}
for (int j = 0; j < 4; j++) {
state[i][j] = row[j];
}
shift++;
}
}
public AES() {
state = new byte[4][4];
keys = new byte[4][4 * (NUMROUNDS + 1)];
}
public byte[] encrypt(byte[] data, byte[] key) {
this.setKey(key);
ByteArrayOutputStream bout = new ByteArrayOutputStream();
int n = (int) Math.ceil(data.length / 16.0);
for (int i = 0; i < n; i++) {
for (int j = 0; j < 4; j++) {
for (int k = 0; k < 4; k++) {
if (i * 16 + j * 4 + k < data.length) {
state[k][j] = data[i * 16 + j * 4 + k];
} else {
state[k][j] = (byte) 0;
}
}
}
addRoundKey(0);
for (int j = 1; j < NUMROUNDS + 1; j++) {
subBytes();
shiftRows();
if (j != NUMROUNDS)
mixColumns();
addRoundKey(j);
}
for (int j = 0; j < 4; j++) {
for (int k = 0; k < 4; k++) {
bout.write(state[k][j]);
}
}
}
return bout.toByteArray();
}
public byte[] decrypt(byte[] data, byte[] key) {
this.setKey(key);
ByteArrayOutputStream bout = new ByteArrayOutputStream();
int n = (int) Math.ceil(data.length / 16.0);
for (int i = 0; i < n; i++) {
for (int j = 0; j < 4; j++) {
for (int k = 0; k < 4; k++) {
if (i * 16 + j * 4 + k < data.length) {
state[k][j] = data[i * 16 + j * 4 + k];
} else {
state[k][j] = (byte) 0;
}
}
}
addRoundKey(NUMROUNDS);
for (int j = NUMROUNDS - 1; j > -1; j--) {
subBytesInverse();
shiftRowsInverse();
addRoundKey(j);
if (j != 0) // last round has no mixColumns
mixColumnsInverse();
}
for (int j = 0; j < 4; j++) {
for (int k = 0; k < 4; k++) {
bout.write(state[k][j]);
}
}
}
return bout.toByteArray();
}
}
}加密的算法是从httpdb这个开源项目提取出来的，其他代码块均为原创。
调用方法如下：
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.Statement;
public class test {
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
String path = "C:/Users/Administrator/Desktop/safeConnection";
// sl.removeCertificate();
String url = "jdbc:sqlserver://localhost:1433;DatabaseName=goods";//根据实际情况改
String sqlStr = "select * from t_book";//根据实际情况改
String SDriver = "com.microsoft.sqlserver.jdbc.SQLServerDriver";
try {
ConnectionSafer.Builder.builder.setPath(path);
ConnectionSafer.Builder.builder.setNamespace("jiami");
ConnectionSafer.removeCertificate();
ConnectionSafer.initConnection();
Connection con =ConnectionSafer.getConnection(SDriver, url);
Statement st = con.createStatement();
ResultSet rs = st.executeQuery(sqlStr);
// 输出所有查询结果
ResultSetMetaData rsmd = rs.getMetaData();
int col = rsmd.getColumnCount();
while (rs.next()) {
int i = 1;
String str = "";
while (i <= col) {
str = str + rs.getString(i) + "\t\t";
i++;
}
System.out.println(str);
}
rs.close();
st.close();
con.close();
} catch (Exception err) {
err.printStackTrace(System.out);
}
}
}
235
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
