From 2a97456b4a18cf21e4b6fd3a70d522d3e28f37b0 Mon Sep 17 00:00:00 2001 From: Ali Younis Date: Wed, 4 Oct 2017 14:00:40 -0700 Subject: [PATCH] Fixed Andriod version --- .../app/src/main/java/iotcloud/CloudComm.java | 135 ++++++++++++----- .../app/src/main/java/iotcloud/Slot.java | 23 ++- .../app/src/main/java/iotcloud/Table.java | 138 ++++++++++++------ version2/src/Control/build.gradle | 2 +- .../gradle/wrapper/gradle-wrapper.properties | 4 +- 5 files changed, 216 insertions(+), 86 deletions(-) diff --git a/version2/src/Control/app/src/main/java/iotcloud/CloudComm.java b/version2/src/Control/app/src/main/java/iotcloud/CloudComm.java index 4f51e5c..aa0791f 100644 --- a/version2/src/Control/app/src/main/java/iotcloud/CloudComm.java +++ b/version2/src/Control/app/src/main/java/iotcloud/CloudComm.java @@ -13,6 +13,8 @@ import org.spongycastle.crypto.digests.SHA256Digest; 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 @@ -25,13 +27,13 @@ import android.content.*; 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; @@ -272,6 +274,9 @@ class CloudComm { initCrypt(); } + /** + * Inits the HMAC generator. + */ /** * Inits the HMAC generator. */ @@ -282,20 +287,17 @@ class CloudComm { } 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. */ @@ -467,6 +469,57 @@ class CloudComm { } } + + 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 @@ -484,11 +537,18 @@ class CloudComm { } 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()); @@ -640,10 +700,15 @@ class CloudComm { 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); @@ -653,7 +718,7 @@ class CloudComm { 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; @@ -670,7 +735,12 @@ class CloudComm { // 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); @@ -691,7 +761,8 @@ class CloudComm { timer.endTime(); - returnData = decryptCipher.doFinal(returnData); +// returnData = decryptCipher.doFinal(returnData); + returnData = stripIVAndDecryptSlot(returnData); // We are done with this socket socket.close(); @@ -708,15 +779,9 @@ class CloudComm { 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..."); } @@ -754,7 +819,9 @@ class CloudComm { 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(); @@ -778,7 +845,9 @@ class CloudComm { 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(); @@ -789,15 +858,9 @@ class CloudComm { // 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..."); } } diff --git a/version2/src/Control/app/src/main/java/iotcloud/Slot.java b/version2/src/Control/app/src/main/java/iotcloud/Slot.java index ab04359..153ef80 100644 --- a/version2/src/Control/app/src/main/java/iotcloud/Slot.java +++ b/version2/src/Control/app/src/main/java/iotcloud/Slot.java @@ -36,7 +36,9 @@ class Slot implements Liveness { /** 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; @@ -46,14 +48,15 @@ class Slot implements Liveness { 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() { @@ -112,7 +115,7 @@ class Slot implements Liveness { 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)); @@ -216,6 +219,14 @@ class Slot implements Liveness { 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() + ">"; } diff --git a/version2/src/Control/app/src/main/java/iotcloud/Table.java b/version2/src/Control/app/src/main/java/iotcloud/Table.java index 9629ddb..5d56fd9 100644 --- a/version2/src/Control/app/src/main/java/iotcloud/Table.java +++ b/version2/src/Control/app/src/main/java/iotcloud/Table.java @@ -45,6 +45,8 @@ final public class Table { 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 @@ -167,14 +169,34 @@ final public class Table { 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 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++; @@ -188,6 +210,8 @@ final public class Table { 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); @@ -221,7 +245,8 @@ final public class Table { 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); @@ -245,6 +270,9 @@ final public class Table { // Just pull the latest slots from the server Slot[] newslots = cloud.getSlots(sequenceNumber + 1); validateAndUpdate(newslots, true); + sendToServer(null); + updateLiveTransactionsAndStatus(); + } // public String toString() { @@ -382,6 +410,7 @@ final public class Table { } NewKey newKey = new NewKey(null, keyName, machineId); + if (sendToServer(newKey)) { // If successfully inserted return true; @@ -497,6 +526,10 @@ final public class Table { bufferResizeThreshold = resizeLower - 1 + random.nextInt(numberOfSlots - resizeLower); } + public long getLocalSequenceNumber() { + return localSequenceNumber; + } + boolean lastInsertedNewKey = false; @@ -690,9 +723,11 @@ final public class Table { } + 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) { @@ -707,7 +742,8 @@ final public class Table { } // 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 fillSlotsReturn = fillSlot(slot, false, newKey); @@ -901,7 +937,8 @@ final public class Table { 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 @@ -962,7 +999,8 @@ final public class Table { // 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 @@ -1115,6 +1153,8 @@ final public class Table { entry.encode(bbEncode); } + + localSequenceNumber++; return returnData; } @@ -1185,9 +1225,12 @@ final public class Table { * Returns false if a resize was needed */ private ThreeTuple fillSlot(Slot slot, boolean resize, NewKey newKeyEntry) { + + int newSize = 0; if (liveSlotCount > bufferResizeThreshold) { resize = true; //Resize is forced + } if (resize) { @@ -1216,6 +1259,7 @@ final public class Table { if (newKeyEntry != null) { newKeyEntry.setSlot(slot); if (slot.hasSpace(newKeyEntry)) { + slot.addEntry(newKeyEntry); inserted = true; } @@ -1444,6 +1488,7 @@ final public class Table { // Process each slots data for (Slot slot : newSlots) { processSlot(indexer, slot, acceptUpdatesToLocal, machineSet); + updateExpectedSize(); } @@ -1517,20 +1562,30 @@ final public class Table { } 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; } @@ -1568,6 +1623,7 @@ final public class Table { // 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(); } @@ -1691,11 +1747,11 @@ final public class Table { // 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); @@ -1828,11 +1884,11 @@ final public class Table { // 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); @@ -2285,36 +2341,36 @@ final public class Table { 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()); } } } @@ -2686,7 +2742,7 @@ final public class Table { 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); } } diff --git a/version2/src/Control/build.gradle b/version2/src/Control/build.gradle index f031279..9041ba8 100644 --- a/version2/src/Control/build.gradle +++ b/version2/src/Control/build.gradle @@ -5,7 +5,7 @@ buildscript { 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 diff --git a/version2/src/Control/gradle/wrapper/gradle-wrapper.properties b/version2/src/Control/gradle/wrapper/gradle-wrapper.properties index 32498eb..29d8f59 100644 --- a/version2/src/Control/gradle/wrapper/gradle-wrapper.properties +++ b/version2/src/Control/gradle/wrapper/gradle-wrapper.properties @@ -1,6 +1,6 @@ -#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 -- 2.34.1