me/no-java
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

formatting

Browse Source
This commit is contained in:
Dave
2015-06-27 21:50:28 +02:00
parent 7bb6c6fdfa
commit 34b9a748f9
36 changed files with 2381 additions and 2360 deletions
Download Patch File Download Diff File Expand all files Collapse all files

70
src/nodash/core/NoConfigBase.java
View File

@@ -9,46 +9,46 @@ import javax.crypto.SecretKey;
import nodash.exceptions.NoDashFatalException; import nodash.exceptions.NoDashFatalException;
public abstract class NoConfigBase implements NoConfigInterface { public abstract class NoConfigBase implements NoConfigInterface {
protected boolean ready; protected boolean ready;
protected SecretKey secretKey; protected SecretKey secretKey;
protected boolean saveDatabase; protected boolean saveDatabase;
protected boolean saveByteSets; protected boolean saveByteSets;
protected final void generateSecretKey() {
try {
KeyGenerator keyGenerator = KeyGenerator.getInstance(NoUtil.CIPHER_KEY_SPEC);
keyGenerator.init(NoUtil.AES_STRENGTH);
this.secretKey = keyGenerator.generateKey();
} catch (NoSuchAlgorithmException e) {
throw new NoDashFatalException("Value for CIPHER_KEY_SPEC not valid.", e);
}
}
@Override protected final void generateSecretKey() {
public void construct() { try {
this.generateSecretKey(); KeyGenerator keyGenerator = KeyGenerator.getInstance(NoUtil.CIPHER_KEY_SPEC);
this.ready = true; keyGenerator.init(NoUtil.AES_STRENGTH);
} this.secretKey = keyGenerator.generateKey();
} catch (NoSuchAlgorithmException e) {
throw new NoDashFatalException("Value for CIPHER_KEY_SPEC not valid.", e);
}
}
@Override @Override
public SecretKey getSecretKey() { public void construct() {
return this.secretKey; this.generateSecretKey();
} this.ready = true;
}
@Override @Override
public boolean saveDatabase() { public SecretKey getSecretKey() {
return this.saveDatabase; return this.secretKey;
} }
@Override @Override
public boolean saveByteSets() { public boolean saveDatabase() {
return this.saveByteSets; return this.saveDatabase;
} }
@Override @Override
public abstract void saveNoConfig(); public boolean saveByteSets() {
return this.saveByteSets;
}
@Override @Override
public abstract NoConfigInterface loadNoConfig() throws IOException; public abstract void saveNoConfig();
@Override
public abstract NoConfigInterface loadNoConfig() throws IOException;
} }

124
src/nodash/core/NoConfigDefault.java
View File

@@ -1,20 +1,17 @@
/* /*
* Copyright 2014 David Horscroft * Copyright 2014 David Horscroft
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* *
* The NoConfig is a means to store the server secret key, database address * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* and other configs. * in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*
* The NoConfig is a means to store the server secret key, database address and other configs.
*/ */
package nodash.core; package nodash.core;
@@ -32,59 +29,60 @@ import java.nio.file.StandardOpenOption;
import nodash.exceptions.NoDashFatalException; import nodash.exceptions.NoDashFatalException;
public final class NoConfigDefault extends NoConfigBase implements Serializable { public final class NoConfigDefault extends NoConfigBase implements Serializable {
private static final long serialVersionUID = -8498303909736017075L; private static final long serialVersionUID = -8498303909736017075L;
private static final String CONFIG_FILENAME = "noconfig.cfg"; private static final String CONFIG_FILENAME = "noconfig.cfg";
private String databaseFileName = "nodatabase.hash";
@Override private String databaseFileName = "nodatabase.hash";
public boolean saveDatabase() {
return saveDatabase;
}
public String getDatabaseName() {
return databaseFileName;
}
@Override @Override
public boolean saveByteSets() { public boolean saveDatabase() {
return saveByteSets; return saveDatabase;
} }
@Override public String getDatabaseName() {
public void saveNoConfig() { return databaseFileName;
try { }
File file = new File(NoConfigDefault.CONFIG_FILENAME);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(this);
byte[] data = baos.toByteArray();
Files.write(file.toPath(), data, StandardOpenOption.CREATE_NEW);
} catch (IOException e) {
throw new NoDashFatalException("Unable to save config, including generated secret key.", e);
}
}
@Override @Override
public NoConfigInterface loadNoConfig() throws IOException { public boolean saveByteSets() {
File file = new File(NoConfigDefault.CONFIG_FILENAME); return saveByteSets;
byte[] data = Files.readAllBytes(file.toPath()); }
ByteArrayInputStream bais = new ByteArrayInputStream(data);
ObjectInputStream ois = new ObjectInputStream(bais);
NoConfigInterface noConfig;
try {
noConfig = (NoConfigDefault) ois.readObject();
} catch (ClassNotFoundException e) {
throw new NoDashFatalException("Given bytestream does not compile into a configuration object.", e);
}
this.ready = true;
return noConfig;
}
@Override @Override
public boolean isReady() { public void saveNoConfig() {
return this.ready; try {
} File file = new File(NoConfigDefault.CONFIG_FILENAME);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(this);
byte[] data = baos.toByteArray();
Files.write(file.toPath(), data, StandardOpenOption.CREATE_NEW);
} catch (IOException e) {
throw new NoDashFatalException("Unable to save config, including generated secret key.", e);
}
}
@Override
public NoConfigInterface loadNoConfig() throws IOException {
File file = new File(NoConfigDefault.CONFIG_FILENAME);
byte[] data = Files.readAllBytes(file.toPath());
ByteArrayInputStream bais = new ByteArrayInputStream(data);
ObjectInputStream ois = new ObjectInputStream(bais);
NoConfigInterface noConfig;
try {
noConfig = (NoConfigDefault) ois.readObject();
} catch (ClassNotFoundException e) {
throw new NoDashFatalException(
"Given bytestream does not compile into a configuration object.", e);
}
this.ready = true;
return noConfig;
}
@Override
public boolean isReady() {
return this.ready;
}
} }

20
src/nodash/core/NoConfigInterface.java
View File

@@ -5,11 +5,17 @@ import java.io.IOException;
import javax.crypto.SecretKey; import javax.crypto.SecretKey;
public interface NoConfigInterface { public interface NoConfigInterface {
public void construct(); public void construct();
public SecretKey getSecretKey();
public boolean saveDatabase(); public SecretKey getSecretKey();
public boolean saveByteSets();
public void saveNoConfig(); public boolean saveDatabase();
public NoConfigInterface loadNoConfig() throws IOException;
public boolean isReady(); public boolean saveByteSets();
public void saveNoConfig();
public NoConfigInterface loadNoConfig() throws IOException;
public boolean isReady();
} }

195
src/nodash/core/NoCore.java
View File

@@ -1,20 +1,18 @@
/* /*
* Copyright 2014 David Horscroft * Copyright 2014 David Horscroft
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* *
* The NoCore class is the interface between which the wrapper application * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* (wrapplication?) accesses no- functionality. * in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*
* The NoCore class is the interface between which the wrapper application (wrapplication?) accesses
* no- functionality.
*/ */
package nodash.core; package nodash.core;
@@ -39,83 +37,94 @@ import nodash.models.NoUser;
import nodash.models.NoSession.NoState; import nodash.models.NoSession.NoState;
public final class NoCore { public final class NoCore {
public static NoConfigInterface config; public static NoConfigInterface config;
public static NoHashSphereInterface hashSphere; public static NoHashSphereInterface hashSphere;
public static boolean isReady() {
return (config != null && config.isReady()) &&
(hashSphere != null && hashSphere.isReady());
}
public static void setup(NoConfigInterface config, NoHashSphereInterface hashSphere) {
NoCore.setup(config);
NoCore.setup(hashSphere);
}
public static void setup(NoConfigInterface config) {
NoCore.config = config;
}
public static void setup(NoHashSphereInterface hashSphere) {
NoCore.hashSphere = hashSphere;
hashSphere.setup();
}
public static void setup() {
NoConfigInterface newConfig = new NoConfigDefault();
try {
newConfig = newConfig.loadNoConfig();
} catch (IOException e) {
newConfig.construct();
}
NoCore.setup(newConfig);
NoCore.setup(new NoHashSphereDefault());
}
public static byte[] login(byte[] data, char[] password) throws NoUserNotValidException, NoUserAlreadyOnlineException, NoSessionExpiredException {
/* steps 1 through to pre-3 */
return NoSessionSphere.login(data, password);
}
public static NoRegister register(NoUser user, char[] password) {
/* Straight to step 4 */
return NoSessionSphere.registerUser(user, password);
}
public static NoUser getUser(byte[] cookie) throws NoSessionExpiredException, NoSessionConfirmedException, NoDashSessionBadUUIDException {
/* Facilitates step 3
* allow website-side modifications to the NoUser or NoUser inheritant */
return NoSessionSphere.getUser(cookie);
}
public static NoState getSessionState(byte[] cookie) throws NoSessionExpiredException, NoSessionConfirmedException, NoDashSessionBadUUIDException {
/* Facilitates step 3
* allow front-side to keep track of session state */
return NoSessionSphere.getState(cookie);
}
public static byte[] requestSave(byte[] cookie, char[] password) throws NoSessionExpiredException, NoSessionConfirmedException, NoSessionNotChangedException, NoSessionAlreadyAwaitingConfirmationException, NoDashSessionBadUUIDException {
/* Step 4. Provides a user with the new binary file */
return NoSessionSphere.save(cookie, password);
}
public static void confirm(byte[] cookie, char[] password, byte[] data) throws NoSessionExpiredException, NoSessionConfirmedException, NoSessionNotAwaitingConfirmationException, NoUserNotValidException, NoDashSessionBadUUIDException {
/* Step 5. Assumes the user has re-uploaded the file along with providing the same password.
* Further attempts of getUser or getSessionState will fail with a NoSessionExpiredException*/
NoSessionSphere.confirm(cookie, password, data);
}
public static void addByteSet(NoByteSet byteSet, PublicKey publicKey) { public static boolean isReady() {
NoByteSetSphere.add(byteSet, publicKey); return (config != null && config.isReady()) && (hashSphere != null && hashSphere.isReady());
} }
public static void shred(byte[] cookie) { public static void setup(NoConfigInterface config, NoHashSphereInterface hashSphere) {
/* 3.2 Hot pull */ NoCore.setup(config);
NoSessionSphere.shred(cookie); NoCore.setup(hashSphere);
} }
public static void triggerPrune() { public static void setup(NoConfigInterface config) {
NoSessionSphere.prune(); NoCore.config = config;
} }
} public static void setup(NoHashSphereInterface hashSphere) {
NoCore.hashSphere = hashSphere;
hashSphere.setup();
}
public static void setup() {
NoConfigInterface newConfig = new NoConfigDefault();
try {
newConfig = newConfig.loadNoConfig();
} catch (IOException e) {
newConfig.construct();
}
NoCore.setup(newConfig);
NoCore.setup(new NoHashSphereDefault());
}
public static byte[] login(byte[] data, char[] password) throws NoUserNotValidException,
NoUserAlreadyOnlineException, NoSessionExpiredException {
/* steps 1 through to pre-3 */
return NoSessionSphere.login(data, password);
}
public static NoRegister register(NoUser user, char[] password) {
/* Straight to step 4 */
return NoSessionSphere.registerUser(user, password);
}
public static NoUser getUser(byte[] cookie) throws NoSessionExpiredException,
NoSessionConfirmedException, NoDashSessionBadUUIDException {
/*
* Facilitates step 3 allow website-side modifications to the NoUser or NoUser inheritant
*/
return NoSessionSphere.getUser(cookie);
}
public static NoState getSessionState(byte[] cookie) throws NoSessionExpiredException,
NoSessionConfirmedException, NoDashSessionBadUUIDException {
/*
* Facilitates step 3 allow front-side to keep track of session state
*/
return NoSessionSphere.getState(cookie);
}
public static byte[] requestSave(byte[] cookie, char[] password)
throws NoSessionExpiredException, NoSessionConfirmedException, NoSessionNotChangedException,
NoSessionAlreadyAwaitingConfirmationException, NoDashSessionBadUUIDException {
/* Step 4. Provides a user with the new binary file */
return NoSessionSphere.save(cookie, password);
}
public static void confirm(byte[] cookie, char[] password, byte[] data)
throws NoSessionExpiredException, NoSessionConfirmedException,
NoSessionNotAwaitingConfirmationException, NoUserNotValidException,
NoDashSessionBadUUIDException {
/*
* Step 5. Assumes the user has re-uploaded the file along with providing the same password.
* Further attempts of getUser or getSessionState will fail with a NoSessionExpiredException
*/
NoSessionSphere.confirm(cookie, password, data);
}
public static void addByteSet(NoByteSet byteSet, PublicKey publicKey) {
NoByteSetSphere.add(byteSet, publicKey);
}
public static void shred(byte[] cookie) {
/* 3.2 Hot pull */
NoSessionSphere.shred(cookie);
}
public static void triggerPrune() {
NoSessionSphere.prune();
}
}

32
src/nodash/core/NoRegister.java
View File

@@ -1,25 +1,23 @@
/* /*
* Copyright 2014 David Horscroft * Copyright 2014 David Horscroft
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* *
* The NoRegister class is a simple model used to return both cookies and * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* download data upon user registration. * in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*
* The NoRegister class is a simple model used to return both cookies and download data upon user
* registration.
*/ */
package nodash.core; package nodash.core;
public final class NoRegister { public final class NoRegister {
public byte[] cookie; public byte[] cookie;
public byte[] data; public byte[] data;
} }

361
src/nodash/core/NoUtil.java
View File

@@ -1,20 +1,18 @@
/* /*
* Copyright 2014 David Horscroft * Copyright 2014 David Horscroft
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* *
* The NoUtil class encapsulates no- standard functions such as encryption/decryption * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* and hashing algorithms. * in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*
* The NoUtil class encapsulates no- standard functions such as encryption/decryption and hashing
* algorithms.
*/ */
package nodash.core; package nodash.core;
@@ -38,172 +36,177 @@ import javax.crypto.spec.SecretKeySpec;
import nodash.exceptions.NoDashFatalException; import nodash.exceptions.NoDashFatalException;
public final class NoUtil { public final class NoUtil {
public static final String CIPHER_TYPE = "AES/ECB/PKCS5PADDING"; public static final String CIPHER_TYPE = "AES/ECB/PKCS5PADDING";
public static final String CIPHER_KEY_SPEC = "AES"; public static final String CIPHER_KEY_SPEC = "AES";
public static final String DIGEST_TYPE = "SHA-512"; public static final String DIGEST_TYPE = "SHA-512";
public static final String PBE_TYPE = "PBKDF2WithHmacSHA1"; public static final String PBE_TYPE = "PBKDF2WithHmacSHA1";
public static final String CIPHER_RSA_TYPE = "RSA/ECB/PKCS1PADDING"; public static final String CIPHER_RSA_TYPE = "RSA/ECB/PKCS1PADDING";
public static final String KEYPAIR_ALGORITHM = "RSA"; public static final String KEYPAIR_ALGORITHM = "RSA";
public static final String SECURERANDOM_ALGORITHM = "SHA1PRNG"; public static final String SECURERANDOM_ALGORITHM = "SHA1PRNG";
public static final String SECURERANDOM_PROVIDER = "SUN"; public static final String SECURERANDOM_PROVIDER = "SUN";
public static final int RSA_STRENGTH = 4096; public static final int RSA_STRENGTH = 4096;
public static final int AES_STRENGTH = 256; public static final int AES_STRENGTH = 256;
public static final byte BLANK_BYTE = 'A'; public static final byte BLANK_BYTE = 'A';
public static char[] bytesToChars(byte[] array) {
char[] result = new char[array.length];
for (int x=0; x<array.length; x++) {
result[x] = (char) array[x];
}
return result;
}
public static byte[] charsToBytes(char[] array) {
byte[] result = new byte[array.length];
for (int x=0; x<array.length; x++) {
result[x] = (byte) array[x];
}
return result;
}
public static void wipeBytes(byte[] array) { public static char[] bytesToChars(byte[] array) {
for (int x=0; x<array.length; x++) { char[] result = new char[array.length];
array[x] = NoUtil.BLANK_BYTE; for (int x = 0; x < array.length; x++) {
} result[x] = (char) array[x];
} }
return result;
}
public static void wipeChars(char[] array) { public static byte[] charsToBytes(char[] array) {
for (int x=0; x<array.length; x++) { byte[] result = new byte[array.length];
array[x] = NoUtil.BLANK_BYTE; for (int x = 0; x < array.length; x++) {
} result[x] = (byte) array[x];
} }
return result;
}
private static byte[] getPBEKeyFromPassword(char[] password) { public static void wipeBytes(byte[] array) {
SecretKeyFactory skf; for (int x = 0; x < array.length; x++) {
try { array[x] = NoUtil.BLANK_BYTE;
skf = SecretKeyFactory.getInstance(NoUtil.PBE_TYPE); }
} catch (NoSuchAlgorithmException e) { }
throw new NoDashFatalException("Value for PBE_TYPE is not valid.", e);
}
KeySpec spec = new PBEKeySpec(password, NoCore.config.getSecretKey().getEncoded(), 65536, 256);
SecretKey key;
try {
key = skf.generateSecret(spec);
} catch (InvalidKeySpecException e) {
throw new NoDashFatalException("PBE manager unable to derive key from password.", e);
}
NoUtil.wipeChars(password);
return key.getEncoded();
}
public static byte[] getHashFromByteArray(byte[] bytes) {
try {
MessageDigest messageDigest = MessageDigest.getInstance(NoUtil.DIGEST_TYPE);
return messageDigest.digest(bytes);
} catch (NoSuchAlgorithmException e) {
throw new NoDashFatalException("Value for DIGEST_TYPE not valid.", e);
}
}
public static byte[] decrypt(byte[] data, char[] password) throws IllegalBlockSizeException, BadPaddingException {
byte[] passwordByte = NoUtil.getPBEKeyFromPassword(password);
byte[] response = NoUtil.decrypt(NoUtil.decrypt(data), passwordByte);
NoUtil.wipeBytes(passwordByte);
return response;
}
public static byte[] encrypt(byte[] data, char[] password) {
byte[] passwordByte = NoUtil.getPBEKeyFromPassword(password);
byte[] response = NoUtil.encrypt(NoUtil.encrypt(data, passwordByte));
NoUtil.wipeBytes(passwordByte);
return response;
}
public static byte[] encrypt(byte[] data, byte[] key) {
Cipher cipher;
try {
cipher = Cipher.getInstance(NoUtil.CIPHER_TYPE);
} catch (NoSuchAlgorithmException e) {
throw new NoDashFatalException("Value for CIPHER_TYPE is not valid (no such algorithm).", e);
} catch (NoSuchPaddingException e) {
throw new NoDashFatalException("Value for CIPHER_TYPE is not valid (no such padding).", e);
}
SecretKeySpec secretKey = new SecretKeySpec(key, NoUtil.CIPHER_KEY_SPEC);
try {
cipher.init(Cipher.ENCRYPT_MODE, secretKey);
} catch (InvalidKeyException e) {
throw new NoDashFatalException("Secret key is invalid.", e);
}
try {
return cipher.doFinal(data);
} catch (IllegalBlockSizeException e) {
throw new NoDashFatalException("Block size exception encountered during encryption.", e);
} catch (BadPaddingException e) {
throw new NoDashFatalException("Bad padding exception encountered during encryption.", e);
}
}
public static byte[] encrypt(byte[] data) {
return NoUtil.encrypt(data, NoCore.config.getSecretKey().getEncoded());
}
public static byte[] decrypt(byte[] data, byte[] key) throws IllegalBlockSizeException, BadPaddingException {
Cipher cipher;
try {
cipher = Cipher.getInstance(NoUtil.CIPHER_TYPE);
} catch (NoSuchAlgorithmException e) {
throw new NoDashFatalException("Value for CIPHER_TYPE is not valid (no such algorithm).", e);
} catch (NoSuchPaddingException e) {
throw new NoDashFatalException("Value for CIPHER_TYPE is not valid (no such padding).", e);
}
SecretKeySpec secretKey = new SecretKeySpec(key, NoUtil.CIPHER_KEY_SPEC);
try {
cipher.init(Cipher.DECRYPT_MODE, secretKey);
} catch (InvalidKeyException e) {
throw new NoDashFatalException("Secret key is invalid.", e);
}
return cipher.doFinal(data);
}
public static byte[] decrypt(byte[] data) throws IllegalBlockSizeException, BadPaddingException {
return NoUtil.decrypt(data, NoCore.config.getSecretKey().getEncoded());
}
public static byte[] encryptRSA(byte[] data, PublicKey publicKey) {
Cipher cipher;
try {
cipher = Cipher.getInstance(NoUtil.CIPHER_RSA_TYPE);
} catch (NoSuchAlgorithmException e) {
throw new NoDashFatalException("Value for CIPHER_RSA_TYPE is not valid (no such algorithm).", e);
} catch (NoSuchPaddingException e) {
throw new NoDashFatalException("Value for CIPHER_RSA_TYPE is not valid (no such padding).", e);
}
try {
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
return cipher.doFinal(data);
} catch (InvalidKeyException e){
throw new NoDashFatalException("Public key invalid.", e);
} catch (IllegalBlockSizeException e) {
throw new NoDashFatalException("Unable to encrypt data stream with public key.", e);
} catch (BadPaddingException e) {
throw new NoDashFatalException("Unable to encrypt data stream with public key.", e);
}
}
public static byte[] decryptRSA(byte[] data, PrivateKey privateKey) throws InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
Cipher cipher;
try {
cipher = Cipher.getInstance(NoUtil.CIPHER_RSA_TYPE);
} catch (NoSuchAlgorithmException e) {
throw new NoDashFatalException("Value for CIPHER_RSA_TYPE is not valid (no such algorithm).", e);
} catch (NoSuchPaddingException e) {
throw new NoDashFatalException("Value for CIPHER_RSA_TYPE is not valid (no such padding).", e);
}
cipher.init(Cipher.DECRYPT_MODE, privateKey);
return cipher.doFinal(data);
}
} public static void wipeChars(char[] array) {
for (int x = 0; x < array.length; x++) {
array[x] = NoUtil.BLANK_BYTE;
}
}
private static byte[] getPBEKeyFromPassword(char[] password) {
SecretKeyFactory skf;
try {
skf = SecretKeyFactory.getInstance(NoUtil.PBE_TYPE);
} catch (NoSuchAlgorithmException e) {
throw new NoDashFatalException("Value for PBE_TYPE is not valid.", e);
}
KeySpec spec = new PBEKeySpec(password, NoCore.config.getSecretKey().getEncoded(), 65536, 256);
SecretKey key;
try {
key = skf.generateSecret(spec);
} catch (InvalidKeySpecException e) {
throw new NoDashFatalException("PBE manager unable to derive key from password.", e);
}
NoUtil.wipeChars(password);
return key.getEncoded();
}
public static byte[] getHashFromByteArray(byte[] bytes) {
try {
MessageDigest messageDigest = MessageDigest.getInstance(NoUtil.DIGEST_TYPE);
return messageDigest.digest(bytes);
} catch (NoSuchAlgorithmException e) {
throw new NoDashFatalException("Value for DIGEST_TYPE not valid.", e);
}
}
public static byte[] decrypt(byte[] data, char[] password) throws IllegalBlockSizeException,
BadPaddingException {
byte[] passwordByte = NoUtil.getPBEKeyFromPassword(password);
byte[] response = NoUtil.decrypt(NoUtil.decrypt(data), passwordByte);
NoUtil.wipeBytes(passwordByte);
return response;
}
public static byte[] encrypt(byte[] data, char[] password) {
byte[] passwordByte = NoUtil.getPBEKeyFromPassword(password);
byte[] response = NoUtil.encrypt(NoUtil.encrypt(data, passwordByte));
NoUtil.wipeBytes(passwordByte);
return response;
}
public static byte[] encrypt(byte[] data, byte[] key) {
Cipher cipher;
try {
cipher = Cipher.getInstance(NoUtil.CIPHER_TYPE);
} catch (NoSuchAlgorithmException e) {
throw new NoDashFatalException("Value for CIPHER_TYPE is not valid (no such algorithm).", e);
} catch (NoSuchPaddingException e) {
throw new NoDashFatalException("Value for CIPHER_TYPE is not valid (no such padding).", e);
}
SecretKeySpec secretKey = new SecretKeySpec(key, NoUtil.CIPHER_KEY_SPEC);
try {
cipher.init(Cipher.ENCRYPT_MODE, secretKey);
} catch (InvalidKeyException e) {
throw new NoDashFatalException("Secret key is invalid.", e);
}
try {
return cipher.doFinal(data);
} catch (IllegalBlockSizeException e) {
throw new NoDashFatalException("Block size exception encountered during encryption.", e);
} catch (BadPaddingException e) {
throw new NoDashFatalException("Bad padding exception encountered during encryption.", e);
}
}
public static byte[] encrypt(byte[] data) {
return NoUtil.encrypt(data, NoCore.config.getSecretKey().getEncoded());
}
public static byte[] decrypt(byte[] data, byte[] key) throws IllegalBlockSizeException,
BadPaddingException {
Cipher cipher;
try {
cipher = Cipher.getInstance(NoUtil.CIPHER_TYPE);
} catch (NoSuchAlgorithmException e) {
throw new NoDashFatalException("Value for CIPHER_TYPE is not valid (no such algorithm).", e);
} catch (NoSuchPaddingException e) {
throw new NoDashFatalException("Value for CIPHER_TYPE is not valid (no such padding).", e);
}
SecretKeySpec secretKey = new SecretKeySpec(key, NoUtil.CIPHER_KEY_SPEC);
try {
cipher.init(Cipher.DECRYPT_MODE, secretKey);
} catch (InvalidKeyException e) {
throw new NoDashFatalException("Secret key is invalid.", e);
}
return cipher.doFinal(data);
}
public static byte[] decrypt(byte[] data) throws IllegalBlockSizeException, BadPaddingException {
return NoUtil.decrypt(data, NoCore.config.getSecretKey().getEncoded());
}
public static byte[] encryptRSA(byte[] data, PublicKey publicKey) {
Cipher cipher;
try {
cipher = Cipher.getInstance(NoUtil.CIPHER_RSA_TYPE);
} catch (NoSuchAlgorithmException e) {
throw new NoDashFatalException("Value for CIPHER_RSA_TYPE is not valid (no such algorithm).",
e);
} catch (NoSuchPaddingException e) {
throw new NoDashFatalException("Value for CIPHER_RSA_TYPE is not valid (no such padding).", e);
}
try {
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
return cipher.doFinal(data);
} catch (InvalidKeyException e) {
throw new NoDashFatalException("Public key invalid.", e);
} catch (IllegalBlockSizeException e) {
throw new NoDashFatalException("Unable to encrypt data stream with public key.", e);
} catch (BadPaddingException e) {
throw new NoDashFatalException("Unable to encrypt data stream with public key.", e);
}
}
public static byte[] decryptRSA(byte[] data, PrivateKey privateKey) throws InvalidKeyException,
IllegalBlockSizeException, BadPaddingException {
Cipher cipher;
try {
cipher = Cipher.getInstance(NoUtil.CIPHER_RSA_TYPE);
} catch (NoSuchAlgorithmException e) {
throw new NoDashFatalException("Value for CIPHER_RSA_TYPE is not valid (no such algorithm).",
e);
} catch (NoSuchPaddingException e) {
throw new NoDashFatalException("Value for CIPHER_RSA_TYPE is not valid (no such padding).", e);
}
cipher.init(Cipher.DECRYPT_MODE, privateKey);
return cipher.doFinal(data);
}
}

81
src/nodash/core/spheres/NoByteSetSphere.java
View File

@@ -1,20 +1,18 @@
/* /*
* Copyright 2014 David Horscroft * Copyright 2014 David Horscroft
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* *
* The NoByteSetSphere stores user-to-user influences and their encryption * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* keys in an accessible manner. * in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*
* The NoByteSetSphere stores user-to-user influences and their encryption keys in an accessible
* manner.
*/ */
package nodash.core.spheres; package nodash.core.spheres;
@@ -27,31 +25,32 @@ import nodash.models.NoByteSet;
import nodash.models.NoUser; import nodash.models.NoUser;
public final class NoByteSetSphere { public final class NoByteSetSphere {
private static final ArrayList<NoByteSet> EMPTY_BYTESET_LIST = new ArrayList<NoByteSet>(0); private static final ArrayList<NoByteSet> EMPTY_BYTESET_LIST = new ArrayList<NoByteSet>(0);
private static ConcurrentHashMap<PublicKey, ArrayList<NoByteSet>> byteSets = new ConcurrentHashMap<PublicKey, ArrayList<NoByteSet>>(); private static ConcurrentHashMap<PublicKey, ArrayList<NoByteSet>> byteSets =
new ConcurrentHashMap<PublicKey, ArrayList<NoByteSet>>();
public static void add(NoByteSet byteSet, PublicKey publicKey) {
if (!NoByteSetSphere.byteSets.containsKey(publicKey)) { public static void add(NoByteSet byteSet, PublicKey publicKey) {
NoByteSetSphere.byteSets.put(publicKey, new ArrayList<NoByteSet>()); if (!NoByteSetSphere.byteSets.containsKey(publicKey)) {
} NoByteSetSphere.byteSets.put(publicKey, new ArrayList<NoByteSet>());
NoByteSetSphere.byteSets.get(publicKey).add(byteSet); }
} NoByteSetSphere.byteSets.get(publicKey).add(byteSet);
}
public static void addList(ArrayList<NoByteSet> byteSetList, PublicKey publicKey) {
if (!NoByteSetSphere.byteSets.containsKey(publicKey)) { public static void addList(ArrayList<NoByteSet> byteSetList, PublicKey publicKey) {
NoByteSetSphere.byteSets.put(publicKey, new ArrayList<NoByteSet>()); if (!NoByteSetSphere.byteSets.containsKey(publicKey)) {
} NoByteSetSphere.byteSets.put(publicKey, new ArrayList<NoByteSet>());
NoByteSetSphere.byteSets.get(publicKey).addAll(byteSetList); }
} NoByteSetSphere.byteSets.get(publicKey).addAll(byteSetList);
}
public static ArrayList<NoByteSet> consume(NoUser user) {
if (NoByteSetSphere.byteSets.containsKey(user.getRSAPublicKey())) { public static ArrayList<NoByteSet> consume(NoUser user) {
ArrayList<NoByteSet> result = NoByteSetSphere.byteSets.get(user.getRSAPublicKey()); if (NoByteSetSphere.byteSets.containsKey(user.getRSAPublicKey())) {
NoByteSetSphere.byteSets.remove(user.getRSAPublicKey()); ArrayList<NoByteSet> result = NoByteSetSphere.byteSets.get(user.getRSAPublicKey());
return result; NoByteSetSphere.byteSets.remove(user.getRSAPublicKey());
} else { return result;
return NoByteSetSphere.EMPTY_BYTESET_LIST; } else {
} return NoByteSetSphere.EMPTY_BYTESET_LIST;
} }
}
} }

165
src/nodash/core/spheres/NoHashSphereDefault.java
View File

@@ -1,17 +1,15 @@
/* /*
* Copyright 2014 David Horscroft * Copyright 2014 David Horscroft
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* you may not use this file except in compliance with the License. * in compliance with the License. You may obtain a copy of the License at
* You may obtain a copy of the License at *
* * http://www.apache.org/licenses/LICENSE-2.0
* http://www.apache.org/licenses/LICENSE-2.0 *
* * Unless required by applicable law or agreed to in writing, software distributed under the License
* Unless required by applicable law or agreed to in writing, software * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* distributed under the License is distributed on an "AS IS" BASIS, * or implied. See the License for the specific language governing permissions and limitations under
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * the License.
* See the License for the specific language governing permissions and
* limitations under the License.
* *
* The NoHashSpehre stores database hashes for user verification. * The NoHashSpehre stores database hashes for user verification.
* *
@@ -38,77 +36,78 @@ import nodash.exceptions.NoDashFatalException;
import nodash.models.NoUser; import nodash.models.NoUser;
public final class NoHashSphereDefault implements NoHashSphereInterface { public final class NoHashSphereDefault implements NoHashSphereInterface {
private Set<String> database = Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>()); private Set<String> database = Collections
private String fileName; .newSetFromMap(new ConcurrentHashMap<String, Boolean>());
private boolean ready = false; private String fileName;
private boolean ready = false;
public NoHashSphereDefault(String fileName) {
this.fileName = fileName;
}
public NoHashSphereDefault() {
this.fileName = ( (NoConfigDefault) NoCore.config).getDatabaseName();
}
@SuppressWarnings("unchecked")
public void setup() {
if (NoCore.config.saveDatabase()) {
File file = new File(this.fileName);
if (file.exists()) {
try {
byte[] data = Files.readAllBytes(file.toPath());
ByteArrayInputStream bais = new ByteArrayInputStream(data);
ObjectInputStream ois = new ObjectInputStream(bais);
this.database = (Set<String>) ois.readObject();
ois.close();
bais.close();
} catch (IOException e){
throw new NoDashFatalException("Unable to load up given database file.", e);
} catch (ClassNotFoundException e) {
throw new NoDashFatalException("Database file not in a verifiable format.", e);
}
}
}
this.ready = true;
}
public synchronized void saveToFile() throws IOException {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(this.database);
byte[] data = baos.toByteArray();
oos.close();
baos.close();
File file = new File( ( (NoConfigDefault) NoCore.config).getDatabaseName());
Files.write(file.toPath(), data, StandardOpenOption.CREATE);
}
public synchronized void addNewNoUser(NoUser user) throws IOException {
String hash = user.createHashString();
this.database.add(hash);
this.saveToFile();
}
public synchronized void insertHash(String hash) throws IOException {
this.database.add(hash);
this.saveToFile();
}
public synchronized void removeHash(String hash) throws IOException {
this.database.remove(hash);
this.saveToFile();
}
public synchronized boolean checkHash(String hash) {
return this.database.contains(hash);
}
public synchronized long size() { public NoHashSphereDefault(String fileName) {
return this.database.size(); this.fileName = fileName;
} }
@Override public NoHashSphereDefault() {
public boolean isReady() { this.fileName = ((NoConfigDefault) NoCore.config).getDatabaseName();
return this.ready; }
}
@SuppressWarnings("unchecked")
public void setup() {
if (NoCore.config.saveDatabase()) {
File file = new File(this.fileName);
if (file.exists()) {
try {
byte[] data = Files.readAllBytes(file.toPath());
ByteArrayInputStream bais = new ByteArrayInputStream(data);
ObjectInputStream ois = new ObjectInputStream(bais);
this.database = (Set<String>) ois.readObject();
ois.close();
bais.close();
} catch (IOException e) {
throw new NoDashFatalException("Unable to load up given database file.", e);
} catch (ClassNotFoundException e) {
throw new NoDashFatalException("Database file not in a verifiable format.", e);
}
}
}
this.ready = true;
}
public synchronized void saveToFile() throws IOException {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(this.database);
byte[] data = baos.toByteArray();
oos.close();
baos.close();
File file = new File(((NoConfigDefault) NoCore.config).getDatabaseName());
Files.write(file.toPath(), data, StandardOpenOption.CREATE);
}
public synchronized void addNewNoUser(NoUser user) throws IOException {
String hash = user.createHashString();
this.database.add(hash);
this.saveToFile();
}
public synchronized void insertHash(String hash) throws IOException {
this.database.add(hash);
this.saveToFile();
}
public synchronized void removeHash(String hash) throws IOException {
this.database.remove(hash);
this.saveToFile();
}
public synchronized boolean checkHash(String hash) {
return this.database.contains(hash);
}
public synchronized long size() {
return this.database.size();
}
@Override
public boolean isReady() {
return this.ready;
}
} }

23
src/nodash/core/spheres/NoHashSphereInterface.java
View File

@@ -5,12 +5,19 @@ import java.io.IOException;
import nodash.models.NoUser; import nodash.models.NoUser;
public interface NoHashSphereInterface { public interface NoHashSphereInterface {
public void setup(); public void setup();
public void saveToFile() throws IOException;
public void addNewNoUser(NoUser user) throws IOException; public void saveToFile() throws IOException;
public void insertHash(String hash) throws IOException;
public void removeHash(String hash) throws IOException; public void addNewNoUser(NoUser user) throws IOException;
public boolean checkHash(String hash);
public long size(); public void insertHash(String hash) throws IOException;
public boolean isReady();
public void removeHash(String hash) throws IOException;
public boolean checkHash(String hash);
public long size();
public boolean isReady();
} }

325
src/nodash/core/spheres/NoSessionSphere.java
View File

@@ -1,20 +1,18 @@
/* /*
* Copyright 2014 David Horscroft * Copyright 2014 David Horscroft
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* *
* The NoSessionSphere stores user sessions and allows their access and * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* manipulation with the use of their UUID. * in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*
* The NoSessionSphere stores user sessions and allows their access and manipulation with the use of
* their UUID.
*/ */
package nodash.core.spheres; package nodash.core.spheres;
@@ -43,148 +41,161 @@ import nodash.models.NoUser;
import nodash.models.NoSession.NoState; import nodash.models.NoSession.NoState;
public final class NoSessionSphere { public final class NoSessionSphere {
private static ConcurrentHashMap<UUID, NoSession> sessions = new ConcurrentHashMap<UUID, NoSession>(); private static ConcurrentHashMap<UUID, NoSession> sessions =
private static Set<String> originalHashesOnline = Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>()); new ConcurrentHashMap<UUID, NoSession>();
private static Set<String> originalHashesOnline = Collections
public static synchronized void prune() { .newSetFromMap(new ConcurrentHashMap<String, Boolean>());
for (UUID uuid : NoSessionSphere.sessions.keySet()) {
pruneSingle(uuid);
}
}
public static void shred(byte[] encryptedUUID) { public static synchronized void prune() {
try { for (UUID uuid : NoSessionSphere.sessions.keySet()) {
UUID uuid = NoSession.decryptUUID(encryptedUUID); pruneSingle(uuid);
if (NoSessionSphere.sessions.containsKey(uuid)) { }
NoSession session = NoSessionSphere.sessions.get(uuid); }
NoByteSetSphere.addList(session.incoming, session.current.getRSAPublicKey());
NoSessionSphere.originalHashesOnline.remove(Base64.encodeBase64String(session.getOriginalHash()));
NoSessionSphere.sessions.remove(uuid);
session = null;
}
} catch (NoDashSessionBadUUIDException e) {
// Suppress, doesn't matter
}
}
public static synchronized void pruneSingle(UUID uuid) {
NoSession session = NoSessionSphere.sessions.get(uuid);
try {
session.check();
} catch (NoSessionExpiredException e) {
/* Resultant from 3.1 and 3.2 */
NoByteSetSphere.addList(session.incoming, session.current.getRSAPublicKey());
NoSessionSphere.originalHashesOnline.remove(session.getOriginalHash());
NoSessionSphere.sessions.remove(uuid);
session = null;
} catch (NoSessionConfirmedException e) {
/* Should be cleaned up at 5.2 */
}
}
public static synchronized byte[] login(byte[] data, char[] password) throws NoUserNotValidException, NoUserAlreadyOnlineException, NoSessionExpiredException {
/* 1. Login with byte[] data and byte[] password */
NoSession session = new NoSession(data, password);
/* 1.1. User currently has an online session, must wait for it to expire. */
if (originalHashesOnline.contains(Base64.encodeBase64String(session.getOriginalHash()))) {
throw new NoUserAlreadyOnlineException();
}
/* 1.2. User successfully logged in: set up session records. */
NoSessionSphere.originalHashesOnline.add(Base64.encodeBase64String(session.getOriginalHash()));
NoSessionSphere.sessions.put(session.uuid, session);
/* 2. Check NoByteSetSphere for incoming Influences */
session.incoming = NoByteSetSphere.consume(session.current);
for (NoByteSet nbs : session.incoming) {
/* 2.1 Decrypt NoInfluence from NoByteSet, let the current user consume them */
try {
session.consume(nbs);
} catch (NoByteSetBadDecryptionException e) {
throw new NoDashFatalException("Bad byte sets on consumption.", e);
}
} /* 2.2 Alternatively, no NoByteSets to consume */
try {
session.check();
} catch (NoSessionConfirmedException e) {
/* Should be impossible to reach */
throw new NoDashFatalException(e);
}
/* Will set to 2.1[MODIFIED] or 2.2[IDLE] */
/* Precursor to 3.; allow website to associate user session with a cookie. */
return session.getEncryptedUUID();
}
public static NoUser getUser(byte[] encryptedUUID) throws NoDashSessionBadUUIDException, NoSessionExpiredException, NoSessionConfirmedException {
UUID uuid = NoSession.decryptUUID(encryptedUUID);
if (NoSessionSphere.sessions.containsKey(uuid)) {
NoSessionSphere.pruneSingle(uuid);
try {
return NoSessionSphere.sessions.get(uuid).getNoUser();
} catch (NullPointerException e) {
throw new NoSessionExpiredException();
}
}
throw new NoSessionExpiredException();
}
public static NoState getState(byte[] encryptedUUID) throws NoDashSessionBadUUIDException, NoSessionExpiredException, NoSessionConfirmedException {
UUID uuid = NoSession.decryptUUID(encryptedUUID);
if (NoSessionSphere.sessions.containsKey(uuid)) {
NoSessionSphere.pruneSingle(uuid);
NoSession session = NoSessionSphere.sessions.get(uuid);
return session.getNoState();
}
throw new NoSessionExpiredException();
}
public static synchronized byte[] save(byte[] encryptedUUID, char[] password) throws NoDashSessionBadUUIDException, NoSessionExpiredException, NoSessionConfirmedException, NoSessionNotChangedException, NoSessionAlreadyAwaitingConfirmationException {
UUID uuid = NoSession.decryptUUID(encryptedUUID);
if (NoSessionSphere.sessions.containsKey(uuid)) {
NoSessionSphere.pruneSingle(uuid);
NoSession session = NoSessionSphere.sessions.get(uuid);
if (session.getNoState().equals(NoState.IDLE)) {
throw new NoSessionNotChangedException();
} else if (session.getNoState().equals(NoState.AWAITING_CONFIRMATION)) {
throw new NoSessionAlreadyAwaitingConfirmationException();
}
return session.initiateSaveAttempt(password);
}
throw new NoSessionExpiredException();
}
public static synchronized void confirm(byte[] encryptedUUID, char[] password, byte[] data) throws NoDashSessionBadUUIDException, NoSessionExpiredException, NoSessionConfirmedException, NoSessionNotAwaitingConfirmationException, NoUserNotValidException {
UUID uuid = NoSession.decryptUUID(encryptedUUID);
if (NoSessionSphere.sessions.containsKey(uuid)) {
NoSessionSphere.pruneSingle(uuid);
NoSession session = NoSessionSphere.sessions.get(uuid);
session.confirmSave(data, password);
return;
}
throw new NoSessionExpiredException();
}
public static synchronized NoRegister registerUser(NoUser user, char[] password) { public static void shred(byte[] encryptedUUID) {
NoRegister result = new NoRegister(); try {
NoSession session = new NoSession(user); UUID uuid = NoSession.decryptUUID(encryptedUUID);
NoSessionSphere.sessions.put(session.uuid, session); if (NoSessionSphere.sessions.containsKey(uuid)) {
result.cookie = session.getEncryptedUUID(); NoSession session = NoSessionSphere.sessions.get(uuid);
try { NoByteSetSphere.addList(session.incoming, session.current.getRSAPublicKey());
result.data = NoSessionSphere.save(result.cookie, password); NoSessionSphere.originalHashesOnline.remove(Base64.encodeBase64String(session
} catch (NoDashSessionBadUUIDException e) { .getOriginalHash()));
throw new NoDashFatalException("Immediately generated cookie throwing bad cookie error.", e); NoSessionSphere.sessions.remove(uuid);
} catch (NoSessionExpiredException e) { session = null;
throw new NoDashFatalException("Session expired before it was even returned to client.", e); }
} catch (NoSessionConfirmedException e) { } catch (NoDashSessionBadUUIDException e) {
throw new NoDashFatalException("Session is in confirmed state before it was returned to client.", e); // Suppress, doesn't matter
} catch (NoSessionNotChangedException e) { }
throw new NoDashFatalException("Session claims to be unchanged but user is newly registered.", e); }
} catch (NoSessionAlreadyAwaitingConfirmationException e) {
throw new NoDashFatalException("Session claims to be awaiting confirmation before returning data to the user.", e); public static synchronized void pruneSingle(UUID uuid) {
} NoSession session = NoSessionSphere.sessions.get(uuid);
return result; try {
} session.check();
} } catch (NoSessionExpiredException e) {
/* Resultant from 3.1 and 3.2 */
NoByteSetSphere.addList(session.incoming, session.current.getRSAPublicKey());
NoSessionSphere.originalHashesOnline.remove(session.getOriginalHash());
NoSessionSphere.sessions.remove(uuid);
session = null;
} catch (NoSessionConfirmedException e) {
/* Should be cleaned up at 5.2 */
}
}
public static synchronized byte[] login(byte[] data, char[] password)
throws NoUserNotValidException, NoUserAlreadyOnlineException, NoSessionExpiredException {
/* 1. Login with byte[] data and byte[] password */
NoSession session = new NoSession(data, password);
/* 1.1. User currently has an online session, must wait for it to expire. */
if (originalHashesOnline.contains(Base64.encodeBase64String(session.getOriginalHash()))) {
throw new NoUserAlreadyOnlineException();
}
/* 1.2. User successfully logged in: set up session records. */
NoSessionSphere.originalHashesOnline.add(Base64.encodeBase64String(session.getOriginalHash()));
NoSessionSphere.sessions.put(session.uuid, session);
/* 2. Check NoByteSetSphere for incoming Influences */
session.incoming = NoByteSetSphere.consume(session.current);
for (NoByteSet nbs : session.incoming) {
/* 2.1 Decrypt NoInfluence from NoByteSet, let the current user consume them */
try {
session.consume(nbs);
} catch (NoByteSetBadDecryptionException e) {
throw new NoDashFatalException("Bad byte sets on consumption.", e);
}
} /* 2.2 Alternatively, no NoByteSets to consume */
try {
session.check();
} catch (NoSessionConfirmedException e) {
/* Should be impossible to reach */
throw new NoDashFatalException(e);
}
/* Will set to 2.1[MODIFIED] or 2.2[IDLE] */
/* Precursor to 3.; allow website to associate user session with a cookie. */
return session.getEncryptedUUID();
}
public static NoUser getUser(byte[] encryptedUUID) throws NoDashSessionBadUUIDException,
NoSessionExpiredException, NoSessionConfirmedException {
UUID uuid = NoSession.decryptUUID(encryptedUUID);
if (NoSessionSphere.sessions.containsKey(uuid)) {
NoSessionSphere.pruneSingle(uuid);
try {
return NoSessionSphere.sessions.get(uuid).getNoUser();
} catch (NullPointerException e) {
throw new NoSessionExpiredException();
}
}
throw new NoSessionExpiredException();
}
public static NoState getState(byte[] encryptedUUID) throws NoDashSessionBadUUIDException,
NoSessionExpiredException, NoSessionConfirmedException {
UUID uuid = NoSession.decryptUUID(encryptedUUID);
if (NoSessionSphere.sessions.containsKey(uuid)) {
NoSessionSphere.pruneSingle(uuid);
NoSession session = NoSessionSphere.sessions.get(uuid);
return session.getNoState();
}
throw new NoSessionExpiredException();
}
public static synchronized byte[] save(byte[] encryptedUUID, char[] password)
throws NoDashSessionBadUUIDException, NoSessionExpiredException, NoSessionConfirmedException,
NoSessionNotChangedException, NoSessionAlreadyAwaitingConfirmationException {
UUID uuid = NoSession.decryptUUID(encryptedUUID);
if (NoSessionSphere.sessions.containsKey(uuid)) {
NoSessionSphere.pruneSingle(uuid);
NoSession session = NoSessionSphere.sessions.get(uuid);
if (session.getNoState().equals(NoState.IDLE)) {
throw new NoSessionNotChangedException();
} else if (session.getNoState().equals(NoState.AWAITING_CONFIRMATION)) {
throw new NoSessionAlreadyAwaitingConfirmationException();
}
return session.initiateSaveAttempt(password);
}
throw new NoSessionExpiredException();
}
public static synchronized void confirm(byte[] encryptedUUID, char[] password, byte[] data)
throws NoDashSessionBadUUIDException, NoSessionExpiredException, NoSessionConfirmedException,
NoSessionNotAwaitingConfirmationException, NoUserNotValidException {
UUID uuid = NoSession.decryptUUID(encryptedUUID);
if (NoSessionSphere.sessions.containsKey(uuid)) {
NoSessionSphere.pruneSingle(uuid);
NoSession session = NoSessionSphere.sessions.get(uuid);
session.confirmSave(data, password);
return;
}
throw new NoSessionExpiredException();
}
public static synchronized NoRegister registerUser(NoUser user, char[] password) {
NoRegister result = new NoRegister();
NoSession session = new NoSession(user);
NoSessionSphere.sessions.put(session.uuid, session);
result.cookie = session.getEncryptedUUID();
try {
result.data = NoSessionSphere.save(result.cookie, password);
} catch (NoDashSessionBadUUIDException e) {
throw new NoDashFatalException("Immediately generated cookie throwing bad cookie error.", e);
} catch (NoSessionExpiredException e) {
throw new NoDashFatalException("Session expired before it was even returned to client.", e);
} catch (NoSessionConfirmedException e) {
throw new NoDashFatalException(
"Session is in confirmed state before it was returned to client.", e);
} catch (NoSessionNotChangedException e) {
throw new NoDashFatalException(
"Session claims to be unchanged but user is newly registered.", e);
} catch (NoSessionAlreadyAwaitingConfirmationException e) {
throw new NoDashFatalException(
"Session claims to be awaiting confirmation before returning data to the user.", e);
}
return result;
}
}

35
src/nodash/exceptions/NoByteSetBadDecryptionException.java
View File

@@ -1,29 +1,26 @@
/* /*
* Copyright 2014 David Horscroft * Copyright 2014 David Horscroft
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* *
* NoByteSetBadDecryptionException is triggered when no- is unable to * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* decrypt a given byte stream. * in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*
* NoByteSetBadDecryptionException is triggered when no- is unable to decrypt a given byte stream.
*/ */
package nodash.exceptions; package nodash.exceptions;
public class NoByteSetBadDecryptionException extends NoDashException { public class NoByteSetBadDecryptionException extends NoDashException {
private static final long serialVersionUID = -8579497499272656543L; private static final long serialVersionUID = -8579497499272656543L;
public NoByteSetBadDecryptionException(Exception e) { public NoByteSetBadDecryptionException(Exception e) {
super(e); super(e);
} }
} }

52
src/nodash/exceptions/NoCannotGetInfluenceException.java
View File

@@ -1,21 +1,19 @@
/* /*
* Copyright 2014 David Horscroft * Copyright 2014 David Horscroft
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* *
* NoCannotGetInfluenceException is returned when an action is unable to * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* render a successful influence for the target, instead returning an * in compliance with the License. You may obtain a copy of the License at
* influence to be returned to the sender if possible. *
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*
* NoCannotGetInfluenceException is returned when an action is unable to render a successful
* influence for the target, instead returning an influence to be returned to the sender if
* possible.
*/ */
package nodash.exceptions; package nodash.exceptions;
@@ -23,16 +21,16 @@ package nodash.exceptions;
import nodash.models.NoInfluence; import nodash.models.NoInfluence;
public class NoCannotGetInfluenceException extends Exception { public class NoCannotGetInfluenceException extends Exception {
private static final long serialVersionUID = 4581361079067540974L; private static final long serialVersionUID = 4581361079067540974L;
private NoInfluence returnable; private NoInfluence returnable;
public NoCannotGetInfluenceException(NoInfluence returnable) { public NoCannotGetInfluenceException(NoInfluence returnable) {
super(); super();
this.returnable = returnable; this.returnable = returnable;
} }
public NoInfluence getResponseInfluence() { public NoInfluence getResponseInfluence() {
return returnable; return returnable;
} }
} }

38
src/nodash/exceptions/NoDashException.java
View File

@@ -1,17 +1,15 @@
/* /*
* Copyright 2014 David Horscroft * Copyright 2014 David Horscroft
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* you may not use this file except in compliance with the License. * in compliance with the License. You may obtain a copy of the License at
* You may obtain a copy of the License at *
* * http://www.apache.org/licenses/LICENSE-2.0
* http://www.apache.org/licenses/LICENSE-2.0 *
* * Unless required by applicable law or agreed to in writing, software distributed under the License
* Unless required by applicable law or agreed to in writing, software * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* distributed under the License is distributed on an "AS IS" BASIS, * or implied. See the License for the specific language governing permissions and limitations under
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * the License.
* See the License for the specific language governing permissions and
* limitations under the License.
* *
* NoDashException is the base class for no- related exceptions. * NoDashException is the base class for no- related exceptions.
*/ */
@@ -19,13 +17,13 @@
package nodash.exceptions; package nodash.exceptions;
public class NoDashException extends Exception { public class NoDashException extends Exception {
private static final long serialVersionUID = -8579497499272656543L; private static final long serialVersionUID = -8579497499272656543L;
public NoDashException() { public NoDashException() {
super(); super();
} }
public NoDashException(Exception e) { public NoDashException(Exception e) {
super(e); super(e);
} }
} }

46
src/nodash/exceptions/NoDashFatalException.java
View File

@@ -1,35 +1,33 @@
/* /*
* Copyright 2014 David Horscroft * Copyright 2014 David Horscroft
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* you may not use this file except in compliance with the License. * in compliance with the License. You may obtain a copy of the License at
* You may obtain a copy of the License at *
* * http://www.apache.org/licenses/LICENSE-2.0
* http://www.apache.org/licenses/LICENSE-2.0 *
* * Unless required by applicable law or agreed to in writing, software distributed under the License
* Unless required by applicable law or agreed to in writing, software * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* distributed under the License is distributed on an "AS IS" BASIS, * or implied. See the License for the specific language governing permissions and limitations under
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * the License.
* See the License for the specific language governing permissions and
* limitations under the License.
* *
* NoDashFatalException is the base exception for no- related runtime exceptions. * NoDashFatalException is the base exception for no- related runtime exceptions.
*/ */
package nodash.exceptions; package nodash.exceptions;
public class NoDashFatalException extends RuntimeException { public class NoDashFatalException extends RuntimeException {
private static final long serialVersionUID = -8254102569327237811L; private static final long serialVersionUID = -8254102569327237811L;
public NoDashFatalException(Exception e) { public NoDashFatalException(Exception e) {
super(e); super(e);
} }
public NoDashFatalException(String string) { public NoDashFatalException(String string) {
super(string); super(string);
} }
public NoDashFatalException(String string, Exception e) { public NoDashFatalException(String string, Exception e) {
super(string, e); super(string, e);
} }
} }

42
src/nodash/exceptions/NoDashSessionBadUUIDException.java
View File

@@ -1,32 +1,30 @@
/* /*
* Copyright 2014 David Horscroft * Copyright 2014 David Horscroft
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* *
* NoDashSessionBadUUIDException is triggered when the NoSessionSphere is * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* unable to find a valid session for the provided UUID. * in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*
* NoDashSessionBadUUIDException is triggered when the NoSessionSphere is unable to find a valid
* session for the provided UUID.
*/ */
package nodash.exceptions; package nodash.exceptions;
public class NoDashSessionBadUUIDException extends Exception { public class NoDashSessionBadUUIDException extends Exception {
private static final long serialVersionUID = -402131397575158344L; private static final long serialVersionUID = -402131397575158344L;
public NoDashSessionBadUUIDException() { public NoDashSessionBadUUIDException() {
super(); super();
} }
public NoDashSessionBadUUIDException(Exception e) { public NoDashSessionBadUUIDException(Exception e) {
super(e); super(e);
} }
} }

29
src/nodash/exceptions/NoSessionAlreadyAwaitingConfirmationException.java
View File

@@ -1,25 +1,22 @@
/* /*
* Copyright 2014 David Horscroft * Copyright 2014 David Horscroft
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* *
* NoSessionAlreadyAWaitingConfirmationException is triggered when a * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* save request is attempted for a session, but it is already awaiting * in compliance with the License. You may obtain a copy of the License at
* a confirmation upload. *
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*
* NoSessionAlreadyAWaitingConfirmationException is triggered when a save request is attempted for a
* session, but it is already awaiting a confirmation upload.
*/ */
package nodash.exceptions; package nodash.exceptions;
public class NoSessionAlreadyAwaitingConfirmationException extends NoDashException { public class NoSessionAlreadyAwaitingConfirmationException extends NoDashException {
private static final long serialVersionUID = 6046203718016296554L; private static final long serialVersionUID = 6046203718016296554L;
} }

28
src/nodash/exceptions/NoSessionConfirmedException.java
View File

@@ -1,24 +1,22 @@
/* /*
* Copyright 2014 David Horscroft * Copyright 2014 David Horscroft
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* *
* NoSessionConfirmedException is triggered when an interaction attempt is * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* made on a session that has recently been confirmed and thus closed. * in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*
* NoSessionConfirmedException is triggered when an interaction attempt is made on a session that
* has recently been confirmed and thus closed.
*/ */
package nodash.exceptions; package nodash.exceptions;
public class NoSessionConfirmedException extends NoDashException { public class NoSessionConfirmedException extends NoDashException {
private static final long serialVersionUID = -8065331145629402524L; private static final long serialVersionUID = -8065331145629402524L;
} }

27
src/nodash/exceptions/NoSessionExpiredException.java
View File

@@ -1,24 +1,21 @@
/* /*
* Copyright 2014 David Horscroft * Copyright 2014 David Horscroft
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* *
* NoSessionExpiredException is thrown when an interaction is attempted with * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* an expired session. * in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*
* NoSessionExpiredException is thrown when an interaction is attempted with an expired session.
*/ */
package nodash.exceptions; package nodash.exceptions;
public class NoSessionExpiredException extends NoDashException { public class NoSessionExpiredException extends NoDashException {
private static final long serialVersionUID = -541733773743173644L; private static final long serialVersionUID = -541733773743173644L;
} }

29
src/nodash/exceptions/NoSessionNotAwaitingConfirmationException.java
View File

@@ -1,25 +1,22 @@
/* /*
* Copyright 2014 David Horscroft * Copyright 2014 David Horscroft
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* *
* NoSessionNotAwaitingConfirmationException is thrown when an attempt is made * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* to confirm a session with a password/byte[] combination, but the session is * in compliance with the License. You may obtain a copy of the License at
* not currently awaiting a confirmation. *
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*
* NoSessionNotAwaitingConfirmationException is thrown when an attempt is made to confirm a session
* with a password/byte[] combination, but the session is not currently awaiting a confirmation.
*/ */
package nodash.exceptions; package nodash.exceptions;
public class NoSessionNotAwaitingConfirmationException extends NoDashException { public class NoSessionNotAwaitingConfirmationException extends NoDashException {
private static final long serialVersionUID = -2563955621281305198L; private static final long serialVersionUID = -2563955621281305198L;
} }

28
src/nodash/exceptions/NoSessionNotChangedException.java
View File

@@ -1,24 +1,22 @@
/* /*
* Copyright 2014 David Horscroft * Copyright 2014 David Horscroft
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* *
* NoSessionNotChangedException is thrown when a save is requested for a session * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* whilst the user object remains unchanged. * in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*
* NoSessionNotChangedException is thrown when a save is requested for a session whilst the user
* object remains unchanged.
*/ */
package nodash.exceptions; package nodash.exceptions;
public class NoSessionNotChangedException extends NoDashException { public class NoSessionNotChangedException extends NoDashException {
private static final long serialVersionUID = 8049751796255114602L; private static final long serialVersionUID = 8049751796255114602L;
} }

30
src/nodash/exceptions/NoUserAlreadyOnlineException.java
View File

@@ -1,25 +1,23 @@
/* /*
* Copyright 2014 David Horscroft * Copyright 2014 David Horscroft
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* *
* NoUserAlreadyOnlineException is thrown when a login attempt is made for * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* a user who is currently online. * in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*
* NoUserAlreadyOnlineException is thrown when a login attempt is made for a user who is currently
* online.
*/ */
package nodash.exceptions; package nodash.exceptions;
public class NoUserAlreadyOnlineException extends NoDashException { public class NoUserAlreadyOnlineException extends NoDashException {
private static final long serialVersionUID = -2922060333175653034L; private static final long serialVersionUID = -2922060333175653034L;
} }

27
src/nodash/exceptions/NoUserNotValidException.java
View File

@@ -1,24 +1,21 @@
/* /*
* Copyright 2014 David Horscroft * Copyright 2014 David Horscroft
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* *
* NoUserNotValidException is thrown when a user file does not hash to a known * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* hash. * in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*
* NoUserNotValidException is thrown when a user file does not hash to a known hash.
*/ */
package nodash.exceptions; package nodash.exceptions;
public class NoUserNotValidException extends NoDashException { public class NoUserNotValidException extends NoDashException {
private static final long serialVersionUID = -6432604940919299965L; private static final long serialVersionUID = -6432604940919299965L;
} }

37
src/nodash/models/NoAction.java
View File

@@ -1,20 +1,18 @@
/* /*
* Copyright 2014 David Horscroft * Copyright 2014 David Horscroft
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* *
* NoAction is an abstract class to allow for the inheritance of actions which * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* users can queue before confirmation (user-to-user and user-to-server). * in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*
* NoAction is an abstract class to allow for the inheritance of actions which users can queue
* before confirmation (user-to-user and user-to-server).
*/ */
package nodash.models; package nodash.models;
@@ -22,8 +20,11 @@ package nodash.models;
import java.io.Serializable; import java.io.Serializable;
public abstract class NoAction implements Serializable { public abstract class NoAction implements Serializable {
private static final long serialVersionUID = -194752850197321803L; private static final long serialVersionUID = -194752850197321803L;
public abstract void process();
public abstract void execute(); public abstract void process();
public abstract void purge();
public abstract void execute();
public abstract void purge();
} }

44
src/nodash/models/NoByteSet.java
View File

@@ -1,31 +1,29 @@
/* /*
* Copyright 2014 David Horscroft * Copyright 2014 David Horscroft
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* *
* NoByteSet stores an AES key which has been RSA-4096 encrypted and a data * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* stream which has been encrypted by this key. * in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*
* NoByteSet stores an AES key which has been RSA-4096 encrypted and a data stream which has been
* encrypted by this key.
*/ */
package nodash.models; package nodash.models;
public final class NoByteSet { public final class NoByteSet {
public byte[] key; public byte[] key;
public byte[] data; public byte[] data;
public NoByteSet(byte[] key, byte[] data) { public NoByteSet(byte[] key, byte[] data) {
this.key = key; this.key = key;
this.data = data; this.data = data;
} }
} }

127
src/nodash/models/NoInfluence.java
View File

@@ -1,22 +1,20 @@
/* /*
* Copyright 2014 David Horscroft * Copyright 2014 David Horscroft
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* *
* NoInfluence is an abstract class allowing for the subclassing of user * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* influences, generated by both actions and the server. Upon login, the user * in compliance with the License. You may obtain a copy of the License at
* consumes NoByteSets (generated by .getByteSet()) into the primary NoInfluence, *
* which is then applied to the user with .applyTo(NoUser). * http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*
* NoInfluence is an abstract class allowing for the subclassing of user influences, generated by
* both actions and the server. Upon login, the user consumes NoByteSets (generated by
* .getByteSet()) into the primary NoInfluence, which is then applied to the user with
* .applyTo(NoUser).
* *
* Examples include incoming messages, financial changes or charges or updates. * Examples include incoming messages, financial changes or charges or updates.
*/ */
@@ -40,53 +38,54 @@ import javax.crypto.SecretKey;
import nodash.core.NoUtil; import nodash.core.NoUtil;
import nodash.exceptions.NoDashFatalException; import nodash.exceptions.NoDashFatalException;
public abstract class NoInfluence implements Serializable { public abstract class NoInfluence implements Serializable {
private static final long serialVersionUID = -7509462039664862920L; private static final long serialVersionUID = -7509462039664862920L;
public abstract void applyTo(NoUser user);
public final NoByteSet getByteSet(PublicKey publicKey) {
KeyGenerator keyGen;
try {
keyGen = KeyGenerator.getInstance(NoUtil.CIPHER_KEY_SPEC);
} catch (NoSuchAlgorithmException e) {
throw new NoDashFatalException("Value for CIPHER_KEY_SPEC is not valid.", e);
}
keyGen.init(NoUtil.AES_STRENGTH);
SecretKey secretKey = keyGen.generateKey();
byte[] key = secretKey.getEncoded();
byte[] encryptedKey = NoUtil.encryptRSA(key, publicKey);
byte[] data = this.getEncrypted(key);
NoUtil.wipeBytes(key);
return new NoByteSet(encryptedKey, data);
}
private final byte[] getEncrypted(byte[] key) {
try {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(this);
byte[] encrypted = NoUtil.encrypt(baos.toByteArray(), key);
oos.close();
baos.close();
return encrypted;
} catch (IOException e) {
throw new NoDashFatalException("Unable to write NoInfluence object to byte stream.", e);
}
}
public static NoInfluence decrypt(byte[] data, byte[] key) throws IllegalBlockSizeException,
BadPaddingException, ClassNotFoundException {
byte[] decrypted = NoUtil.decrypt(data, key);
ByteArrayInputStream bais = new ByteArrayInputStream(decrypted);
try {
ObjectInputStream ois = new ObjectInputStream(bais);
NoInfluence noInfluence = (NoInfluence) ois.readObject();
ois.close();
bais.close();
return noInfluence;
} catch (IOException e) {
throw new NoDashFatalException("Unable to read out provided data stream.", e);
}
}
public abstract void applyTo(NoUser user);
public final NoByteSet getByteSet(PublicKey publicKey) {
KeyGenerator keyGen;
try {
keyGen = KeyGenerator.getInstance(NoUtil.CIPHER_KEY_SPEC);
} catch (NoSuchAlgorithmException e) {
throw new NoDashFatalException("Value for CIPHER_KEY_SPEC is not valid.", e);
}
keyGen.init(NoUtil.AES_STRENGTH);
SecretKey secretKey = keyGen.generateKey();
byte[] key = secretKey.getEncoded();
byte[] encryptedKey = NoUtil.encryptRSA(key, publicKey);
byte[] data = this.getEncrypted(key);
NoUtil.wipeBytes(key);
return new NoByteSet(encryptedKey, data);
}
private final byte[] getEncrypted(byte[] key) {
try {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(this);
byte[] encrypted = NoUtil.encrypt(baos.toByteArray(), key);
oos.close();
baos.close();
return encrypted;
} catch (IOException e) {
throw new NoDashFatalException("Unable to write NoInfluence object to byte stream.", e);
}
}
public static NoInfluence decrypt(byte[] data, byte[] key) throws IllegalBlockSizeException, BadPaddingException, ClassNotFoundException {
byte[] decrypted = NoUtil.decrypt(data, key);
ByteArrayInputStream bais = new ByteArrayInputStream(decrypted);
try {
ObjectInputStream ois = new ObjectInputStream(bais);
NoInfluence noInfluence = (NoInfluence) ois.readObject();
ois.close();
bais.close();
return noInfluence;
} catch (IOException e) {
throw new NoDashFatalException("Unable to read out provided data stream.", e);
}
}
} }

408
src/nodash/models/NoSession.java
View File

@@ -21,208 +21,212 @@ import nodash.exceptions.NoSessionNotAwaitingConfirmationException;
import nodash.exceptions.NoUserNotValidException; import nodash.exceptions.NoUserNotValidException;
public final class NoSession implements Serializable { public final class NoSession implements Serializable {
private static final long serialVersionUID = 1814807373427948931L; private static final long serialVersionUID = 1814807373427948931L;
public static final long SESSION_DURATION = 1000 * 60 * 30; //30 minute sessions
public static enum NoState {
IDLE, MODIFIED, AWAITING_CONFIRMATION, CONFIRMED, CLOSED;
};
private NoUser original;
private NoState state;
private final long expiry;
private boolean newUserSession;
public ArrayList<NoByteSet> incoming;
public NoUser current;
public UUID uuid;
public NoSession() {
this.state = NoState.IDLE;
this.expiry = System.currentTimeMillis() + NoSession.SESSION_DURATION;
this.uuid = UUID.randomUUID();
}
public NoSession(NoUser newUser) {
this();
this.state = NoState.MODIFIED;
this.original = null;
this.current = newUser;
this.newUserSession = true;
}
public NoSession(byte[] data, char[] password) throws NoUserNotValidException {
this();
this.newUserSession = false;
this.state = NoState.IDLE;
char[] passwordDupe = password.clone();
try {
this.original = NoUser.createUserFromFile(data, password);
if (NoCore.hashSphere.checkHash(this.original.createHashString())) {
this.current = NoUser.createUserFromFile(data, passwordDupe);
this.uuid = UUID.randomUUID();
NoUtil.wipeBytes(data);
} else {
throw new NoUserNotValidException();
}
} catch (IOException e) {
throw new NoUserNotValidException();
} catch (IllegalBlockSizeException e) {
throw new NoUserNotValidException();
} catch (BadPaddingException e) {
throw new NoUserNotValidException();
} catch (ClassNotFoundException e) {
throw new NoUserNotValidException();
}
}
public void check() throws NoSessionConfirmedException, NoSessionExpiredException {
if (this.state == NoState.CONFIRMED) {
throw new NoSessionConfirmedException();
} else if (this.state == NoState.CLOSED || System.currentTimeMillis() > this.expiry) {
this.state = NoState.CLOSED;
throw new NoSessionExpiredException();
}
}
public NoState touchState() throws NoSessionConfirmedException, NoSessionExpiredException {
this.check();
if (this.newUserSession) {
if (this.state != NoState.AWAITING_CONFIRMATION) {
this.state = NoState.MODIFIED;
}
} else {
String originalHash = this.original.createHashString();
String currentHash = this.current.createHashString();
if (originalHash.equals(currentHash)) {
this.state = NoState.IDLE;
} else if (this.state != NoState.AWAITING_CONFIRMATION) {
this.state = NoState.MODIFIED;
}
}
return this.state;
}
public byte[] initiateSaveAttempt(char[] password) throws NoSessionConfirmedException, NoSessionExpiredException {
this.touchState();
this.state = NoState.AWAITING_CONFIRMATION;
byte[] file = this.current.createFile(password);
NoUtil.wipeChars(password);
return file;
}
public void confirmSave(byte[] confirmData, char[] password) throws NoSessionConfirmedException, NoSessionExpiredException,
NoSessionNotAwaitingConfirmationException, NoUserNotValidException {
this.check();
if (this.state != NoState.AWAITING_CONFIRMATION) {
throw new NoSessionNotAwaitingConfirmationException();
}
NoUser confirmed;
try {
confirmed = NoUser.createUserFromFile(confirmData, password);
} catch (IOException e) {
throw new NoUserNotValidException();
} catch (IllegalBlockSizeException e) {
throw new NoUserNotValidException();
} catch (BadPaddingException e) {
throw new NoUserNotValidException();
} catch (ClassNotFoundException e) {
throw new NoUserNotValidException();
}
NoUtil.wipeBytes(confirmData);
NoUtil.wipeChars(password);
if (confirmed.createHashString().equals(this.current.createHashString())) {
this.state = NoState.CONFIRMED;
/* 5.2: confirmed! */
if (!this.newUserSession) {
/* 5.2.1: remove old hash from array */
try {
NoCore.hashSphere.removeHash(this.original.createHashString());
} catch (IOException e) {
throw new NoDashFatalException("Unable to remove hash on confirm.", e);
}
}
/* 5.2.2: add new hash to array */
try {
NoCore.hashSphere.insertHash(this.current.createHashString());
} catch (IOException e) {
throw new NoDashFatalException("Unable to remove hash on confirm.", e);
}
/* 5.2.3: clear influences as they will not need to be re-applied */
ArrayList<NoAction> actions = this.current.getNoActions();
this.incoming = null;
this.original = null;
this.current = null;
/* 5.2.4: execute NoActions */
for (NoAction action : actions) {
/* It is assumed that actions are not long-running tasks
* It is also assumed that actions have the information they need without the user objects */
action.execute();
action.purge();
}
} else {
throw new NoUserNotValidException();
}
}
public NoState getNoState() throws NoSessionConfirmedException, NoSessionExpiredException {
this.touchState();
return this.state;
}
public NoUser getNoUser() throws NoSessionConfirmedException, NoSessionExpiredException {
this.check();
return this.current;
}
public UUID getUUID() {
return this.uuid;
}
public String getUUIDAsString() {
return this.uuid.toString();
}
public byte[] getEncryptedUUID() {
return NoUtil.encrypt(Base64.encodeBase64(this.uuid.toString().getBytes()));
}
public String getEncryptedUUIDAsString() {
return new String(this.getEncryptedUUID());
}
public byte[] getOriginalHash() { public static final long SESSION_DURATION = 1000 * 60 * 30; // 30 minute sessions
if (this.original != null) {
return this.original.createHash();
} else {
return null;
}
}
public static UUID decryptUUID(byte[] data) throws NoDashSessionBadUUIDException {
if (data == null) {
throw new NoDashSessionBadUUIDException();
}
try {
return UUID.fromString(new String(Base64.decodeBase64(NoUtil.decrypt(data))));
} catch (IllegalArgumentException e) {
throw new NoDashSessionBadUUIDException();
}catch (IllegalBlockSizeException e) {
throw new NoDashSessionBadUUIDException();
} catch (BadPaddingException e) {
throw new NoDashSessionBadUUIDException();
}
}
public void consume(NoByteSet byteSet) throws NoByteSetBadDecryptionException { public static enum NoState {
this.current.consume(byteSet); IDLE, MODIFIED, AWAITING_CONFIRMATION, CONFIRMED, CLOSED;
} };
public void close() { private NoUser original;
this.state = NoState.CLOSED; private NoState state;
} private final long expiry;
private boolean newUserSession;
public ArrayList<NoByteSet> incoming;
public NoUser current;
public UUID uuid;
public NoSession() {
this.state = NoState.IDLE;
this.expiry = System.currentTimeMillis() + NoSession.SESSION_DURATION;
this.uuid = UUID.randomUUID();
}
public NoSession(NoUser newUser) {
this();
this.state = NoState.MODIFIED;
this.original = null;
this.current = newUser;
this.newUserSession = true;
}
public NoSession(byte[] data, char[] password) throws NoUserNotValidException {
this();
this.newUserSession = false;
this.state = NoState.IDLE;
char[] passwordDupe = password.clone();
try {
this.original = NoUser.createUserFromFile(data, password);
if (NoCore.hashSphere.checkHash(this.original.createHashString())) {
this.current = NoUser.createUserFromFile(data, passwordDupe);
this.uuid = UUID.randomUUID();
NoUtil.wipeBytes(data);
} else {
throw new NoUserNotValidException();
}
} catch (IOException e) {
throw new NoUserNotValidException();
} catch (IllegalBlockSizeException e) {
throw new NoUserNotValidException();
} catch (BadPaddingException e) {
throw new NoUserNotValidException();
} catch (ClassNotFoundException e) {
throw new NoUserNotValidException();
}
}
public void check() throws NoSessionConfirmedException, NoSessionExpiredException {
if (this.state == NoState.CONFIRMED) {
throw new NoSessionConfirmedException();
} else if (this.state == NoState.CLOSED || System.currentTimeMillis() > this.expiry) {
this.state = NoState.CLOSED;
throw new NoSessionExpiredException();
}
}
public NoState touchState() throws NoSessionConfirmedException, NoSessionExpiredException {
this.check();
if (this.newUserSession) {
if (this.state != NoState.AWAITING_CONFIRMATION) {
this.state = NoState.MODIFIED;
}
} else {
String originalHash = this.original.createHashString();
String currentHash = this.current.createHashString();
if (originalHash.equals(currentHash)) {
this.state = NoState.IDLE;
} else if (this.state != NoState.AWAITING_CONFIRMATION) {
this.state = NoState.MODIFIED;
}
}
return this.state;
}
public byte[] initiateSaveAttempt(char[] password) throws NoSessionConfirmedException,
NoSessionExpiredException {
this.touchState();
this.state = NoState.AWAITING_CONFIRMATION;
byte[] file = this.current.createFile(password);
NoUtil.wipeChars(password);
return file;
}
public void confirmSave(byte[] confirmData, char[] password) throws NoSessionConfirmedException,
NoSessionExpiredException, NoSessionNotAwaitingConfirmationException, NoUserNotValidException {
this.check();
if (this.state != NoState.AWAITING_CONFIRMATION) {
throw new NoSessionNotAwaitingConfirmationException();
}
NoUser confirmed;
try {
confirmed = NoUser.createUserFromFile(confirmData, password);
} catch (IOException e) {
throw new NoUserNotValidException();
} catch (IllegalBlockSizeException e) {
throw new NoUserNotValidException();
} catch (BadPaddingException e) {
throw new NoUserNotValidException();
} catch (ClassNotFoundException e) {
throw new NoUserNotValidException();
}
NoUtil.wipeBytes(confirmData);
NoUtil.wipeChars(password);
if (confirmed.createHashString().equals(this.current.createHashString())) {
this.state = NoState.CONFIRMED;
/* 5.2: confirmed! */
if (!this.newUserSession) {
/* 5.2.1: remove old hash from array */
try {
NoCore.hashSphere.removeHash(this.original.createHashString());
} catch (IOException e) {
throw new NoDashFatalException("Unable to remove hash on confirm.", e);
}
}
/* 5.2.2: add new hash to array */
try {
NoCore.hashSphere.insertHash(this.current.createHashString());
} catch (IOException e) {
throw new NoDashFatalException("Unable to remove hash on confirm.", e);
}
/* 5.2.3: clear influences as they will not need to be re-applied */
ArrayList<NoAction> actions = this.current.getNoActions();
this.incoming = null;
this.original = null;
this.current = null;
/* 5.2.4: execute NoActions */
for (NoAction action : actions) {
/*
* It is assumed that actions are not long-running tasks It is also assumed that actions
* have the information they need without the user objects
*/
action.execute();
action.purge();
}
} else {
throw new NoUserNotValidException();
}
}
public NoState getNoState() throws NoSessionConfirmedException, NoSessionExpiredException {
this.touchState();
return this.state;
}
public NoUser getNoUser() throws NoSessionConfirmedException, NoSessionExpiredException {
this.check();
return this.current;
}
public UUID getUUID() {
return this.uuid;
}
public String getUUIDAsString() {
return this.uuid.toString();
}
public byte[] getEncryptedUUID() {
return NoUtil.encrypt(Base64.encodeBase64(this.uuid.toString().getBytes()));
}
public String getEncryptedUUIDAsString() {
return new String(this.getEncryptedUUID());
}
public byte[] getOriginalHash() {
if (this.original != null) {
return this.original.createHash();
} else {
return null;
}
}
public static UUID decryptUUID(byte[] data) throws NoDashSessionBadUUIDException {
if (data == null) {
throw new NoDashSessionBadUUIDException();
}
try {
return UUID.fromString(new String(Base64.decodeBase64(NoUtil.decrypt(data))));
} catch (IllegalArgumentException e) {
throw new NoDashSessionBadUUIDException();
} catch (IllegalBlockSizeException e) {
throw new NoDashSessionBadUUIDException();
} catch (BadPaddingException e) {
throw new NoDashSessionBadUUIDException();
}
}
public void consume(NoByteSet byteSet) throws NoByteSetBadDecryptionException {
this.current.consume(byteSet);
}
public void close() {
this.state = NoState.CLOSED;
}
} }

314
src/nodash/models/NoUser.java
View File

@@ -1,21 +1,19 @@
/* /*
* Copyright 2014 David Horscroft * Copyright 2014 David Horscroft
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* *
* NoUser allows the subclassing of custom user objects whilst keeping the * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* core requirements of a NoUser: the public and private keys. It also supports * in compliance with the License. You may obtain a copy of the License at
* the serialization, decryption and NoByteSet consumption. *
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*
* NoUser allows the subclassing of custom user objects whilst keeping the core requirements of a
* NoUser: the public and private keys. It also supports the serialization, decryption and NoByteSet
* consumption.
*/ */
package nodash.models; package nodash.models;
@@ -48,148 +46,152 @@ import nodash.exceptions.NoByteSetBadDecryptionException;
import nodash.exceptions.NoDashFatalException; import nodash.exceptions.NoDashFatalException;
public class NoUser implements Serializable { public class NoUser implements Serializable {
private static final long serialVersionUID = 7132405837081692211L; private static final long serialVersionUID = 7132405837081692211L;
private PublicKey publicKey; private PublicKey publicKey;
private PrivateKey privateKey; private PrivateKey privateKey;
@SuppressWarnings("unused") @SuppressWarnings("unused")
private String randomized; private String randomized;
public int influences;
public int actions;
private ArrayList<NoAction> outgoing = new ArrayList<NoAction>();
public NoUser() {
KeyPairGenerator kpg;
try {
kpg = KeyPairGenerator.getInstance(NoUtil.KEYPAIR_ALGORITHM);
} catch (NoSuchAlgorithmException e) {
throw new NoDashFatalException("Value for KEYPAIR_ALGORITHM is not valid.", e);
}
try { public int influences;
kpg.initialize(NoUtil.RSA_STRENGTH, SecureRandom.getInstance(NoUtil.SECURERANDOM_ALGORITHM, NoUtil.SECURERANDOM_PROVIDER)); public int actions;
} catch (NoSuchAlgorithmException e) {
throw new NoDashFatalException("Value for SECURERANDOM_ALGORITHM not valid.", e);
} catch (NoSuchProviderException e) {
throw new NoDashFatalException("Value for SECURERANDOM_PROVIDER not valid.", e);
}
KeyPair keyPair = kpg.generateKeyPair();
this.publicKey = keyPair.getPublic();
this.privateKey = keyPair.getPrivate();
this.influences = 0;
this.actions = 0;
this.touchRandomizer();
}
private void touchRandomizer() {
byte[] randomBytes = new byte[64];
try {
SecureRandom.getInstance(NoUtil.SECURERANDOM_ALGORITHM).nextBytes(randomBytes);
} catch (NoSuchAlgorithmException e) {
throw new NoDashFatalException("Value for SECURERANDOM_ALGORITHM not valid.", e);
}
this.randomized = new String(randomBytes);
}
public final byte[] createFile(char[] password) { private ArrayList<NoAction> outgoing = new ArrayList<NoAction>();
ArrayList<NoAction> temp = this.outgoing;
try {
this.touchRandomizer();
this.outgoing = new ArrayList<NoAction>();
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(this);
byte[] encrypted = NoUtil.encrypt(baos.toByteArray(), password);
oos.close();
baos.close();
return encrypted;
} catch (IOException e) {
throw new NoDashFatalException("IO Exception encountered while generating encrypted user file byte stream.", e);
} finally {
this.outgoing = temp;
}
}
public final byte[] createHash() {
ArrayList<NoAction> temp = this.outgoing;
try {
this.outgoing = new ArrayList<NoAction>();
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(this);
byte[] userBytes = baos.toByteArray();
return NoUtil.getHashFromByteArray(userBytes);
} catch (IOException e) {
throw new NoDashFatalException("IO Exception encountered while generating user hash.", e);
} finally {
this.outgoing = temp;
}
}
public final String createHashString() {
return new String(this.createHash());
}
public final void consume(NoByteSet byteSet) throws NoByteSetBadDecryptionException { public NoUser() {
try { KeyPairGenerator kpg;
SecretKey secretKey = new SecretKeySpec(decryptRSA(byteSet.key), NoUtil.CIPHER_KEY_SPEC); try {
byte[] key = secretKey.getEncoded(); kpg = KeyPairGenerator.getInstance(NoUtil.KEYPAIR_ALGORITHM);
secretKey = null; } catch (NoSuchAlgorithmException e) {
NoInfluence influence = NoInfluence.decrypt(byteSet.data, key); throw new NoDashFatalException("Value for KEYPAIR_ALGORITHM is not valid.", e);
NoUtil.wipeBytes(key); }
influence.applyTo(this);
this.influences++;
} catch (BadPaddingException e) {
throw new NoByteSetBadDecryptionException(e);
} catch (IllegalBlockSizeException e) {
throw new NoByteSetBadDecryptionException(e);
} catch (ClassNotFoundException e) {
throw new NoByteSetBadDecryptionException(e);
} catch (InvalidKeyException e) {
throw new NoByteSetBadDecryptionException(e);
}
}
public final void addAction(NoAction action) {
this.outgoing.add(action);
this.actions++;
}
public final ArrayList<NoAction> getNoActions() { try {
return this.outgoing; kpg.initialize(NoUtil.RSA_STRENGTH,
} SecureRandom.getInstance(NoUtil.SECURERANDOM_ALGORITHM, NoUtil.SECURERANDOM_PROVIDER));
} catch (NoSuchAlgorithmException e) {
public final BigInteger getPublicExponent() { throw new NoDashFatalException("Value for SECURERANDOM_ALGORITHM not valid.", e);
return ((RSAPublicKeyImpl) publicKey).getPublicExponent(); } catch (NoSuchProviderException e) {
} throw new NoDashFatalException("Value for SECURERANDOM_PROVIDER not valid.", e);
}
public final BigInteger getModulus() {
return ((RSAPublicKeyImpl) publicKey).getModulus(); KeyPair keyPair = kpg.generateKeyPair();
} this.publicKey = keyPair.getPublic();
this.privateKey = keyPair.getPrivate();
public final PublicKey getRSAPublicKey() { this.influences = 0;
try { this.actions = 0;
return new RSAPublicKeyImpl(this.getModulus(), this.getPublicExponent()); this.touchRandomizer();
} catch (InvalidKeyException e) { }
throw new NoDashFatalException("Invalid key while re-generating a RSAPublicKey.", e);
} private void touchRandomizer() {
} byte[] randomBytes = new byte[64];
try {
private final byte[] decryptRSA(byte[] data) throws InvalidKeyException, IllegalBlockSizeException, BadPaddingException { SecureRandom.getInstance(NoUtil.SECURERANDOM_ALGORITHM).nextBytes(randomBytes);
return NoUtil.decryptRSA(data, this.privateKey); } catch (NoSuchAlgorithmException e) {
} throw new NoDashFatalException("Value for SECURERANDOM_ALGORITHM not valid.", e);
}
public static NoUser createUserFromFile(byte[] data, char[] password) throws IllegalBlockSizeException, BadPaddingException, IOException, ClassNotFoundException { this.randomized = new String(randomBytes);
byte[] decrypted = NoUtil.decrypt(data, password); }
ByteArrayInputStream bais = new ByteArrayInputStream(decrypted);
ObjectInputStream ois = new ObjectInputStream(bais); public final byte[] createFile(char[] password) {
NoUser noUser = (NoUser) ois.readObject(); ArrayList<NoAction> temp = this.outgoing;
ois.close(); try {
bais.close(); this.touchRandomizer();
return noUser; this.outgoing = new ArrayList<NoAction>();
} ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
} oos.writeObject(this);
byte[] encrypted = NoUtil.encrypt(baos.toByteArray(), password);
oos.close();
baos.close();
return encrypted;
} catch (IOException e) {
throw new NoDashFatalException(
"IO Exception encountered while generating encrypted user file byte stream.", e);
} finally {
this.outgoing = temp;
}
}
public final byte[] createHash() {
ArrayList<NoAction> temp = this.outgoing;
try {
this.outgoing = new ArrayList<NoAction>();
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(this);
byte[] userBytes = baos.toByteArray();
return NoUtil.getHashFromByteArray(userBytes);
} catch (IOException e) {
throw new NoDashFatalException("IO Exception encountered while generating user hash.", e);
} finally {
this.outgoing = temp;
}
}
public final String createHashString() {
return new String(this.createHash());
}
public final void consume(NoByteSet byteSet) throws NoByteSetBadDecryptionException {
try {
SecretKey secretKey = new SecretKeySpec(decryptRSA(byteSet.key), NoUtil.CIPHER_KEY_SPEC);
byte[] key = secretKey.getEncoded();
secretKey = null;
NoInfluence influence = NoInfluence.decrypt(byteSet.data, key);
NoUtil.wipeBytes(key);
influence.applyTo(this);
this.influences++;
} catch (BadPaddingException e) {
throw new NoByteSetBadDecryptionException(e);
} catch (IllegalBlockSizeException e) {
throw new NoByteSetBadDecryptionException(e);
} catch (ClassNotFoundException e) {
throw new NoByteSetBadDecryptionException(e);
} catch (InvalidKeyException e) {
throw new NoByteSetBadDecryptionException(e);
}
}
public final void addAction(NoAction action) {
this.outgoing.add(action);
this.actions++;
}
public final ArrayList<NoAction> getNoActions() {
return this.outgoing;
}
public final BigInteger getPublicExponent() {
return ((RSAPublicKeyImpl) publicKey).getPublicExponent();
}
public final BigInteger getModulus() {
return ((RSAPublicKeyImpl) publicKey).getModulus();
}
public final PublicKey getRSAPublicKey() {
try {
return new RSAPublicKeyImpl(this.getModulus(), this.getPublicExponent());
} catch (InvalidKeyException e) {
throw new NoDashFatalException("Invalid key while re-generating a RSAPublicKey.", e);
}
}
private final byte[] decryptRSA(byte[] data) throws InvalidKeyException,
IllegalBlockSizeException, BadPaddingException {
return NoUtil.decryptRSA(data, this.privateKey);
}
public static NoUser createUserFromFile(byte[] data, char[] password)
throws IllegalBlockSizeException, BadPaddingException, IOException, ClassNotFoundException {
byte[] decrypted = NoUtil.decrypt(data, password);
ByteArrayInputStream bais = new ByteArrayInputStream(decrypted);
ObjectInputStream ois = new ObjectInputStream(bais);
NoUser noUser = (NoUser) ois.readObject();
ois.close();
bais.close();
return noUser;
}
}

75
src/nodash/models/noactiontypes/NoErrorableAction.java
View File

@@ -1,25 +1,22 @@
/* /*
* Copyright 2014 David Horscroft * Copyright 2014 David Horscroft
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* *
* NoErrorableAction is a subclassing of NoTargetedAction for user-server * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* interactions that require an error to be returned if a * in compliance with the License. You may obtain a copy of the License at
* NoCannotGetInfluenceException is thrown. The target is not a destination user,
* but is instead treated as the source.
* *
* As with all sourced actions it is advised to avoid their use unless the logic * http://www.apache.org/licenses/LICENSE-2.0
* demands it, as it establishes a connection between a server action and a user address. *
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*
* NoErrorableAction is a subclassing of NoTargetedAction for user-server interactions that require
* an error to be returned if a NoCannotGetInfluenceException is thrown. The target is not a
* destination user, but is instead treated as the source.
*
* As with all sourced actions it is advised to avoid their use unless the logic demands it, as it
* establishes a connection between a server action and a user address.
*/ */
package nodash.models.noactiontypes; package nodash.models.noactiontypes;
@@ -32,27 +29,27 @@ import nodash.models.NoByteSet;
import nodash.models.NoInfluence; import nodash.models.NoInfluence;
public abstract class NoErrorableAction extends NoTargetedAction { public abstract class NoErrorableAction extends NoTargetedAction {
private static final long serialVersionUID = -6077150774349400823L; private static final long serialVersionUID = -6077150774349400823L;
public NoErrorableAction(PublicKey source) { public NoErrorableAction(PublicKey source) {
// Note that // Note that
super(source); super(source);
} }
public void execute() { public void execute() {
this.process(); this.process();
try { try {
NoInfluence influence = this.generateTargetInfluence(); NoInfluence influence = this.generateTargetInfluence();
if (influence != null) { if (influence != null) {
NoByteSet byteSet = influence.getByteSet(this.target); NoByteSet byteSet = influence.getByteSet(this.target);
NoCore.addByteSet(byteSet, this.target); NoCore.addByteSet(byteSet, this.target);
} }
} catch (NoCannotGetInfluenceException e) { } catch (NoCannotGetInfluenceException e) {
NoInfluence errorInfluence = e.getResponseInfluence(); NoInfluence errorInfluence = e.getResponseInfluence();
if (errorInfluence != null) { if (errorInfluence != null) {
NoByteSet byteSet = errorInfluence.getByteSet(this.target); NoByteSet byteSet = errorInfluence.getByteSet(this.target);
NoCore.addByteSet(byteSet, this.target); NoCore.addByteSet(byteSet, this.target);
} }
} }
} }
} }

101
src/nodash/models/noactiontypes/NoHandshakeAction.java
View File

@@ -1,25 +1,22 @@
/* /*
* Copyright 2014 David Horscroft * Copyright 2014 David Horscroft
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* *
* NoHandshakeAction is a subclass of the NoSourcedAction with logic to * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* generate an applying influence as well as a returned influence, whilst * in compliance with the License. You may obtain a copy of the License at
* also being capable of returned an error influence if the
* NoCannotGetInfluenceException is thrown.
* *
* As with all two-way or sourced actions, their use should be sparing as * http://www.apache.org/licenses/LICENSE-2.0
* it establishes a connection between two user addresses. *
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*
* NoHandshakeAction is a subclass of the NoSourcedAction with logic to generate an applying
* influence as well as a returned influence, whilst also being capable of returned an error
* influence if the NoCannotGetInfluenceException is thrown.
*
* As with all two-way or sourced actions, their use should be sparing as it establishes a
* connection between two user addresses.
*/ */
package nodash.models.noactiontypes; package nodash.models.noactiontypes;
@@ -31,39 +28,39 @@ import nodash.exceptions.NoCannotGetInfluenceException;
import nodash.models.NoByteSet; import nodash.models.NoByteSet;
import nodash.models.NoInfluence; import nodash.models.NoInfluence;
public abstract class NoHandshakeAction extends NoSourcedAction { public abstract class NoHandshakeAction extends NoSourcedAction {
private static final long serialVersionUID = 3195466136587475680L; private static final long serialVersionUID = 3195466136587475680L;
protected abstract NoInfluence generateReturnedInfluence(); protected abstract NoInfluence generateReturnedInfluence();
public NoHandshakeAction(PublicKey target, PublicKey source) { public NoHandshakeAction(PublicKey target, PublicKey source) {
super(target, source); super(target, source);
} }
public void execute() { public void execute() {
this.process(); this.process();
try { try {
NoInfluence influence = this.generateTargetInfluence(); NoInfluence influence = this.generateTargetInfluence();
if (influence != null) { if (influence != null) {
NoByteSet byteSet = influence.getByteSet(this.target); NoByteSet byteSet = influence.getByteSet(this.target);
NoCore.addByteSet(byteSet, this.target); NoCore.addByteSet(byteSet, this.target);
} }
NoInfluence result = this.generateReturnedInfluence(); NoInfluence result = this.generateReturnedInfluence();
if (result != null) { if (result != null) {
NoByteSet byteSet = result.getByteSet(this.source); NoByteSet byteSet = result.getByteSet(this.source);
NoCore.addByteSet(byteSet, this.source); NoCore.addByteSet(byteSet, this.source);
} }
} catch (NoCannotGetInfluenceException e) { } catch (NoCannotGetInfluenceException e) {
NoInfluence errorInfluence = e.getResponseInfluence(); NoInfluence errorInfluence = e.getResponseInfluence();
if (errorInfluence != null) { if (errorInfluence != null) {
NoByteSet byteSet = errorInfluence.getByteSet(this.source); NoByteSet byteSet = errorInfluence.getByteSet(this.source);
NoCore.addByteSet(byteSet, this.source); NoCore.addByteSet(byteSet, this.source);
} }
} }
} }
public void purge() { public void purge() {
super.purge(); super.purge();
} }
} }

94
src/nodash/models/noactiontypes/NoSourcedAction.java
View File

@@ -1,24 +1,21 @@
/* /*
* Copyright 2014 David Horscroft * Copyright 2014 David Horscroft
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* *
* NoSourcedAction is a subclassing of NoTargetedAction which additionally * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* has a source, allowing for errors to be returned if a NoCannotGetInfluenceException * in compliance with the License. You may obtain a copy of the License at
* is thrown.
* *
* It is not advised to make a habit of using these for all user-user interactions * http://www.apache.org/licenses/LICENSE-2.0
* as they provide a clear link between two users. *
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*
* NoSourcedAction is a subclassing of NoTargetedAction which additionally has a source, allowing
* for errors to be returned if a NoCannotGetInfluenceException is thrown.
*
* It is not advised to make a habit of using these for all user-user interactions as they provide a
* clear link between two users.
*/ */
package nodash.models.noactiontypes; package nodash.models.noactiontypes;
@@ -30,35 +27,36 @@ import nodash.exceptions.NoCannotGetInfluenceException;
import nodash.models.NoByteSet; import nodash.models.NoByteSet;
import nodash.models.NoInfluence; import nodash.models.NoInfluence;
public abstract class NoSourcedAction extends NoTargetedAction { public abstract class NoSourcedAction extends NoTargetedAction {
private static final long serialVersionUID = -2996690472537380062L; private static final long serialVersionUID = -2996690472537380062L;
protected PublicKey source; protected PublicKey source;
protected abstract NoInfluence generateTargetInfluence() throws NoCannotGetInfluenceException;
protected abstract NoInfluence generateTargetInfluence() throws NoCannotGetInfluenceException;
public NoSourcedAction(PublicKey target, PublicKey source) {
super(target); public NoSourcedAction(PublicKey target, PublicKey source) {
this.source = source; super(target);
} this.source = source;
}
public void execute() {
this.process(); public void execute() {
try { this.process();
NoInfluence influence = this.generateTargetInfluence(); try {
if (influence != null) { NoInfluence influence = this.generateTargetInfluence();
NoByteSet byteSet = influence.getByteSet(this.target); if (influence != null) {
NoCore.addByteSet(byteSet, this.target); NoByteSet byteSet = influence.getByteSet(this.target);
} NoCore.addByteSet(byteSet, this.target);
} catch (NoCannotGetInfluenceException e) { }
NoInfluence errorInfluence = e.getResponseInfluence(); } catch (NoCannotGetInfluenceException e) {
if (errorInfluence != null) { NoInfluence errorInfluence = e.getResponseInfluence();
NoByteSet byteSet = errorInfluence.getByteSet(this.source); if (errorInfluence != null) {
NoCore.addByteSet(byteSet, this.source); NoByteSet byteSet = errorInfluence.getByteSet(this.source);
} NoCore.addByteSet(byteSet, this.source);
} }
} }
}
public void purge() {
super.purge(); public void purge() {
this.source = null; super.purge();
} this.source = null;
}
} }

81
src/nodash/models/noactiontypes/NoTargetedAction.java
View File

@@ -1,20 +1,18 @@
/* /*
* Copyright 2014 David Horscroft * Copyright 2014 David Horscroft
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* *
* NoTargetedAction is an abstract subclassing of NoAction aimed at providing the * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* basis for an action that has a user target in mind. * in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*
* NoTargetedAction is an abstract subclassing of NoAction aimed at providing the basis for an
* action that has a user target in mind.
*/ */
package nodash.models.noactiontypes; package nodash.models.noactiontypes;
@@ -29,31 +27,32 @@ import nodash.models.NoByteSet;
import nodash.models.NoInfluence; import nodash.models.NoInfluence;
public abstract class NoTargetedAction extends NoAction { public abstract class NoTargetedAction extends NoAction {
private static final long serialVersionUID = -8893381130155149646L; private static final long serialVersionUID = -8893381130155149646L;
protected PublicKey target; protected PublicKey target;
protected abstract NoInfluence generateTargetInfluence() throws NoCannotGetInfluenceException; protected abstract NoInfluence generateTargetInfluence() throws NoCannotGetInfluenceException;
public NoTargetedAction(PublicKey target) { public NoTargetedAction(PublicKey target) {
this.target = target; this.target = target;
} }
public void execute() { public void execute() {
this.process(); this.process();
try { try {
NoInfluence influence = this.generateTargetInfluence(); NoInfluence influence = this.generateTargetInfluence();
if (influence != null) { if (influence != null) {
NoByteSet byteSet = influence.getByteSet(this.target); NoByteSet byteSet = influence.getByteSet(this.target);
NoCore.addByteSet(byteSet, this.target); NoCore.addByteSet(byteSet, this.target);
} }
} catch (NoCannotGetInfluenceException e) { } catch (NoCannotGetInfluenceException e) {
if (e.getResponseInfluence() != null) { if (e.getResponseInfluence() != null) {
throw new NoDashFatalException("Unsourced action has generated an error with an undeliverable influence.", e); throw new NoDashFatalException(
} "Unsourced action has generated an error with an undeliverable influence.", e);
} }
} }
}
public void purge() {
this.target = null; public void purge() {
} this.target = null;
}
} }

34
src/nodash/test/NoActionTest.java
View File

@@ -7,26 +7,26 @@ import nodash.models.NoInfluence;
import nodash.models.noactiontypes.NoTargetedAction; import nodash.models.noactiontypes.NoTargetedAction;
public class NoActionTest extends NoTargetedAction { public class NoActionTest extends NoTargetedAction {
/** /**
* *
*/ */
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
private String newName;
public NoActionTest(PublicKey target, String newName) {
super(target);
this.newName = newName;
}
@Override private String newName;
protected NoInfluence generateTargetInfluence() throws NoCannotGetInfluenceException {
return new NoInfluenceTest(newName);
}
@Override public NoActionTest(PublicKey target, String newName) {
public void process() { super(target);
// Nothing; this.newName = newName;
} }
@Override
protected NoInfluence generateTargetInfluence() throws NoCannotGetInfluenceException {
return new NoInfluenceTest(newName);
}
@Override
public void process() {
// Nothing;
}
} }

1553
src/nodash/test/NoCoreTest.java
View File

File diff suppressed because it is too large Load Diff

24
src/nodash/test/NoInfluenceTest.java
View File

@@ -4,20 +4,20 @@ import nodash.models.NoInfluence;
import nodash.models.NoUser; import nodash.models.NoUser;
public class NoInfluenceTest extends NoInfluence { public class NoInfluenceTest extends NoInfluence {
/** /**
* *
*/ */
private static final long serialVersionUID = 5710677031891178814L; private static final long serialVersionUID = 5710677031891178814L;
private String newName; private String newName;
public NoInfluenceTest(String newName) {
super();
this.newName = newName;
}
@Override public NoInfluenceTest(String newName) {
public void applyTo(NoUser user) { super();
((NoUserTest) user).setChangableString(this.newName); this.newName = newName;
} }
@Override
public void applyTo(NoUser user) {
((NoUserTest) user).setChangableString(this.newName);
}
} }

10
src/nodash/test/NoTestNotReadyException.java
View File

@@ -3,13 +3,13 @@ package nodash.test;
import nodash.exceptions.NoDashFatalException; import nodash.exceptions.NoDashFatalException;
public class NoTestNotReadyException extends NoDashFatalException { public class NoTestNotReadyException extends NoDashFatalException {
/** /**
* *
*/ */
private static final long serialVersionUID = -8955061212302042899L; private static final long serialVersionUID = -8955061212302042899L;
public NoTestNotReadyException(String string) { public NoTestNotReadyException(String string) {
super(string); super(string);
} }
} }

32
src/nodash/test/NoUserTest.java
View File

@@ -4,23 +4,23 @@ import nodash.models.NoUser;
public class NoUserTest extends NoUser { public class NoUserTest extends NoUser {
/** /**
* *
*/ */
private static final long serialVersionUID = 7791713515804652613L; private static final long serialVersionUID = 7791713515804652613L;
private String changableString; private String changableString;
public NoUserTest(String changableString) { public NoUserTest(String changableString) {
super(); super();
setChangableString(changableString); setChangableString(changableString);
} }
public String getChangableString() { public String getChangableString() {
return changableString; return changableString;
} }
public void setChangableString(String changableString) { public void setChangableString(String changableString) {
this.changableString = changableString; this.changableString = changableString;
} }
} }