 |
Subscribe
to this
site |
|
TESTE HAPA ALPHA
Published 5 months ago
by
Anonymous
import javax.crypto.Cipherimport javax.crypto.SecretKey
import javax.crypto.SecretKeyFactory
import javax.crypto.spec.IvParameterSpec
import javax.crypto.spec.PBEKeySpec
import javax.crypto.spec.SecretKeySpec
import java.security.Key
import java.security.spec.KeySpec
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
encrypt("1100000000000000000000000000") //Your text here
Map map = dispose("1KQ+dHUDvoMx3ozllr6gBPmW/5bgKUv7hQTPVcbVVImRb5UY7mW814o85tEfykVKzwTSr6OTWSN2HvWk+bHLNXYmTP/KZt0ELI8cINmylwruRZgcxgD0leF3jUeYAz5C5pjC6BdQ+GjFNg==".replaceAll("[\\r\\n]", ""), "56789jskwijskcnxmesd");
String encrypt(String strToEncrypt) {
int lockEvents = ((0x000001f0 & 0xFF) << 24 | (0x000001f0 & 0xFF) << 16 | (0x000001f0 & 0xFF) << 8 | 0x000001f0 & 0xFF);
int n = ((String) strToEncrypt).length() / 2;
byte[] byArray = new byte[n];
byte[] retorno = new byte[64];
byte[] byArray2 = new byte[16];
byte[] byArray3 = new byte[16];
//byArray2 = [0x11, 0x00,0x00,0x01,0x63,0x63,0xEC,0xC1,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFC,0xFC,0xFC,0xFC,0xFC,0xFC,0xFC,0xFC,0xFC,0xFC,0xFC,];
byArray2 = [0x65, 0xAF,0x9A,0xCC,0xB9,0x75,0x11,0xFC, 0xE2, 0xD0, 0xFC, 0xCA, 0x12, 0x09, 0x5B, 0x39];
byArray3 = [0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
String string = "";
String encryptionKey = "1234567890123456";//Paste your key here
//return Bytes2HexString(byArray2);
retorno = Encrypt(byArray3, encryptionKey);
byArray2 = retorno;
//return Bytes2HexString (retorno);
System.out.println(Bytes2HexString (retorno));
//return null;
retorno = Decrypt1(byArray2, encryptionKey);
System.out.println(Bytes2HexString (retorno));
return null;
return Decrypt1(retorno , encryptionKey);
return Decrypt1(byArray2 , encryptionKey);
byArray = hexStringToByte(strToEncrypt);
//int lockEvents = -411493796;
//var0.setRoomEvents(0);
//setGuestEvents(0);
//var4_23 = var0.getRoomMainKey().getBytes();
//var7_26 /* !! */ = generateWorkingKey(var4_23, 0);
//return generateSignatureV2(var7_26 , lockEvents, Bytes2AsciiString(var13_31, 3, var3_22));
// var0 = generateSignatureV2(generateWorkingKey(var4_23, var0.getRoomEvents()), var0.getLockEvents(), Bytes2AsciiString(var13_31, 3, var2_21));
return generateSignatureV2(byArray2, lockEvents, Bytes2AsciiString(byArray, 3, 4));
//Key aesKey = new SecretKeySpec(encryptionKey.getBytes("UTF-8"), "AES");
if (!strToEncrypt) return strToEncrypt
//Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding")
//cipher.init(1, aesKey);
//retorno = cipher.doFinal(byArray);
//int i;
//String x = "0123456789ABCDEF";
//for (i = 0; i < retorno.length; i++){
//char ch = (retorno[i] >> ((32-4) - i*4)) & 0xF;
// string += Integer.toHexString((retorno[i] >> ((32-4) - i*4)) & 0xF);
//}
// unsigned char ch = (a >> ((32-4) - i*4)) & 0xF;
// string[i] = arr[ch];
//}
//string[i] = '\0';
//String encryptedStr = cipher.doFinal(strToEncrypt.getBytes("UTF-8")).encodeBase64()
//System.arraycopy(byArray, 0, retorno, 0, 5);
//return byArray;
//return retorno;
retorno = Encrypt(byArray, encryptionKey);
return Bytes2HexString (retorno);
//return string;
//return bytesToHexString (retorno);
}
public static byte[] Encrypt(byte[] byArray, String object) throws Exception {
if (object == null) {
return null;
}
if (((String)object).length() < 16) {
return null;
}
Object object2 = object;
if (((String)object).length() > 16) {
object2 = ((String)object).substring(0, 16);
}
Key aesKey = new SecretKeySpec(object2.getBytes("UTF-8"), "AES");
//object = new SecretKeySpec(((String)object2).getBytes("utf-8"), "AES");
object2 = Cipher.getInstance("AES/ECB/PKCS5Padding");
((Cipher)object2).init(1, aesKey);
return ((Cipher)object2).doFinal(byArray);
}
public byte toByte(char c) {
String x = "0123456789ABCDEF";
byte z = x.indexOf((String)c);
return z;
}
public byte[] hexStringToByte(String object) {
int n = ((String)object).length() / 2;
byte[] byArray = new byte[n];
object = ((String)object).toCharArray();
for (int i = 0; i < n; ++i) {
int n2 = i * 2;
byte by = this.toByte((char)object[n2]);
byArray[i] = (byte)(this.toByte((char)object[n2 + 1]) | by << 4);
}
return byArray;
}
public static String Bytes2AsciiString(byte[] byArray, int n, int n2) {
byte[] byArray2 = new byte[n2 - n];
for (int i = n; i < n2; ++i) {
byArray2[i - n] = byArray[i];
}
return byteToString(byArray2);
}
public static String Bytes2HexString(byte[] byArray) {
byte[] hex = "0123456789ABCDEF".getBytes();
byte[] byArray2 = new byte[byArray.length * 2];
for (int i = 0; i < byArray.length; ++i) {
int n = i * 2;
byte[] byArray3 = hex;
byArray2[n] = byArray3[byArray[i] >> 4 & 0xF];
byArray2[n + 1] = byArray3[byArray[i] & 0xF];
}
return new String(byArray2);
}
public static String byteToString(byte[] byArray) {
String string = "";
int n = byArray.length;
for (int i = 0; i < n; ++i) {
char c = (char)byArray[i];
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append(string);
stringBuilder.append(c);
string = stringBuilder.toString();
}
return string;
}
public static char getCheckSum(byte[] byArray, int n, int n2) {
char c;
char c2 = c = '\u0000';
for (int i = 0; i < n; ++i) {
c = (char)(c2 + byArray[i + n2]);
c2 = c;
}
return c2;
}
public String bytesToHexString(byte[] paramArrayOfbyte) {
StringBuffer stringBuffer = new StringBuffer(paramArrayOfbyte.length);
for (byte b = 0;; b++) {
if (b >= paramArrayOfbyte.length)
return stringBuffer.toString();
String str = Integer.toHexString(paramArrayOfbyte[b] & 0xFF);
if (str.length() < 2)
stringBuffer.append(0);
stringBuffer.append(str.toUpperCase());
}
}
private static byte[] XOR64BufferWith36(byte[] byArray) {
for (int i = 0; i < 64; ++i) {
byArray[i] = (byte)(byArray[i] ^ 0x36);
}
return byArray;
}
private static byte[] XOR64BufferWith5c(byte[] byArray) {
for (int i = 0; i < 64; ++i) {
byArray[i] = (byte)(byArray[i] ^ 0x5C);
}
return byArray;
}
public static byte[] generateGuestWorkingKey(String string, int n, String string2) {
byte[] byArray = new byte[string2.length() + 8];
byte by = (byte)(n >> 24);
int n2 = 0;
byArray[0] = by;
byArray[1] = (byte)(n >> 16);
byArray[2] = (byte)(n >> 8);
byArray[3] = (byte)n;
for (n = n2; n < string2.length(); ++n) {
byArray[n + 7] = (byte)string2.charAt(n);
}
return hmacSha1(string, byteToString(byArray));
}
public static byte[] generatePsw(byte[] byArray) {
byte[] byArray2 = new byte[8];
int n = hotp4ToInt(byArray, byArray[19] & 0xF) % 100000000;
for (int i = 0; i < 8; ++i) {
if (i == 0) {
byArray2[7 - i] = (byte)48;
}
byArray2[7 - i] = (byte)(n % 10 + 48);
n /= 10;
}
return byArray2;
}
public static byte[] generatePswV2(byte[] byArray) {
byte[] byArray2 = new byte[8];
for (int i = 0; i < 4; ++i) {
byte by = byArray[i + 16];
int n = i * 2;
byArray2[n] = byArray[by >> 4 & 0xF];
byArray2[n + 1] = byArray[by & 0xF];
}
return byArray2;
}
public static byte[] generateSignatureV2(byte[] byArray, int n, String object) {
int n2;
int n3 = ((String)object).length();
byte[] byArray2 = new byte[((String)object).length() + 68];
int n4 = 0;
for (n2 = 0; n2 < 20; ++n2) {
byArray2[n2] = byArray[n2];
}
byArray2 = XOR64BufferWith36(byArray2);
for (n2 = 0; n2 < ((String)object).length(); ++n2) {
byArray2[n2 + 64] = (byte)((String)object).charAt(n2);
}
n2 = n3 + 64;
byArray2[n2] = (byte)(n >> 24);
byArray2[n2 + 1] = (byte)(n >> 16);
byArray2[n2 + 2] = (byte)(n >> 8);
byArray2[n2 + 3] = (byte)n;
object = digest(byArray2);
byArray2 = new byte[184];
for (n = 0; n < 20; ++n) {
byArray2[n] = byArray[n];
}
byArray = XOR64BufferWith5c(byArray2);
for (n = n4; n < ((Object)object).length(); ++n) {
byArray[n + 64] = (byte)object[n];
}
return generatePswV2(digest(byArray));
}
public static byte[] generateWorkingKey(byte[] byArray, int n) {
byte[] byArray2 = new byte[72];
int n2 = 0;
for (int i = 0; i < byArray.length; ++i) {
byArray2[i] = byArray[i];
}
byArray2 = XOR64BufferWith36(byArray2);
byArray2[68] = (byte)(n >> 24);
byArray2[69] = (byte)(n >> 16);
byArray2[70] = (byte)(n >> 8);
byArray2[71] = (byte)n;
byArray2 = digest(byArray2);
byte[] byArray3 = new byte[84];
for (n = 0; n < byArray.length; ++n) {
byArray3[n] = byArray[n];
}
byArray = XOR64BufferWith5c(byArray3);
for (n = n2; n < byArray2.length; ++n) {
byArray[n + 64] = byArray2[n];
}
return digest(byArray);
}
public static byte[] hmacSha1(String object, String object2) {
int n;
byte[] byArray = new byte[((String)object2).length() + 64];
int n2 = 0;
for (n = 0; n < 20; ++n) {
byArray[n] = (byte)((String)object).charAt(n);
}
byArray = XOR64BufferWith36(byArray);
for (n = 0; n < ((String)object2).length(); ++n) {
byArray[n + 64] = (byte)((String)object2).charAt(n);
}
object2 = digest(byArray);
byArray = new byte[84];
for (n = 0; n < 20; ++n) {
byArray[n] = (byte)((String)object).charAt(n);
}
object =XOR64BufferWith5c(byArray);
for (n = n2; n < ((Object)object2).length; ++n) {
object[n + 64] = (byte)object2[n];
}
return digest((byte[])object);
}
public static int hotp4ToInt(byte[] byArray, int n) {
byte by = byArray[n];
byte by2 = byArray[n + 1];
byte by3 = byArray[n + 2];
return byArray[n + 3] & 0xFF | ((by & 0x7F) << 24 | (by2 & 0xFF) << 16 | (by3 & 0xFF) << 8);
}
public static byte[] digest(byte[] byArray) { try {
MessageDigest messageDigest = MessageDigest.getInstance("SHA1");
messageDigest.update(byArray);
byArray = messageDigest.digest();
return byArray;
}
catch (Exception exception) {
throw new RuntimeException(exception);
}
}
public static byte[] Decrypt1(byte[] string, String object) throws Exception {
if (object == null) {
System.out.print("Key为空null");
return null;
}
if (((String)object).length() != 16) {
System.out.print("Key的长度有误");
return null;
}
System.out.println((String)object);
System.out.println(object.getBytes("UTF-8"));
Object object2 = object;
object2 = ((String)object).substring(0, 16);
Key aesKey = new SecretKeySpec(object2.getBytes("UTF-8"), "AES");
object2 = Cipher.getInstance("AES/ECB/PKCS5Padding");
((Cipher)object2).init(2, aesKey);
System.out.println("AQUI");
return ((Cipher)object2).doFinal(string);
//return Bytes2HexString(((Cipher)object2).doFinal(string));
}
public static String jdkSHA1(String string) {
try {
MessageDigest messageDigest = MessageDigest.getInstance("SHA");
messageDigest.update(string.getBytes());
string = Bytes2HexString(messageDigest.digest());
return string;
}
catch (NoSuchAlgorithmException noSuchAlgorithmException) {
noSuchAlgorithmException.printStackTrace();
return null;
}
}
public static Map<String, Object> disposeX(String paramString1, String paramString2) { String str2;
String str3 = Bytes2HexString(Base64.decode(paramString1.getBytes(), 0));
paramString1 = str3.substring(str3.length() - 20);
str3 = str3.substring(0, str3.length() - 20);
StringBuilder stringBuilder2 = new StringBuilder();
stringBuilder2.append(str2HexStr(paramString2));
stringBuilder2.append(str3);
if (!paramString1.equals(jdkSHA2(stringBuilder2.toString()).substring(0, 20))) {
System.out.println("Assinatura Incorreta");
return null;
}
paramString1 = "";
try {
str3 = Decrypt1(str3, paramString2.substring(0, 16));
paramString1 = str3;
} catch (Exception exception) {
exception.printStackTrace();
}
str3 = paramString1.substring(0, 32);
String str5 = paramString1.substring(32, 96);
String str4 = paramString1.substring(96, 160);
paramString1 = paramString1.substring(160, 176);
String str6 = hexStr2Str(str3).trim();
String str7 = hexStr2Str(paramString1).trim();
StringBuilder stringBuilder1 = new StringBuilder();
stringBuilder1.append(str6);
stringBuilder1.append(paramString2);
String str8 = jdkSHA1(stringBuilder1.toString());
String str1 = "";
str3 = "";
try {
paramString2 =Decrypt(str5, str8);
str1 = paramString2;
str4 = Decrypt(str4, str8);
str1 = paramString2;
paramString2 = str4;
} catch (Exception exception) {
exception.printStackTrace();
str2 = str3;
}
HashMap<Object, Object> hashMap = new HashMap<Object, Object>();
hashMap.put("lockSn", str6);
hashMap.put("lockType", str7);
hashMap.put("manufactureKey", str1);
hashMap.put("bindingKey", str2);
return (Map)hashMap;
}
public static String bytesToHexFun1(byte[] paramArrayOfbyte) {
char[] arrayOfChar = new char[paramArrayOfbyte.length * 2];
int i = paramArrayOfbyte.length;
byte b = 0;
int j = 0;
while (b < i) {
byte b1 = paramArrayOfbyte[b];
int m = b1;
if (b1 < 0)
m = b1 + 256;
int k = j + 1;
char[] arrayOfChar1 = new char[16];
arrayOfChar1 = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'];
arrayOfChar[j] = (char)arrayOfChar1[m / 16];
j = k + 1;
arrayOfChar[k] = (char)arrayOfChar1[m % 16];
b++;
}
return new String(arrayOfChar);
}
public static String bytesToHexFun2(byte[] paramArrayOfbyte) {
char[] arrayOfChar = new char[paramArrayOfbyte.length * 2];
int i = paramArrayOfbyte.length;
byte b = 0;
int j = 0;
while (b < i) {
byte b1 = paramArrayOfbyte[b];
int k = j + 1;
char[] arrayOfChar1 = new char[16];
arrayOfChar1 = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'];
arrayOfChar[j] = (char)arrayOfChar1[b1 >>> 4 & 0xF];
j = k + 1;
arrayOfChar[k] = (char)arrayOfChar1[b1 & 0xF];
b++;
}
return new String(arrayOfChar);
}
public static String hexStr2Str(String string) {
if (string != null && !string.equals("")) {
string = string.replace(" ", "");
byte[] byArray = new byte[string.length() / 2];
for (int i = 0; i < byArray.length; ++i) {
int n = i * 2;
try {
byArray[i] = (byte)(Integer.parseInt(string.substring(n, n + 2), 16) & 0xFF);
continue;
}
catch (Exception exception) {
exception.printStackTrace();
}
}
try {
String string2;
string = string2 = new String(byArray, "UTF-8");
}
catch (Exception exception) {
exception.printStackTrace();
}
return string;
}
return null;
}
public static String str2HexStr(String paramString) {
char[] arrayOfChar = "0123456789ABCDEF".toCharArray();
StringBuilder stringBuilder = new StringBuilder("");
byte[] arrayOfByte = paramString.getBytes();
for (byte b = 0; b < arrayOfByte.length; b++) {
stringBuilder.append(arrayOfChar[(arrayOfByte[b] & 0xF0) >> 4]);
stringBuilder.append(arrayOfChar[arrayOfByte[b] & 0xF]);
}
return stringBuilder.toString().trim();
}
public static byte[] toBytes(String paramString) {
byte b = 0;
if (paramString == null || paramString.trim().equals(""))
return new byte[0];
byte[] arrayOfByte = new byte[paramString.length() / 2];
while (b < paramString.length() / 2) {
int i = b * 2;
arrayOfByte[b] = (byte)(byte)Integer.parseInt(paramString.substring(i, i + 2), 16);
b++;
}
return arrayOfByte;
}
public static Map<String, Object> dispose(String paramString1, String paramString2) {
String str2;
String str3 = bytesToHexFun1(Base64.decode(paramString1.getBytes(), 0));
paramString1 = str3.substring(str3.length() - 20);
str3 = str3.substring(0, str3.length() - 20);
StringBuilder stringBuilder2 = new StringBuilder();
stringBuilder2.append(str2HexStr(paramString2));
stringBuilder2.append(str3);
if (!paramString1.equals(jdkSHA2(stringBuilder2.toString()).substring(0, 20))) {
System.out.println("");
return null;
}
paramString1 = "";
try {
str3 = Decrypt1(str3, paramString2.substring(0, 16));
paramString1 = str3;
} catch (Exception exception) {
exception.printStackTrace();
}
str3 = paramString1.substring(0, 32);
String str5 = paramString1.substring(32, 96);
String str4 = paramString1.substring(96, 160);
paramString1 = paramString1.substring(160, 176);
String str6 = hexStr2Str(str3).trim();
String str7 = hexStr2Str(paramString1).trim();
StringBuilder stringBuilder1 = new StringBuilder();
stringBuilder1.append(str6);
stringBuilder1.append(paramString2);
String str8 = jdkSHA1(stringBuilder1.toString());
String str1 = "";
str3 = "";
try {
paramString2 = Decrypt(str5, str8);
str1 = paramString2;
str4 = Decrypt(str4, str8);
str1 = paramString2;
paramString2 = str4;
} catch (Exception exception) {
exception.printStackTrace();
str2 = str3;
}
HashMap<Object, Object> hashMap = new HashMap<Object, Object>();
hashMap.put("lockSn", str6);
hashMap.put("lockType", str7);
hashMap.put("manufactureKey", str1);
hashMap.put("bindingKey", str2);
return (Map)hashMap;
}
public static String jdkSHA2(String paramString) {
try {
MessageDigest messageDigest = MessageDigest.getInstance("SHA");
messageDigest.update(toBytes(paramString));
return bytesToHexFun1(messageDigest.digest());
} catch (NoSuchAlgorithmException noSuchAlgorithmException) {
noSuchAlgorithmException.printStackTrace();
return null;
}
}