271 lines
8.1 KiB
Java
271 lines
8.1 KiB
Java
package SecureDongle;
|
|
|
|
import lombok.Getter;
|
|
import lombok.Setter;
|
|
import org.tinylog.Logger;
|
|
import static Config.SomeCodes.ToShort;
|
|
import static Config.SomeCodes.Wait;
|
|
|
|
public class SecureDongle {
|
|
|
|
private final int[] lp1 = new int[1];
|
|
private final int[] lp2 = new int[1];
|
|
// for Open/Close Handle
|
|
private final short[] handle = new short[1];
|
|
// P1
|
|
private final short[] p1 = new short[1];
|
|
// P2
|
|
private final short[] p2 = new short[1];
|
|
// P3
|
|
private final short[] p3 = new short[1];
|
|
// P4
|
|
private final short[] p4 = new short[1];
|
|
|
|
private final byte[] buffer = new byte[1024];
|
|
|
|
LibSecureDongle SD;
|
|
|
|
private @Getter boolean Opened = false;
|
|
private @Getter short Handle;
|
|
private @Getter int HardwareID = 0;
|
|
private @Getter int UserID = 0;
|
|
|
|
private @Setter SecureDongleEvent event;
|
|
|
|
/**
|
|
* Create SecureDongle with P1, P2, P3, P4
|
|
* @param P1 Password 1
|
|
* @param P2 Password 2
|
|
* @param P3 Password 3
|
|
* @param P4 Password 4
|
|
*/
|
|
public SecureDongle(Short P1, Short P2, Short P3, Short P4){
|
|
this.p1[0] = P1;
|
|
this.p2[0] = P2;
|
|
this.p3[0] = P3;
|
|
this.p4[0] = P4;
|
|
SD = LibSecureDongle.Instance;
|
|
}
|
|
|
|
/**
|
|
* Create SecureDongle with P1, P2, P3, P4
|
|
* @param P1 Password 1
|
|
* @param P2 Password 2
|
|
* @param P3 Password 3
|
|
* @param P4 Password 4
|
|
*/
|
|
public SecureDongle(String P1, String P2, String P3, String P4){
|
|
this.p1[0] = ToShort(P1);
|
|
this.p2[0] = ToShort(P2);
|
|
this.p3[0] = ToShort(P3);
|
|
this.p4[0] = ToShort(P4);
|
|
SD = LibSecureDongle.Instance;
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
* Find SecureDongle
|
|
* This must be executed first time
|
|
* @return true if found
|
|
*/
|
|
public boolean Find(){
|
|
HardwareID = 0;
|
|
short result = SD.SecureDongle(LibSecureDongle.SD_FIND, handle, lp1, lp2, p1, p2, p3, p4, buffer);
|
|
|
|
if (result== LibSecureDongle.ERR_SUCCESS){
|
|
HardwareID = lp1[0];
|
|
return true;
|
|
} else {
|
|
if (event!=null) event.onDongleError("Find", result);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Open SecureDongle
|
|
* @return true if success
|
|
*/
|
|
public boolean Open(){
|
|
Handle=0;
|
|
if (HardwareID!=0){
|
|
lp1[0] = HardwareID;
|
|
short result = SD.SecureDongle(LibSecureDongle.SD_OPEN, handle, lp1, lp2, p1, p2, p3, p4, buffer);
|
|
if (result== LibSecureDongle.ERR_SUCCESS){
|
|
Handle = handle[0];
|
|
Opened = true;
|
|
return true;
|
|
} else if (event!=null) event.onDongleError("Open", result);
|
|
} //else System.out.println("HardwareID not found, Find SecureDongle first");
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Close SecureDongle
|
|
* @return true if success
|
|
*/
|
|
@SuppressWarnings("UnusedReturnValue")
|
|
public boolean Close(){
|
|
handle[0] = Handle;
|
|
short result = SD.SecureDongle(LibSecureDongle.SD_CLOSE, handle, lp1, lp2, p1, p2, p3, p4, buffer);
|
|
if (result== LibSecureDongle.ERR_SUCCESS){
|
|
return true;
|
|
} else if (event!=null) event.onDongleError("Close", result);
|
|
Opened = false;
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Write to User Data Zone (UDZ)
|
|
* @param StartAddress start address of UDZ, zero based
|
|
* @param length length of data to write, max 1000 bytes
|
|
* @param data data to write
|
|
* @return true if success
|
|
*/
|
|
@SuppressWarnings("unused")
|
|
public boolean Write(short StartAddress, short length, byte[] data){
|
|
if (Opened){
|
|
handle[0] = Handle;
|
|
p1[0] = StartAddress>=0 ? StartAddress : 0;
|
|
if (length<1) length=1;
|
|
if (length>1000) length=1000;
|
|
p2[0] = length;
|
|
System.arraycopy(data, 0, buffer, 0, length);
|
|
short result = SD.SecureDongle(LibSecureDongle.SD_WRITE, handle, lp1, lp2, p1, p2, p3, p4, buffer);
|
|
if (result== LibSecureDongle.ERR_SUCCESS){
|
|
return true;
|
|
} else if (event!=null) event.onDongleError("Write", result);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
/**
|
|
* Read from User Data Zone (UDZ)
|
|
* @param StartAddress Start Address, zero based
|
|
* @param Length Length of data to read, max 1000 bytes
|
|
* @return byte array of data, length=0 if failed
|
|
*/
|
|
@SuppressWarnings("unused")
|
|
public byte[] Read(short StartAddress, short Length){
|
|
if (Opened){
|
|
handle[0] = Handle;
|
|
p1[0] = StartAddress>=0 ? StartAddress : 0;
|
|
if (Length<1) Length=1;
|
|
if (Length>1000) Length=1000;
|
|
p2[0] = Length;
|
|
short result = SD.SecureDongle(LibSecureDongle.SD_READ, handle, lp1, lp2, p1, p2, p3, p4, buffer);
|
|
if (result== LibSecureDongle.ERR_SUCCESS){
|
|
byte[] data = new byte[Length];
|
|
System.arraycopy(buffer, 0, data, 0, Length);
|
|
return data;
|
|
} else if (event!=null) event.onDongleError("Read", result);
|
|
}
|
|
|
|
return new byte[0];
|
|
}
|
|
|
|
/**
|
|
* Generate Random Number
|
|
* @return short array of random number
|
|
*/
|
|
@SuppressWarnings("unused")
|
|
public short[] GenerateRandomNumber(){
|
|
short[] random = new short[4];
|
|
if (Opened){
|
|
handle[0] = Handle;
|
|
short result = SD.SecureDongle(LibSecureDongle.SD_RANDOM, handle, lp1, lp2, p1, p2, p3, p4, buffer);
|
|
if (result== LibSecureDongle.ERR_SUCCESS){
|
|
random[0] = p1[0];
|
|
random[1] = p2[0];
|
|
random[2] = p3[0];
|
|
random[3] = p4[0];
|
|
return random;
|
|
} else if (event!=null) event.onDongleError("GenerateRandomNumber", result);
|
|
}
|
|
|
|
return random;
|
|
}
|
|
|
|
/**
|
|
* Write UserID to SecureDongle
|
|
* @param UserID UserID to write
|
|
* @return true if success
|
|
*/
|
|
@SuppressWarnings("unused")
|
|
public boolean WriteUserID(int UserID){
|
|
if (Opened){
|
|
handle[0] = Handle;
|
|
lp1[0] = UserID;
|
|
short result = SD.SecureDongle(LibSecureDongle.SD_WRITE_USERID, handle, lp1, lp2, p1, p2, p3, p4, buffer);
|
|
if (result== LibSecureDongle.ERR_SUCCESS){
|
|
this.UserID = UserID;
|
|
return true;
|
|
} else if (event!=null) event.onDongleError("WriteUserID", result);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Read UserID from SecureDongle
|
|
* @return UserID, 0 if failed
|
|
*/
|
|
public int ReadUserID(){
|
|
if (Opened){
|
|
handle[0] = Handle;
|
|
short result = SD.SecureDongle(LibSecureDongle.SD_READ_USERID, handle, lp1, lp2, p1, p2, p3, p4, buffer);
|
|
if (result== LibSecureDongle.ERR_SUCCESS){
|
|
this.UserID = lp1[0];
|
|
return UserID;
|
|
} else if (event!=null) event.onDongleError("ReadUserID", result);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
boolean ismonitoring = false;
|
|
|
|
/**
|
|
* Stop Monitoring SecureDongle
|
|
*/
|
|
public void StopMonitor(){
|
|
ismonitoring = false;
|
|
}
|
|
|
|
/**
|
|
* Start Monitoring SecureDongle
|
|
* if dongle missing, will raise event onDongleMissing
|
|
*/
|
|
public void StartMonitor(){
|
|
Thread tx = new Thread(()->{
|
|
if (HardwareID==0) Find();
|
|
Open();
|
|
int firstUserID = ReadUserID();
|
|
Close();
|
|
if (firstUserID!=0){
|
|
ismonitoring = true;
|
|
Logger.info("Start Monitoring UserID="+Integer.toHexString(firstUserID));
|
|
while (ismonitoring){
|
|
Wait(5000);
|
|
Open();
|
|
int newUserID = ReadUserID();
|
|
Close();
|
|
if (newUserID!=firstUserID){
|
|
if (event!=null) event.onDongleMissing();
|
|
}
|
|
|
|
}
|
|
System.out.println("Stop Monitoring");
|
|
} else System.out.println("Canceled Monitoring, UserID not found");
|
|
|
|
});
|
|
tx.setName("SecureDongle Monitor Thread");
|
|
tx.setDaemon(true);
|
|
tx.start();
|
|
}
|
|
|
|
}
|