/**
* Sets the public parameters to the ones given in string parameter
*
* @param params must be of the form g p l, where g, p, and l are the public parameters for DH key
* exchange
*/
public void setPubParams(String params) {
String[] parts = params.split(" ");
BigInteger g = new BigInteger(parts[0]);
BigInteger p = new BigInteger(parts[1]);
int l = Integer.parseInt(parts[2]);
KeyPair keyPair = getKeyPair(g, p, l);
this.pubKey = keyPair.getPublic();
this.privKey = keyPair.getPrivate();
ByteArrayOutputStream baos = null;
ObjectOutputStream oos = null;
try {
baos = new ByteArrayOutputStream();
oos = new ObjectOutputStream(baos);
oos.writeObject(pubKey);
byte[] pubKeyBytes = baos.toByteArray();
this.strPubKey = new Base64().encodeToString(pubKeyBytes);
oos.close();
baos.close();
} catch (Exception e) {
if (DEBUG) {
System.out.println("Not persisted");
e.printStackTrace();
}
}
}
/**
* Performs a handshake for key exchange between two people. This method must be called by both
* people to ensure that the agreement has been reached on both ends.
*
* @param otherKey the serialized string version of the public key for the other person. Must not
* be null.
*/
public void handShake(String otherKey) {
if (DEBUG) {
System.out.println("Performing handshake...");
}
try {
byte[] otherPubBytes = new Base64().decode(otherKey);
ByteArrayInputStream bais = new ByteArrayInputStream(otherPubBytes);
ObjectInputStream ois = new ObjectInputStream(bais);
KeyAgreement keyAgree = KeyAgreement.getInstance("DiffieHellman");
keyAgree.init(privKey);
Key otherPub = (Key) ois.readObject();
keyAgree.doPhase(otherPub, true);
msgKey = keyAgree.generateSecret("DESede");
cipher = Cipher.getInstance("DESede");
mac = Mac.getInstance("HmacSHA512");
if (DEBUG) {
System.out.println("Handshake completed");
}
} catch (Exception e) {
System.out.println("Could not complete handshake...");
System.out.println("Agreement not confirmed");
if (DEBUG) {
e.printStackTrace();
}
}
}
public void run() {
try {
ObjectInputStream ois = new ObjectInputStream(s.getInputStream());
ObjectOutputStream oos = new ObjectOutputStream(s.getOutputStream());
BigInteger bg = dhSpec.getG();
BigInteger bp = dhSpec.getP();
oos.writeObject(bg);
oos.writeObject(bp);
KeyPairGenerator kpg = KeyPairGenerator.getInstance("DH");
kpg.initialize(1024);
KeyPair kpa = (KeyPair) ois.readObject();
KeyAgreement dh = KeyAgreement.getInstance("DH");
KeyPair kp = kpg.generateKeyPair();
oos.writeObject(kp);
dh.init(kp.getPrivate());
Key pk = dh.doPhase(kpa.getPublic(), true);
MessageDigest sha256 = MessageDigest.getInstance("SHA-256");
byte[] rawbits = sha256.digest(dh.generateSecret());
Cipher c = Cipher.getInstance(CIPHER_MODE);
SecretKey key = new SecretKeySpec(rawbits, 0, 16, "AES");
byte ivbits[] = (byte[]) ois.readObject();
IvParameterSpec iv = new IvParameterSpec(ivbits);
c.init(Cipher.DECRYPT_MODE, key, iv);
Mac m = Mac.getInstance("HmacSHA1");
SecretKey mackey = new SecretKeySpec(rawbits, 16, 16, "HmacSHA1");
m.init(mackey);
byte ciphertext[], cleartext[], mac[];
try {
while (true) {
ciphertext = (byte[]) ois.readObject();
mac = (byte[]) ois.readObject();
if (Arrays.equals(mac, m.doFinal(ciphertext))) {
cleartext = c.update(ciphertext);
System.out.println(ct + " : " + new String(cleartext, "UTF-8"));
} else {
// System.exit(1);
System.out.println(ct + "error");
}
}
} catch (EOFException e) {
cleartext = c.doFinal();
System.out.println(ct + " : " + new String(cleartext, "UTF-8"));
System.out.println("[" + ct + "]");
} finally {
if (ois != null) ois.close();
if (oos != null) oos.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
public boolean shareAESkey() {
try {
Envelope message = null, e = null;
// Generate AES key
KeyGenerator keyGen = KeyGenerator.getInstance("AES");
AESkey = keyGen.generateKey();
keyGen = KeyGenerator.getInstance("HmacSHA1");
HMACkey = keyGen.generateKey();
byte[] keyBytes = AESkey.getEncoded();
byte[] hashBytes = HMACkey.getEncoded();
System.out.println("AES key generated");
System.out.println("HMAC key generated");
System.out.println("Begin Encryption...");
// Encrypt message w/ provided public key
Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
cipher.init(Cipher.ENCRYPT_MODE, pubKey);
byte[] cipherBytes = cipher.doFinal(keyBytes);
byte[] cipherBytes1 = cipher.doFinal(hashBytes);
System.out.println("Encryption Complete");
message = new Envelope("SKEY");
message.addObject(cipherBytes); // Add AESkey to message
message.addObject(cipherBytes1);
message.addObject(nonce);
nonce++;
byte[] messageBytes = Envelope.toByteArray(message);
output.writeObject(messageBytes);
byte[] inCipherBytes = (byte[]) input.readObject();
// Decrypt response
cipher = Cipher.getInstance("AES");
cipher.init(Cipher.DECRYPT_MODE, AESkey);
byte[] responseBytes = cipher.doFinal(inCipherBytes);
Envelope response = Envelope.getEnvelopefromBytes(responseBytes);
// If server indicates success, return the member list
if (response.getMessage().equals("OK")
&& (Integer) response.getObjContents().get(0) == nonce) {
return true;
} else {
return false;
}
} catch (Exception e) {
System.err.println("Error: " + e.getMessage());
e.printStackTrace(System.err);
return false;
}
}
public static byte[] decode(byte[] paramArrayOfByte1, byte[] paramArrayOfByte2) {
SecretKeySpec localSecretKeySpec = new SecretKeySpec(paramArrayOfByte2, "AES");
try {
Cipher localCipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
localCipher.init(Cipher.DECRYPT_MODE, localSecretKeySpec);
byte[] arrayOfByte = localCipher.doFinal(paramArrayOfByte1);
return arrayOfByte;
} catch (Exception localException) {
localException.printStackTrace();
}
return null;
}
private long addCertificateToKeychain(String alias, Certificate cert) {
byte[] certblob = null;
long returnValue = 0;
try {
certblob = cert.getEncoded();
returnValue = _addItemToKeychain(alias, true, certblob, null);
} catch (Exception e) {
e.printStackTrace();
}
return returnValue;
}
// decrypts string
public String decrypt(String toDecrypt) {
try {
// see the above comment for rant, replacing Encoder with Decoder... kthxbye
// note: "above comment" no longer exists
byte[] decoded = Base64.decode(toDecrypt);
// decrypt
byte[] bytes = decryptionCipher.doFinal(decoded);
return new String(bytes, "ASCII");
} catch (Exception e) {
System.out.println("Decryption Error: " + e);
e.printStackTrace();
}
return null;
}
/**
* Generates the private RSA key from the given information paramter. The info must be RSA private
* information and of the form "privMod privExp"
*
* @param info must be RSA private information and of the form "privMod privExp"
*/
public void genRSAPrivKey(String info) {
try {
String[] parts = info.split(" ");
BigInteger mod = new BigInteger(parts[0]);
BigInteger exp = new BigInteger(parts[1]);
KeySpec ks = (KeySpec) new RSAPrivateKeySpec(mod, exp);
KeyFactory kf = KeyFactory.getInstance("RSA");
privRSAKey = kf.generatePrivate(ks);
} catch (Exception e) {
if (DEBUG) {
System.out.println("Could not generate the RSA private key");
e.printStackTrace();
}
}
}
public static byte[] decode64(byte[] paramArrayOfByte) {
SecretKeySpec localSecretKeySpec = new SecretKeySpec(BaseSecretKey, "AES");
try {
// byte[] arrayOfByte1 = Base64.decodeBase64(paramArrayOfByte);
byte[] arrayOfByte1 = Base64.decode(paramArrayOfByte, Base64.DEFAULT);
Cipher localCipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
localCipher.init(Cipher.DECRYPT_MODE, localSecretKeySpec);
byte[] arrayOfByte2 = localCipher.doFinal(arrayOfByte1);
return arrayOfByte2;
} catch (Exception localException) {
localException.printStackTrace();
}
return null;
}
/**
* 对字符串加密
*
* @param source String 要加密的字符串
* @return byte[] 已加密的字节
*/
public byte[] encrypt(String source) {
try {
// Encode the string into bytes using utf-8
// byte[] utf8 = new sun.misc.BASE64Decoder().decodeBuffer(str);
// Encrypt
byte[] enc = ecipher.doFinal(source.getBytes());
// Encode bytes to base64 to get a string
// return new sun.misc.BASE64Encoder().encode(enc);
return enc;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
static void getBytes(String inPath) {
Scanner scan = new Scanner(inPath);
fileType = scan.next(); // save the file name for reconstruction later
filePath = inPath; // assign global var
file = new File(filePath); // new file to encrypt
Path path = Paths.get(filePath); // return the path for the file
try {
plainText = Files.readAllBytes(path); // attempts to read the bytes from path
}
// some sort of runtime error here, null size buffer error
catch (Exception e) {
e.printStackTrace();
} finally {
scan.close();
}
}
/**
* Encrypts the given msg and returns the ciphertext for the encryted message
*
* @param msg != null
* @return the encrypted message or null if encryption fails
*/
public String encryptMsg(String msg) {
try {
cipher.init(Cipher.ENCRYPT_MODE, msgKey);
mac.init(msgKey);
byte[] c1 = cipher.doFinal(msg.getBytes());
String c1Str = new Base64().encodeToString(c1);
byte[] m = mac.doFinal(c1);
String mStr = new Base64().encodeToString(m);
return (c1Str + "::::" + mStr).replace("\r\n", "_").replace("\r", "-").replace("\n", "~");
} catch (Exception e) {
System.out.println("Could not encrypt the message");
if (DEBUG) {
e.printStackTrace();
}
return null;
}
}
/**
* Constructs an RSA key pair and returns the public key or null if the key pair could not be
* generated
*
* @return the RSA public key generated from the construction of the key pair or null if the key
* pair could not be generated
*/
public Key getRSAPair() {
try {
SecureRandom random = new SecureRandom();
KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA");
generator.initialize(1024, random);
KeyPair pair = generator.generateKeyPair();
PublicKey pubKey = pair.getPublic();
PrivateKey privKey = pair.getPrivate();
privRSAKey = privKey;
pubRSAKey = pubKey;
return pubKey;
} catch (Exception e) {
if (DEBUG) {
System.out.println("Could not get the RSA pair");
e.printStackTrace();
}
return null;
}
}
/**
* Decrypts the given String and returns the decrypted message if the message is verified to come
* from the correct sender, or null otherwise
*
* @param encryptedMsg != null
* @param nonce must be the nonce sent to the sender to use in the encryption of the message
* @return the decrypted message or null if the message is not verified
*/
public String decryptMsgNonce(String encryptedMsg) {
try {
cipher.init(Cipher.DECRYPT_MODE, msgKey);
mac.init(msgKey);
encryptedMsg = encryptedMsg.replace("~", "\n").replace("-", "\r").replace("_", "\r\n");
String[] encMsgParts = encryptedMsg.split("::::");
String encMsg = encMsgParts[0];
String checkM = encMsgParts[1];
byte[] encBytes = new Base64().decode(encMsg);
byte[] message = cipher.doFinal(encBytes);
byte[] m = mac.doFinal(encBytes);
String mStr = new Base64().encodeToString(m);
if (mStr.equals(checkM)) {
String mess = new String(message);
String[] parts = mess.split(":::");
String msg = parts[0];
int n = Integer.parseInt(parts[1]);
if (nonceSet.contains(n)) {
nonceSet.remove(n);
return msg;
} else {
if (DEBUG) {
System.out.println("Nonces don't match...");
System.out.println("Expected: " + nonceSet.toString() + ", Actual: " + n);
}
return null;
}
} else {
if (DEBUG) {
System.out.println("MACs don't match...");
}
return null;
}
} catch (Exception e) {
System.out.println("Could not decrypt");
if (DEBUG) {
e.printStackTrace();
}
}
return null;
}
/**
* Decrypts the given encrypted message using reverse RSA, meaning that it uses the public key to
* decrypt, and returns the decrypte message or null if the message could not be decrypted
*
* @param encMsg != null and encrypted with either this object or a similar object that has the
* proper decryption parameters
* @return the string representation of the message that was decrypted or null if the message
* could not be decrypted
*/
public String decryptRSA(String encMsg) {
try {
encMsg = encMsg.replace("::", "\n").replace("~", "\r").replace("_", "\r\n");
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.DECRYPT_MODE, pubRSAKey);
String result = "";
for (int i = 0; i < encMsg.length() / 178; i++) {
String subMsg = encMsg.substring(i * 178, Math.min((i + 1) * 178, encMsg.length()));
byte[] msgBytes = cipher.doFinal(new Base64().decode(subMsg));
result += new String(msgBytes);
}
return result;
} catch (Exception e) {
System.out.println("Could not decrypt the message with RSA");
if (DEBUG) {
e.printStackTrace();
}
return null;
}
}
/**
* Creates a new MsgEncrypt object with the given parameters
*
* @param g != null, must satisfy DH key exchange
* @param p != null, must satisfy DH key exchange
* @param l must satisfy DH key exchange
*/
private MsgEncrypt(BigInteger g, BigInteger p, int l) {
KeyPair keyPair = getKeyPair(g, p, l);
this.pubKey = keyPair.getPublic();
this.privKey = keyPair.getPrivate();
ByteArrayOutputStream baos = null;
ObjectOutputStream oos = null;
try {
baos = new ByteArrayOutputStream();
oos = new ObjectOutputStream(baos);
oos.writeObject(pubKey);
byte[] pubKeyBytes = baos.toByteArray();
this.strPubKey = new Base64().encodeToString(pubKeyBytes);
oos.close();
baos.close();
} catch (Exception e) {
if (DEBUG) {
System.out.println("Not persisted");
e.printStackTrace();
}
}
}
/**
* Encrypts the given message using reverse RSA (encrypts with the private key) and returns the
* ciphertext of the message in String form or null if the message could not be encrypted
*
* @param msg != null
* @return ciphertext form of the message made from RSA encryption or null if the message could
* not be encrypted
*/
public String encryptRSA(String msg) {
try {
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.ENCRYPT_MODE, privRSAKey);
byte[] msgBytes = msg.getBytes();
String result = "";
for (int i = 0; i < (int) Math.ceil(msgBytes.length * 1.0 / 100); i++) {
byte[] c =
cipher.doFinal(
Arrays.copyOfRange(msgBytes, i * 100, Math.min((i + 1) * 100, msgBytes.length)));
result += new Base64().encodeToString(c);
}
return result.replace("\r\n", "_").replace("\r", "~").replace("\n", "::");
} catch (Exception e) {
System.out.println("Could not encrypt the message with RSA");
if (DEBUG) {
e.printStackTrace();
}
return null;
}
}
private CryptUtils(String passwd) {
try {
char[] chars = new char[passwd.length()];
for (int i = 0; i < chars.length; i++) chars[i] = passwd.charAt(i);
PBEKeySpec pbeKeySpec = new PBEKeySpec(chars);
SecretKeyFactory keyFac = SecretKeyFactory.getInstance("PBEWithMD5AndDES");
SecretKey pbeKey = keyFac.generateSecret(pbeKeySpec);
// Create PBE encode Cipher
encodeCipher = Cipher.getInstance("PBEWithMD5AndDES");
// Salt
byte[] salt = {
(byte) 0xc7, (byte) 0x73, (byte) 0x21, (byte) 0x8c,
(byte) 0x7e, (byte) 0xc8, (byte) 0xee, (byte) 0x99
};
// Iteration count
int count = 20;
// Create PBE parameter set
PBEParameterSpec encodePbeParamSpec = new PBEParameterSpec(salt, count);
// Initialize PBE encode Cipher with key and parameters
encodeCipher.init(Cipher.ENCRYPT_MODE, pbeKey, encodePbeParamSpec);
// Create PBE decode Cipher
decodeCipher = Cipher.getInstance("PBEWithMD5AndDES");
// Create PBE parameter set
PBEParameterSpec decodePbeParamSpec = new PBEParameterSpec(salt, count);
// Initialize PBE decode Cipher with key and parameters
decodeCipher.init(Cipher.DECRYPT_MODE, pbeKey, decodePbeParamSpec);
} catch (NoSuchPaddingException ex) {
} catch (Exception ex) {
ex.printStackTrace();
}
}
public Cifra(byte[] chave) {
try {
SecretKey key = new SecretKeySpec(chave, "AES");
// Initialization Vector para CBC
byte[] iv = {
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15,
0x16
};
IvParameterSpec ivSpec = new IvParameterSpec(iv);
encrypt = Cipher.getInstance("AES/CBC/PKCS5Padding");
encrypt.init(Cipher.ENCRYPT_MODE, key, ivSpec);
decrypt = Cipher.getInstance("AES/CBC/PKCS5Padding");
decrypt.init(Cipher.DECRYPT_MODE, key, ivSpec);
} catch (InvalidKeyException ex) {
Logger.getLogger(Cifra.class.getName()).log(Level.SEVERE, null, ex);
} catch (NoSuchAlgorithmException ex) {
Logger.getLogger(Cifra.class.getName()).log(Level.SEVERE, null, ex);
} catch (NoSuchPaddingException ex) {
Logger.getLogger(Cifra.class.getName()).log(Level.SEVERE, null, ex);
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* Decrypts the given String and returns the decrypted message if the message is verified to come
* from the correct sender, or null otherwise
*
* @param encryptedMsg != null
* @return the decrypted message or null if the message is not verified
*/
public String decryptMsg(String encryptedMsg) {
try {
cipher.init(Cipher.DECRYPT_MODE, msgKey);
mac.init(msgKey);
encryptedMsg = encryptedMsg.replace("~", "\n").replace("-", "\r").replace("_", "\r\n");
String[] encMsgParts = encryptedMsg.split("::::");
String encMsg = encMsgParts[0];
String checkM = encMsgParts[1];
byte[] encBytes = new Base64().decode(encMsg);
byte[] message = cipher.doFinal(encBytes);
byte[] m = mac.doFinal(encBytes);
String mStr = new Base64().encodeToString(m);
if (mStr.equals(checkM)) return new String(message);
if (DEBUG) {
System.out.println("MACs don't match...");
}
} catch (Exception e) {
System.out.println("Could not decrypt");
if (DEBUG) {
e.printStackTrace();
}
}
return null;
}
public EncryDes() {
try {
// Create the key，"hshundsun2008"为随即初始化密文
String passPhrase = "hshundsun2008";
/* 生成秘钥 */
KeySpec keySpec = new DESKeySpec(passPhrase.getBytes());
SecretKey key = SecretKeyFactory.getInstance("DES").generateSecret(keySpec);
// SecretKeySpec key = new
// SecretKeySpec(passPhrase.getBytes(),"DES");
/* 初始化加解密实例 */
ecipher = Cipher.getInstance(key.getAlgorithm());
dcipher = Cipher.getInstance(key.getAlgorithm());
// Prepare the parameter to the ciphers
// AlgorithmParameterSpec paramSpec = new PBEParameterSpec(salt,
// iterationCount);
// Create the ciphers
ecipher.init(Cipher.ENCRYPT_MODE, key);
dcipher.init(Cipher.DECRYPT_MODE, key);
} catch (Exception e) {
e.printStackTrace();
}
}
public boolean upload(
String sourceFile, String destFile, String group, UserToken token, Key key, int keyNum) {
if (destFile.charAt(0) != '/') {
destFile = "/" + destFile;
}
try {
FileInputStream fis = new FileInputStream(sourceFile);
File encryptFile = new File(sourceFile + "_encrypt");
encryptFile.createNewFile();
FileOutputStream fos = new FileOutputStream(encryptFile);
// Initial Vector must be 16 bytes
byte[] initialVector = {
0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf
};
IvParameterSpec ivs = new IvParameterSpec(initialVector);
byte[] buf = new byte[1024];
Cipher cipher = Cipher.getInstance("AES/CBC/NoPadding");
cipher.init(Cipher.ENCRYPT_MODE, key, ivs);
byte[] cipherBytes;
// create a new local encrypted file
do {
buf = new byte[1024];
int n = fis.read(buf);
if (n > 0) {
System.out.printf(".");
} else if (n < 0) {
System.out.println("Read error");
}
cipherBytes = cipher.doFinal(buf);
fos.write(cipherBytes);
} while (fis.available() > 0);
System.out.println();
// send encrypted file to server
Envelope message = null, env = null;
// Tell the server to return the member list
message = new Envelope("UPLOADF");
message.addObject(destFile);
message.addObject(group);
message.addObject(token);
message.addObject(keyNum);
message.addObject(initialVector);
String concat =
destFile
+ group
+ token.toString()
+ keyNum
+ "UPLOADF"
+ nonce; // concatinates all of the objects in envelope
byte[] hasharray = concat.getBytes(); // turn the concat into a byte array
Mac mac = Mac.getInstance("HmacSHA1");
mac.init(HMACkey);
mac.update(hasharray);
String stringhash =
new String(mac.doFinal(), "UTF8"); // turn the hash into a string for easy comparision!
message.addObject(stringhash);
message.addObject(nonce);
nonce++;
byte[] messageBytes = Envelope.toByteArray(message);
// Encrypt envelope w/ AES
cipher = Cipher.getInstance("AES");
cipher.init(Cipher.ENCRYPT_MODE, AESkey);
cipherBytes = cipher.doFinal(messageBytes);
output.writeObject(cipherBytes);
byte[] responseCipherBytes =
(byte[])
input.readObject(); // if response isnt ready it should check whether it was forged
// Decrypt response
cipher = Cipher.getInstance("AES");
cipher.init(Cipher.DECRYPT_MODE, AESkey);
byte[] responseBytes = cipher.doFinal(responseCipherBytes);
env = Envelope.getEnvelopefromBytes(responseBytes);
if (env.getMessage().equals("READY")) {
System.out.printf("Meta data upload successful\n");
} else if ((Integer) env.getObjContents().get(1) == nonce) {
String hash = (String) env.getObjContents().get(0);
concat = env.getMessage() + nonce; // reconstructs the hash
hasharray = concat.getBytes();
mac = Mac.getInstance("HmacSHA1");
File HASHfile = new File("FHASHKey.bin");
fis = new FileInputStream(HASHfile);
ObjectInputStream ois = new ObjectInputStream(fis);
Key HMACkey = (Key) ois.readObject();
mac.init(HMACkey);
mac.update(hasharray);
String newhash = new String(mac.doFinal(), "UTF8");
nonce++;
// check hashes for equality
if (hash.equals(newhash) != true) {
System.out.println("HASH EQUALITY FAIL2, disconnecting for your own safety");
disconnect();
return false;
}
} else {
System.out.println("Nonce FAIL UPLOADF");
disconnect();
return false;
}
// If server indicates success, return the member list
FileInputStream encryptFIS = new FileInputStream(encryptFile);
do {
if ((Integer) env.getObjContents().get(1) == nonce) {
buf = new byte[1024];
if (!env.getMessage().equals("READY")) {
System.out.printf("Server error: %s\n", env.getMessage());
return false;
}
String hash = (String) env.getObjContents().get(0);
concat = env.getMessage() + nonce; // reconstructs the hash
hasharray = concat.getBytes();
mac = Mac.getInstance("HmacSHA1");
File HASHfile = new File("FHASHKey.bin");
fis = new FileInputStream(HASHfile);
ObjectInputStream ois = new ObjectInputStream(fis);
Key HMACkey = (Key) ois.readObject();
mac.init(HMACkey);
mac.update(hasharray);
String newhash = new String(mac.doFinal(), "UTF8");
nonce++;
ois.close();
// check hashes for equality
if (hash.equals(newhash) != true) {
System.out.println("HASH EQUALITY FAIL3, disconnecting for your own safety");
disconnect();
return false;
}
message = new Envelope("CHUNK");
int n = encryptFIS.read(buf); // can throw an IOException
if (n > 0) {
System.out.printf(".");
} else if (n < 0) {
System.out.println("Read error");
return false;
}
message.addObject(buf);
message.addObject(new Integer(n));
concat = n + "CHUNK" + nonce; // concatinates all of the objects in envelope
hasharray = concat.getBytes(); // turn the concat into a byte array
mac = Mac.getInstance("HmacSHA1");
mac.init(HMACkey);
mac.update(hasharray);
stringhash =
new String(
mac.doFinal(), "UTF8"); // turn the hash into a string for easy comparision!
message.addObject(stringhash);
message.addObject(nonce);
nonce++;
messageBytes = Envelope.toByteArray(message);
// Encrypt envelope w/ AES
cipher = Cipher.getInstance("AES");
cipher.init(Cipher.ENCRYPT_MODE, AESkey);
cipherBytes = cipher.doFinal(messageBytes);
System.out.println("Concatsent" + concat);
output.writeObject(
cipherBytes); ///////////////////////////////////////////
// HERE/////////////////////////////////
responseCipherBytes = (byte[]) input.readObject();
// Decrypt response
cipher.init(Cipher.DECRYPT_MODE, AESkey);
responseBytes = cipher.doFinal(responseCipherBytes);
env = Envelope.getEnvelopefromBytes(responseBytes);
} else {
System.out.println("Nonce FAIL UPLOADF");
disconnect();
return false;
}
} while (encryptFIS.available() > 0);
encryptFIS.close();
// If server indicates success, return the member list
if (env.getMessage().compareTo("READY") == 0
&& (Integer) env.getObjContents().get(1) == nonce) {
nonce++;
message = new Envelope("EOF");
concat = "EOF" + nonce; // concatinates all of the objects in envelope
hasharray = concat.getBytes(); // turn the concat into a byte array
mac = Mac.getInstance("HmacSHA1");
mac.init(HMACkey);
mac.update(hasharray);
stringhash =
new String(mac.doFinal(), "UTF8"); // turn the hash into a string for easy comparision!
message.addObject(stringhash);
message.addObject(nonce);
System.out.println(nonce);
nonce++;
messageBytes = Envelope.toByteArray(message);
// Encrypt envelope w/ AES
cipher = Cipher.getInstance("AES");
cipher.init(Cipher.ENCRYPT_MODE, AESkey);
cipherBytes = cipher.doFinal(messageBytes);
output.writeObject(cipherBytes);
responseCipherBytes = (byte[]) input.readObject();
// Decrypt response
cipher.init(Cipher.DECRYPT_MODE, AESkey);
responseBytes = cipher.doFinal(responseCipherBytes);
env = Envelope.getEnvelopefromBytes(responseBytes);
if (env.getMessage().compareTo("OK") == 0
&& (Integer) env.getObjContents().get(1) == nonce) {
System.out.printf("\nFile data upload successful\n");
} else if ((Integer) env.getObjContents().get(1) != nonce) {
System.out.println("Nonce FAIL UPLOADF");
disconnect();
return false;
} else {
System.out.printf("\nUpload failed: %s\n", env.getMessage());
return false;
}
} else if ((Integer) env.getObjContents().get(1) != nonce) {
System.out.println("Nonce FAIL UPLOADF");
disconnect();
return false;
} else {
System.out.printf("Upload failed: %s\n", env.getMessage());
return false;
}
} catch (Exception e1) {
System.err.println("Error: " + e1.getMessage());
e1.printStackTrace(System.err);
return false;
}
return true;
}
@SuppressWarnings("unchecked")
public List<String> listFiles(UserToken token) {
try {
Envelope env = null, e = null;
// Tell the server to return the member list
env = new Envelope("LFILES");
env.addObject(token); // Add requester's token
String concat =
token.toString() + "LFILES" + nonce; // concatinates all of the objects in envelope
byte[] hasharray = concat.getBytes(); // turn the concat into a byte array
Mac mac = Mac.getInstance("HmacSHA1");
mac.init(HMACkey);
mac.update(hasharray);
String stringhash =
new String(mac.doFinal(), "UTF8"); // turn the hash into a string for easy comparision!
env.addObject(stringhash);
env.addObject(nonce);
nonce++;
byte[] envBytes = Envelope.toByteArray(env);
// Encrypt envelope w/ AES
Cipher cipher = Cipher.getInstance("AES");
cipher.init(Cipher.ENCRYPT_MODE, AESkey);
byte[] cipherBytes = cipher.doFinal(envBytes);
output.writeObject(cipherBytes);
byte[] responseCipherBytes = (byte[]) input.readObject();
// Decrypt response
cipher.init(Cipher.DECRYPT_MODE, AESkey);
byte[] responseBytes = cipher.doFinal(responseCipherBytes);
env = Envelope.getEnvelopefromBytes(responseBytes);
if (env.getMessage().equals("FAIL")) {
System.out.println("Error occured in ListFiles, disconnecting");
disconnect();
return null;
} else if ((Integer) env.getObjContents().get(2) == nonce) {
List<String> files = (List<String>) env.getObjContents().get(0);
String hash = (String) env.getObjContents().get(1);
concat = files.toString() + env.getMessage() + nonce; // reconstructs the hash
hasharray = concat.getBytes();
mac = Mac.getInstance("HmacSHA1");
File HASHfile = new File("FHASHKey.bin");
FileInputStream fis = new FileInputStream(HASHfile);
ObjectInputStream ois = new ObjectInputStream(fis);
Key HMACkey = (Key) ois.readObject();
mac.init(HMACkey);
mac.update(hasharray);
String newhash = new String(mac.doFinal(), "UTF8");
nonce++;
// check hashes for equality
if (hash.equals(newhash) != true) {
System.out.println("HASH EQUALITY FAIL");
disconnect();
} else {
// If server indicates success, return the member list
if (env.getMessage().equals("OK")) {
return files; // This cast creates compiler warnings. Sorry.
}
}
} else {
System.out.println("Nonce FAIL LFILES");
disconnect();
return null;
}
return null;
} catch (Exception e) {
System.err.println("Error: " + e.getMessage());
e.printStackTrace(System.err);
return null;
}
}
