import org.spongycastle.crypto.params.KeyParameter;
import org.spongycastle.crypto.PBEParametersGenerator;
import android.content.*;
+import java.nio.ByteBuffer;
+
/**
* This class provides a communication API to the webserver. It also
class CloudComm {
private static final int SALT_SIZE = 8;
private static final int TIMEOUT_MILLIS = 2000; // 100
+ public static final int IV_SIZE = 16;
/** Sets the size for the HMAC. */
static final int HMAC_SIZE = 32;
private String baseurl;
- private Cipher encryptCipher;
- private Cipher decryptCipher;
+ private SecretKeySpec key;
private Mac mac;
private String password;
private SecureRandom random;
initCrypt();
}
+ /**
+ * Inits the HMAC generator.
+ */
/**
* Inits the HMAC generator.
*/
}
try {
- SecretKeySpec key = initKey();
+ key = initKey();
password = null; // drop password
mac = Mac.getInstance("HmacSHA256");
mac.init(key);
- encryptCipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
- encryptCipher.init(Cipher.ENCRYPT_MODE, key);
- decryptCipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
- decryptCipher.init(Cipher.DECRYPT_MODE, key);
} catch (Exception e) {
e.printStackTrace();
throw new Error("Failed To Initialize Ciphers");
}
}
+
/*
* Builds the URL for the given request.
*/
}
}
+
+ private byte[] createIV(long machineId, long localSequenceNumber) {
+ ByteBuffer buffer = ByteBuffer.allocate(IV_SIZE);
+ buffer.putLong(machineId);
+ long localSequenceNumberShifted = localSequenceNumber << 16;
+ buffer.putLong(localSequenceNumberShifted);
+ return buffer.array();
+
+ }
+
+ private byte[] encryptSlotAndPrependIV(byte[] rawData, byte[] ivBytes) {
+ try {
+ IvParameterSpec ivSpec = new IvParameterSpec(ivBytes);
+ Cipher cipher = Cipher.getInstance("AES/CTR/PKCS5Padding");
+ cipher.init(Cipher.ENCRYPT_MODE, key, ivSpec);
+
+ byte[] encryptedBytes = cipher.doFinal(rawData);
+
+ byte[] bytes = new byte[encryptedBytes.length + IV_SIZE];
+ System.arraycopy(ivBytes, 0, bytes, 0, ivBytes.length);
+ System.arraycopy(encryptedBytes, 0, bytes, IV_SIZE, encryptedBytes.length);
+
+ return bytes;
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ throw new Error("Failed To Encrypt");
+ }
+ }
+
+
+ private byte[] stripIVAndDecryptSlot(byte[] rawData) {
+ try {
+ byte[] ivBytes = new byte[IV_SIZE];
+ byte[] encryptedBytes = new byte[rawData.length - IV_SIZE];
+ System.arraycopy(rawData, 0, ivBytes, 0, IV_SIZE);
+ System.arraycopy(rawData, IV_SIZE, encryptedBytes, 0 , encryptedBytes.length);
+
+ IvParameterSpec ivSpec = new IvParameterSpec(ivBytes);
+
+ Cipher cipher = Cipher.getInstance("AES/CTR/PKCS5Padding");
+ cipher.init(Cipher.DECRYPT_MODE, key, ivSpec);
+
+ return cipher.doFinal(encryptedBytes);
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ throw new Error("Failed To Decrypt");
+ }
+ }
+
/*
* API for putting a slot into the queue. Returns null on success.
* On failure, the server will send slots with newer sequence
}
initCrypt();
}
-
long sequencenumber = slot.getSequenceNumber();
- byte[] bytes = slot.encode(mac);
- bytes = encryptCipher.doFinal(bytes);
+ byte[] slotBytes = slot.encode(mac);
+ // slotBytes = encryptCipher.doFinal(slotBytes);
+
+ // byte[] iVBytes = slot.getSlotCryptIV();
+ // byte[] bytes = new byte[slotBytes.length + IV_SIZE];
+ // System.arraycopy(iVBytes, 0, bytes, 0, iVBytes.length);
+ // System.arraycopy(slotBytes, 0, bytes, IV_SIZE, slotBytes.length);
+
+
+ byte[] bytes = encryptSlotAndPrependIV(slotBytes, slot.getSlotCryptIV());
for (int i = 0; i < numberofslots; i++) {
- byte[] data = new byte[sizesofslots[i]];
- dis.readFully(data);
+ byte[] rawData = new byte[sizesofslots[i]];
+ dis.readFully(rawData);
+
- data = decryptCipher.doFinal(data);
+ // byte[] data = new byte[rawData.length - IV_SIZE];
+ // System.arraycopy(rawData, IV_SIZE, data, 0, data.length);
+
+
+ byte[] data = stripIVAndDecryptSlot(rawData);
slots[i] = Slot.decode(table, data, mac);
return slots;
}
- public byte[] sendLocalData(byte[] sendData, String host, int port) {
+ public byte[] sendLocalData(byte[] sendData, long localSequenceNumber, String host, int port) {
if (salt == null) {
return null;
// Encrypt the data for sending
// byte[] encryptedData = encryptCipher.doFinal(totalData);
- byte[] encryptedData = encryptCipher.doFinal(totalData);
+// byte[] encryptedData = encryptCipher.doFinal(totalData);
+
+ byte[] iv = createIV(table.getMachineId(), table.getLocalSequenceNumber());
+ byte[] encryptedData = encryptSlotAndPrependIV(totalData, iv);
+
+
// Open a TCP socket connection to a local device
Socket socket = new Socket(host, port);
timer.endTime();
- returnData = decryptCipher.doFinal(returnData);
+// returnData = decryptCipher.doFinal(returnData);
+ returnData = stripIVAndDecryptSlot(returnData);
// We are done with this socket
socket.close();
System.arraycopy(returnData, 0, returnData2, 0, returnData2.length);
return returnData2;
- } catch (SocketTimeoutException e) {
-
- } catch (BadPaddingException e) {
-
- } catch (IllegalBlockSizeException e) {
-
- } catch (UnknownHostException e) {
-
- } catch (IOException e) {
+ } catch (Exception e) {
+ e.printStackTrace();
+ // throw new Error("Local comms failure...");
}
timer.endTime();
// Decrypt the data
- readData = decryptCipher.doFinal(readData);
+// readData = decryptCipher.doFinal(readData);
+ readData = stripIVAndDecryptSlot(readData);
+
mac.update(readData, 0, readData.length - HMAC_SIZE);
byte[] genmac = mac.doFinal();
System.arraycopy(realmac, 0, totalData, sendData.length, realmac.length);
// Encrypt the data for sending
- byte[] encryptedData = encryptCipher.doFinal(totalData);
+// byte[] encryptedData = encryptCipher.doFinal(totalData);
+ byte[] iv = createIV(table.getMachineId(), table.getLocalSequenceNumber());
+ byte[] encryptedData = encryptSlotAndPrependIV(totalData, iv);
timer.startTime();
// close the socket
socket.close();
- } catch (SocketTimeoutException e) {
-
- } catch (BadPaddingException e) {
-
- } catch (IllegalBlockSizeException e) {
-
- } catch (UnknownHostException e) {
-
- } catch (IOException e) {
+ } catch (Exception e) {
+ e.printStackTrace();
+ // throw new Error("Local comms failure...");
}
}
/** Reference to Table */
private Table table;
- Slot(Table _table, long _seqnum, long _machineid, byte[] _prevhmac, byte[] _hmac) {
+ private long localSequenceNumber;
+
+ Slot(Table _table, long _seqnum, long _machineid, byte[] _prevhmac, byte[] _hmac, long _localSequenceNumber) {
seqnum = _seqnum;
machineid = _machineid;
prevhmac = _prevhmac;
seqnumlive = true;
freespace = SLOT_SIZE - getBaseSize();
table = _table;
+ localSequenceNumber = _localSequenceNumber;
}
- Slot(Table _table, long _seqnum, long _machineid, byte[] _prevhmac) {
- this(_table, _seqnum, _machineid, _prevhmac, null);
+ Slot(Table _table, long _seqnum, long _machineid, byte[] _prevhmac, long _localSequenceNumber) {
+ this(_table, _seqnum, _machineid, _prevhmac, null, _localSequenceNumber);
}
- Slot(Table _table, long _seqnum, long _machineid) {
- this(_table, _seqnum, _machineid, new byte[HMAC_SIZE], null);
+ Slot(Table _table, long _seqnum, long _machineid, long _localSequenceNumber) {
+ this(_table, _seqnum, _machineid, new byte[HMAC_SIZE], null, _localSequenceNumber);
}
byte[] getHMAC() {
long seqnum = bb.getLong();
long machineid = bb.getLong();
int numentries = bb.getInt();
- Slot slot = new Slot(table, seqnum, machineid, prevhmac, hmac);
+ Slot slot = new Slot(table, seqnum, machineid, prevhmac, hmac, -1);
for (int i = 0; i < numentries; i++) {
slot.addShallowEntry(Entry.decode(slot, bb));
return livecount > 0;
}
+ public byte[] getSlotCryptIV() {
+ ByteBuffer buffer = ByteBuffer.allocate(CloudComm.IV_SIZE);
+ buffer.putLong(machineid);
+ long localSequenceNumberShift = localSequenceNumber << 16;
+ buffer.putLong(localSequenceNumberShift);
+ return buffer.array();
+ }
+
public String toString() {
return "<" + getSequenceNumber() + ">";
}
private long oldestLiveSlotSequenceNumver = 0; // Smallest sequence number of the slot with a live entry
private long localMachineId = 0; // Machine ID of this client device
private long sequenceNumber = 0; // Largest sequence number a client has received
+ private long localSequenceNumber = 0;
+
// private int smallestTableStatusSeen = -1; // Smallest Table Status that was seen in the latest slots sent from the server
// private int largestTableStatusSeen = -1; // Largest Table Status that was seen in the latest slots sent from the server
private long localTransactionSequenceNumber = 0; // Local sequence number counter for transactions
int livec = 0;
int deadc = 0;
+
+ int casdasd = 0;
+
+ int liveslo = 0;
+
for (long i = o; i < (n + 1); i++) {
Slot s = buffer.getSlot(i);
+
+ if (s.isLive()) {
+ liveslo++;
+ }
+
Vector<Entry> entries = s.getEntries();
for (Entry e : entries) {
if (e.isLive()) {
int type = e.getType();
+
+
+ if (type == 6) {
+ RejectedMessage rej = (RejectedMessage)e;
+ casdasd++;
+
+ System.out.println(rej.getMachineID());
+ }
+
+
types[type] = types[type] + 1;
num++;
livec++;
System.out.println(i + " " + types[i]);
}
System.out.println("Live count: " + livec);
+ System.out.println("Live Slot count: " + liveslo);
+
System.out.println("Dead count: " + deadc);
System.out.println("Old: " + o);
System.out.println("New: " + n);
cloud.initSecurity();
// Create the first insertion into the block chain which is the table status
- Slot s = new Slot(this, 1, localMachineId);
+ Slot s = new Slot(this, 1, localMachineId, localSequenceNumber);
+ localSequenceNumber++;
TableStatus status = new TableStatus(s, numberOfSlots);
s.addEntry(status);
Slot[] array = cloud.putSlot(s, numberOfSlots);
// Just pull the latest slots from the server
Slot[] newslots = cloud.getSlots(sequenceNumber + 1);
validateAndUpdate(newslots, true);
+ sendToServer(null);
+ updateLiveTransactionsAndStatus();
+
}
// public String toString() {
}
NewKey newKey = new NewKey(null, keyName, machineId);
+
if (sendToServer(newKey)) {
// If successfully inserted
return true;
bufferResizeThreshold = resizeLower - 1 + random.nextInt(numberOfSlots - resizeLower);
}
+ public long getLocalSequenceNumber() {
+ return localSequenceNumber;
+ }
+
boolean lastInsertedNewKey = false;
}
+
try {
// While we have stuff that needs inserting into the block chain
while ((pendingTransactionQueue.size() > 0) || (pendingSendArbitrationRounds.size() > 0) || (newKey != null)) {
+
fromRetry = false;
if (hadPartialSendToServer) {
}
// Create the slot
- Slot slot = new Slot(this, sequenceNumber + 1, localMachineId, buffer.getSlot(sequenceNumber).getHMAC());
+ Slot slot = new Slot(this, sequenceNumber + 1, localMachineId, buffer.getSlot(sequenceNumber).getHMAC(), localSequenceNumber);
+ localSequenceNumber++;
// Try to fill the slot with data
ThreeTuple<Boolean, Integer, Boolean> fillSlotsReturn = fillSlot(slot, false, newKey);
bbEncode.putInt(0);
// Send by local
- byte[] returnData = cloud.sendLocalData(sendData, localCommunicationInformation.getFirst(), localCommunicationInformation.getSecond());
+ byte[] returnData = cloud.sendLocalData(sendData, localSequenceNumber, localCommunicationInformation.getFirst(), localCommunicationInformation.getSecond());
+ localSequenceNumber++;
if (returnData == null) {
// Could not contact server
// Send by local
- byte[] returnData = cloud.sendLocalData(sendData, localCommunicationInformation.getFirst(), localCommunicationInformation.getSecond());
+ byte[] returnData = cloud.sendLocalData(sendData, localSequenceNumber, localCommunicationInformation.getFirst(), localCommunicationInformation.getSecond());
+ localSequenceNumber++;
if (returnData == null) {
// Could not contact server
entry.encode(bbEncode);
}
+
+ localSequenceNumber++;
return returnData;
}
* Returns false if a resize was needed
*/
private ThreeTuple<Boolean, Integer, Boolean> fillSlot(Slot slot, boolean resize, NewKey newKeyEntry) {
+
+
int newSize = 0;
if (liveSlotCount > bufferResizeThreshold) {
resize = true; //Resize is forced
+
}
if (resize) {
if (newKeyEntry != null) {
newKeyEntry.setSlot(slot);
if (slot.hasSpace(newKeyEntry)) {
+
slot.addEntry(newKeyEntry);
inserted = true;
}
// Process each slots data
for (Slot slot : newSlots) {
processSlot(indexer, slot, acceptUpdatesToLocal, machineSet);
+
updateExpectedSize();
}
}
private void initExpectedSize(long firstSequenceNumber, long numberOfSlots) {
-
+ // if (didFindTableStatus) {
+ // return;
+ // }
long prevslots = firstSequenceNumber;
+
+
if (didFindTableStatus) {
-// expectedsize = (prevslots < ((long) numberOfSlots)) ? (int) prevslots : expectedsize;
+ // expectedsize = (prevslots < ((long) numberOfSlots)) ? (int) prevslots : expectedsize;
+ // System.out.println("Here2: " + expectedsize + " " + numberOfSlots + " " + prevslots);
+
} else {
expectedsize = (prevslots < ((long) numberOfSlots)) ? (int) prevslots : numberOfSlots;
+ // System.out.println("Here: " + expectedsize);
}
- didFindTableStatus = true;
+ // System.out.println(numberOfSlots);
+
+ didFindTableStatus = true;
currMaxSize = numberOfSlots;
}
private void updateExpectedSize() {
expectedsize++;
+
if (expectedsize > currMaxSize) {
expectedsize = currMaxSize;
}
// Change the number of local slots to the new size
numberOfSlots = (int)currMaxSize;
+
// Recalculate the resize threshold since the size of the local buffer has changed
setResizeThreshold();
}
// Create the abort
Abort newAbort = new Abort(null,
- transaction.getClientLocalSequenceNumber(),
- transaction.getSequenceNumber(),
- transaction.getMachineId(),
- transaction.getArbitrator(),
- localArbitrationSequenceNumber);
+ transaction.getClientLocalSequenceNumber(),
+ transaction.getSequenceNumber(),
+ transaction.getMachineId(),
+ transaction.getArbitrator(),
+ localArbitrationSequenceNumber);
localArbitrationSequenceNumber++;
generatedAborts.add(newAbort);
// Create the abort
Abort newAbort = new Abort(null,
- transaction.getClientLocalSequenceNumber(),
- -1,
- transaction.getMachineId(),
- transaction.getArbitrator(),
- localArbitrationSequenceNumber);
+ transaction.getClientLocalSequenceNumber(),
+ -1,
+ transaction.getMachineId(),
+ transaction.getArbitrator(),
+ localArbitrationSequenceNumber);
localArbitrationSequenceNumber++;
addAbortSet.add(newAbort);
for (Entry entry : slot.getEntries()) {
switch (entry.getType()) {
- case Entry.TypeCommitPart:
- processEntry((CommitPart)entry);
- break;
+ case Entry.TypeCommitPart:
+ processEntry((CommitPart)entry);
+ break;
- case Entry.TypeAbort:
- processEntry((Abort)entry);
- break;
+ case Entry.TypeAbort:
+ processEntry((Abort)entry);
+ break;
- case Entry.TypeTransactionPart:
- processEntry((TransactionPart)entry);
- break;
+ case Entry.TypeTransactionPart:
+ processEntry((TransactionPart)entry);
+ break;
- case Entry.TypeNewKey:
- processEntry((NewKey)entry);
- break;
+ case Entry.TypeNewKey:
+ processEntry((NewKey)entry);
+ break;
- case Entry.TypeLastMessage:
- processEntry((LastMessage)entry, machineSet);
- break;
+ case Entry.TypeLastMessage:
+ processEntry((LastMessage)entry, machineSet);
+ break;
- case Entry.TypeRejectedMessage:
- processEntry((RejectedMessage)entry, indexer);
- break;
+ case Entry.TypeRejectedMessage:
+ processEntry((RejectedMessage)entry, indexer);
+ break;
- case Entry.TypeTableStatus:
- processEntry((TableStatus)entry, slot.getSequenceNumber());
- break;
+ case Entry.TypeTableStatus:
+ processEntry((TableStatus)entry, slot.getSequenceNumber());
+ break;
- default:
- throw new Error("Unrecognized type: " + entry.getType());
+ default:
+ throw new Error("Unrecognized type: " + entry.getType());
}
}
}
Slot currSlot = newSlots[i];
Slot prevSlot = indexer.getSlot(currSlot.getSequenceNumber() - 1);
if (prevSlot != null &&
- !Arrays.equals(prevSlot.getHMAC(), currSlot.getPrevHMAC()))
+ !Arrays.equals(prevSlot.getHMAC(), currSlot.getPrevHMAC()))
throw new Error("Server Error: Invalid HMAC Chain" + currSlot + " " + prevSlot);
}
}
jcenter()
}
dependencies {
- classpath 'com.android.tools.build:gradle:2.4.0-alpha7'
+ classpath 'com.android.tools.build:gradle:3.0.0-beta7'
// NOTE: Do not place your application dependencies here; they belong
// in the individual module build.gradle files
-#Fri May 12 20:24:22 PDT 2017
+#Wed Oct 04 13:32:04 PDT 2017
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-3.4.1-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-4.1-all.zip
projects / iotcloud.git / commitdiff