Merge branch 'release/2.0.0' into release/2.1.0

overheadhunter · overheadhunter · commit dddc206b4490 · 2021-06-28T15:43:26.000+02:00
diff --git a/pom.xml b/pom.xml
@@ -18,7 +18,7 @@
 		<maven.compiler.release>16</maven.compiler.release>
 
 		<!-- dependencies -->
-		<cryptolib.version>2.0.0-rc5</cryptolib.version>
+		<cryptolib.version>2.0.0-rc6</cryptolib.version>
 		<jwt.version>3.17.0</jwt.version>
 		<dagger.version>2.37</dagger.version>
 		<guava.version>30.1.1-jre</guava.version>
diff --git a/src/main/java/org/cryptomator/cryptofs/CryptoFileSystemProperties.java b/src/main/java/org/cryptomator/cryptofs/CryptoFileSystemProperties.java
@@ -9,6 +9,7 @@
 package org.cryptomator.cryptofs;
 
 import com.google.common.base.Strings;
+import org.cryptomator.cryptolib.api.CryptorProvider;
 import org.cryptomator.cryptolib.api.MasterkeyLoader;
 
 import java.net.URI;
@@ -91,7 +92,7 @@ public enum FileSystemFlags {
 	 */
 	public static final String PROPERTY_CIPHER_COMBO = "cipherCombo";
 
-	static final VaultCipherCombo DEFAULT_CIPHER_COMBO = VaultCipherCombo.SIV_GCM;
+	static final CryptorProvider.Scheme DEFAULT_CIPHER_COMBO = CryptorProvider.Scheme.SIV_GCM;
 
 	private final Set<Entry<String, Object>> entries;
 
@@ -110,8 +111,8 @@ MasterkeyLoader keyLoader() {
 		return (MasterkeyLoader) get(PROPERTY_KEYLOADER);
 	}
 
-	public VaultCipherCombo cipherCombo() {
-		return (VaultCipherCombo) get(PROPERTY_CIPHER_COMBO);
+	public CryptorProvider.Scheme cipherCombo() {
+		return (CryptorProvider.Scheme) get(PROPERTY_CIPHER_COMBO);
 	}
 
 	@SuppressWarnings("unchecked")
@@ -183,7 +184,7 @@ public static CryptoFileSystemProperties wrap(Map<String, ?> properties) {
 	 */
 	public static class Builder {
 
-		public VaultCipherCombo cipherCombo = DEFAULT_CIPHER_COMBO;
+		public CryptorProvider.Scheme cipherCombo = DEFAULT_CIPHER_COMBO;
 		private MasterkeyLoader keyLoader = null;
 		private final Set<FileSystemFlags> flags = EnumSet.copyOf(DEFAULT_FILESYSTEM_FLAGS);
 		private String vaultConfigFilename = DEFAULT_VAULTCONFIG_FILENAME;
@@ -199,7 +200,7 @@ private Builder(Map<String, ?> properties) {
 			checkedSet(String.class, PROPERTY_MASTERKEY_FILENAME, properties, this::withMasterkeyFilename);
 			checkedSet(Set.class, PROPERTY_FILESYSTEM_FLAGS, properties, this::withFlags);
 			checkedSet(Integer.class, PROPERTY_MAX_CLEARTEXT_NAME_LENGTH, properties, this::withMaxCleartextNameLength);
-			checkedSet(VaultCipherCombo.class, PROPERTY_CIPHER_COMBO, properties, this::withCipherCombo);
+			checkedSet(CryptorProvider.Scheme.class, PROPERTY_CIPHER_COMBO, properties, this::withCipherCombo);
 		}
 
 		private <T> void checkedSet(Class<T> type, String key, Map<String, ?> properties, Consumer<T> setter) {
@@ -235,7 +236,7 @@ public Builder withMaxCleartextNameLength(int maxCleartextNameLength) {
 		 * @return this
 		 * @since 2.0.0
 		 */
-		public Builder withCipherCombo(VaultCipherCombo cipherCombo) {
+		public Builder withCipherCombo(CryptorProvider.Scheme cipherCombo) {
 			this.cipherCombo = cipherCombo;
 			return this;
 		}
diff --git a/src/main/java/org/cryptomator/cryptofs/CryptoFileSystemProvider.java b/src/main/java/org/cryptomator/cryptofs/CryptoFileSystemProvider.java
@@ -12,6 +12,7 @@
 import org.cryptomator.cryptofs.common.Constants;
 import org.cryptomator.cryptofs.common.FileSystemCapabilityChecker;
 import org.cryptomator.cryptolib.api.Cryptor;
+import org.cryptomator.cryptolib.api.CryptorProvider;
 import org.cryptomator.cryptolib.api.Masterkey;
 import org.cryptomator.cryptolib.api.MasterkeyLoadingFailedException;
 
@@ -143,7 +144,7 @@ public static void initialize(Path pathToVault, CryptoFileSystemProperties prope
 		byte[] rawKey = new byte[0];
 		var config = VaultConfig.createNew().cipherCombo(properties.cipherCombo()).shorteningThreshold(Constants.DEFAULT_SHORTENING_THRESHOLD).build();
 		try (Masterkey key = properties.keyLoader().loadKey(keyId);
-			 Cryptor cryptor = config.getCipherCombo().getCryptorProvider(strongSecureRandom()).withKey(key)) {
+			 Cryptor cryptor = CryptorProvider.forScheme(config.getCipherCombo()).provide(key, strongSecureRandom())) {
 			rawKey = key.getEncoded();
 			// save vault config:
 			Path vaultConfigPath = pathToVault.resolve(properties.vaultConfigFilename());
diff --git a/src/main/java/org/cryptomator/cryptofs/CryptoFileSystems.java b/src/main/java/org/cryptomator/cryptofs/CryptoFileSystems.java
@@ -3,6 +3,7 @@
 import org.cryptomator.cryptofs.common.Constants;
 import org.cryptomator.cryptofs.common.FileSystemCapabilityChecker;
 import org.cryptomator.cryptolib.api.Cryptor;
+import org.cryptomator.cryptolib.api.CryptorProvider;
 import org.cryptomator.cryptolib.api.Masterkey;
 import org.cryptomator.cryptolib.api.MasterkeyLoadingFailedException;
 import org.slf4j.Logger;
@@ -51,7 +52,7 @@ public CryptoFileSystemImpl create(CryptoFileSystemProvider provider, Path pathT
 		try (Masterkey key = properties.keyLoader().loadKey(keyId)) {
 			var config = configLoader.verify(key.getEncoded(), Constants.VAULT_VERSION);
 			var adjustedProperties = adjustForCapabilities(pathToVault, properties);
-			var cryptor = config.getCipherCombo().getCryptorProvider(csprng).withKey(key.clone());
+			var cryptor = CryptorProvider.forScheme(config.getCipherCombo()).provide(key.clone(), csprng);
 			try {
 				checkVaultRootExistence(pathToVault, cryptor);
 				return fileSystems.compute(normalizedPathToVault, (path, fs) -> {
diff --git a/src/main/java/org/cryptomator/cryptofs/VaultCipherCombo.java b/src/main/java/org/cryptomator/cryptofs/VaultCipherCombo.java
diff --git a/src/main/java/org/cryptomator/cryptofs/VaultConfig.java b/src/main/java/org/cryptomator/cryptofs/VaultConfig.java
@@ -8,6 +8,7 @@
 import com.auth0.jwt.exceptions.SignatureVerificationException;
 import com.auth0.jwt.interfaces.DecodedJWT;
 import org.cryptomator.cryptofs.common.Constants;
+import org.cryptomator.cryptolib.api.CryptorProvider;
 import org.cryptomator.cryptolib.api.Masterkey;
 import org.cryptomator.cryptolib.api.MasterkeyLoader;
 import org.cryptomator.cryptolib.api.MasterkeyLoadingFailedException;
@@ -36,13 +37,13 @@ public class VaultConfig {
 
 	private final String id;
 	private final int vaultVersion;
-	private final VaultCipherCombo cipherCombo;
+	private final CryptorProvider.Scheme cipherCombo;
 	private final int shorteningThreshold;
 
 	private VaultConfig(DecodedJWT verifiedConfig) {
 		this.id = verifiedConfig.getId();
 		this.vaultVersion = verifiedConfig.getClaim(JSON_KEY_VAULTVERSION).asInt();
-		this.cipherCombo = VaultCipherCombo.valueOf(verifiedConfig.getClaim(JSON_KEY_CIPHERCONFIG).asString());
+		this.cipherCombo = CryptorProvider.Scheme.valueOf(verifiedConfig.getClaim(JSON_KEY_CIPHERCONFIG).asString());
 		this.shorteningThreshold = verifiedConfig.getClaim(JSON_KEY_SHORTENING_THRESHOLD).asInt();
 	}
 
@@ -61,7 +62,7 @@ public int getVaultVersion() {
 		return vaultVersion;
 	}
 
-	public VaultCipherCombo getCipherCombo() {
+	public CryptorProvider.Scheme getCipherCombo() {
 		return cipherCombo;
 	}
 
@@ -184,10 +185,10 @@ public static class VaultConfigBuilder {
 
 		private final String id = UUID.randomUUID().toString();
 		private final int vaultVersion = Constants.VAULT_VERSION;
-		private VaultCipherCombo cipherCombo;
+		private CryptorProvider.Scheme cipherCombo;
 		private int shorteningThreshold;
 
-		public VaultConfigBuilder cipherCombo(VaultCipherCombo cipherCombo) {
+		public VaultConfigBuilder cipherCombo(CryptorProvider.Scheme cipherCombo) {
 			this.cipherCombo = cipherCombo;
 			return this;
 		}
diff --git a/src/main/java/org/cryptomator/cryptofs/attr/CryptoBasicFileAttributes.java b/src/main/java/org/cryptomator/cryptofs/attr/CryptoBasicFileAttributes.java
@@ -10,7 +10,6 @@
 
 import org.cryptomator.cryptofs.common.CiphertextFileType;
 import org.cryptomator.cryptofs.fh.OpenCryptoFile;
-import org.cryptomator.cryptolib.Cryptors;
 import org.cryptomator.cryptolib.api.Cryptor;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -53,7 +52,8 @@ private static long getPlaintextFileSize(Path ciphertextPath, long size, Optiona
 
 	private static long calculatePlaintextFileSize(Path ciphertextPath, long size, Cryptor cryptor) {
 		try {
-			return Cryptors.cleartextSize(size - cryptor.fileHeaderCryptor().headerSize(), cryptor);
+			long payloadSize = size - cryptor.fileHeaderCryptor().headerSize();
+			return cryptor.fileContentCryptor().cleartextSize(payloadSize);
 		} catch (IllegalArgumentException e) {
 			LOG.warn("Unable to calculate cleartext file size for {}. Ciphertext size (including header): {}", ciphertextPath, size);
 			return 0l;
diff --git a/src/main/java/org/cryptomator/cryptofs/ch/CleartextFileChannel.java b/src/main/java/org/cryptomator/cryptofs/ch/CleartextFileChannel.java
@@ -32,7 +32,6 @@
 
 import static java.lang.Math.max;
 import static java.lang.Math.min;
-import static org.cryptomator.cryptolib.Cryptors.ciphertextSize;
 
 @ChannelScoped
 public class CleartextFileChannel extends AbstractFileChannel {
@@ -192,7 +191,7 @@ protected void truncateLocked(long newSize) throws IOException {
 			if (sizeOfIncompleteChunk > 0) {
 				chunkCache.get(indexOfLastChunk).truncate(sizeOfIncompleteChunk);
 			}
-			long ciphertextFileSize = cryptor.fileHeaderCryptor().headerSize() + ciphertextSize(newSize, cryptor);
+			long ciphertextFileSize = cryptor.fileHeaderCryptor().headerSize() + cryptor.fileContentCryptor().ciphertextSize(newSize);
 			chunkCache.invalidateAll(); // make sure no chunks _after_ newSize exist that would otherwise be written during the next cache eviction
 			ciphertextFileChannel.truncate(ciphertextFileSize);
 			position = min(newSize, position);
diff --git a/src/main/java/org/cryptomator/cryptofs/fh/OpenCryptoFile.java b/src/main/java/org/cryptomator/cryptofs/fh/OpenCryptoFile.java
@@ -11,7 +11,6 @@
 import org.cryptomator.cryptofs.EffectiveOpenOptions;
 import org.cryptomator.cryptofs.ch.ChannelComponent;
 import org.cryptomator.cryptofs.ch.CleartextFileChannel;
-import org.cryptomator.cryptolib.Cryptors;
 import org.cryptomator.cryptolib.api.Cryptor;
 import org.cryptomator.cryptolib.api.FileHeader;
 import org.slf4j.Logger;
@@ -135,7 +134,8 @@ private void initFileSize(FileChannel ciphertextFileChannel) throws IOException
 			try {
 				long ciphertextSize = ciphertextFileChannel.size();
 				if (ciphertextSize > 0l) {
-					cleartextSize = Cryptors.cleartextSize(ciphertextSize - cryptor.fileHeaderCryptor().headerSize(), cryptor);
+					long payloadSize = ciphertextSize - cryptor.fileHeaderCryptor().headerSize();
+					cleartextSize = cryptor.fileContentCryptor().cleartextSize(payloadSize);
 				}
 			} catch (IllegalArgumentException e) {
 				LOG.warn("Invalid cipher text file size. Assuming empty file.", e);
diff --git a/src/main/java/org/cryptomator/cryptofs/fh/OpenCryptoFileModule.java b/src/main/java/org/cryptomator/cryptofs/fh/OpenCryptoFileModule.java
@@ -18,8 +18,6 @@
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 import java.util.function.Supplier;
 
-import static org.cryptomator.cryptolib.Cryptors.cleartextSize;
-
 @Module
 public class OpenCryptoFileModule {
 
diff --git a/src/main/java/org/cryptomator/cryptofs/migration/MigrationModule.java b/src/main/java/org/cryptomator/cryptofs/migration/MigrationModule.java
@@ -14,25 +14,17 @@
 import org.cryptomator.cryptofs.migration.v6.Version6Migrator;
 import org.cryptomator.cryptofs.migration.v7.Version7Migrator;
 import org.cryptomator.cryptofs.migration.v8.Version8Migrator;
-import org.cryptomator.cryptolib.Cryptors;
-import org.cryptomator.cryptolib.api.CryptorProvider;
 
 import java.lang.annotation.Documented;
 import java.lang.annotation.Retention;
 import java.lang.annotation.Target;
-import java.security.SecureRandom;
 
 import static java.lang.annotation.ElementType.METHOD;
 import static java.lang.annotation.RetentionPolicy.RUNTIME;
 
 @Module
 class MigrationModule {
 
-	@Provides
-	CryptorProvider provideVersion1CryptorProvider(SecureRandom csprng) {
-		return Cryptors.version1(csprng);
-	}
-
 	@Provides
 	FileSystemCapabilityChecker provideFileSystemCapabilityChecker() {
 		return new FileSystemCapabilityChecker();
diff --git a/src/test/java/org/cryptomator/cryptofs/CryptoFileSystemsTest.java b/src/test/java/org/cryptomator/cryptofs/CryptoFileSystemsTest.java
@@ -50,7 +50,7 @@ public class CryptoFileSystemsTest {
 	private final Masterkey clonedMasterkey = Mockito.mock(Masterkey.class);
 	private final byte[] rawKey = new byte[64];
 	private final VaultConfig vaultConfig = mock(VaultConfig.class);
-	private final VaultCipherCombo cipherCombo = mock(VaultCipherCombo.class);
+	private final CryptorProvider.Scheme cipherCombo = mock(CryptorProvider.Scheme.class);
 	private final SecureRandom csprng = Mockito.mock(SecureRandom.class);
 	private final CryptorProvider cryptorProvider = mock(CryptorProvider.class);
 	private final Cryptor cryptor = mock(Cryptor.class);
@@ -60,30 +60,31 @@ public class CryptoFileSystemsTest {
 
 	private MockedStatic<VaultConfig> vaultConficClass;
 	private MockedStatic<Files> filesClass;
+	private MockedStatic<CryptorProvider> cryptorProviderClass;
 
 	private final CryptoFileSystems inTest = new CryptoFileSystems(cryptoFileSystemComponentBuilder, capabilityChecker, csprng);
 
 	@BeforeEach
 	public void setup() throws IOException, MasterkeyLoadingFailedException {
 		vaultConficClass = Mockito.mockStatic(VaultConfig.class);
 		filesClass = Mockito.mockStatic(Files.class);
+		cryptorProviderClass = Mockito.mockStatic(CryptorProvider.class);
 
 		when(pathToVault.normalize()).thenReturn(normalizedPathToVault);
 		when(normalizedPathToVault.resolve("vault.cryptomator")).thenReturn(configFilePath);
 		when(properties.vaultConfigFilename()).thenReturn("vault.cryptomator");
 		when(properties.keyLoader()).thenReturn(keyLoader);
 		filesClass.when(() -> Files.readString(configFilePath, StandardCharsets.US_ASCII)).thenReturn("jwt-vault-config");
 		vaultConficClass.when(() -> VaultConfig.decode("jwt-vault-config")).thenReturn(configLoader);
+		cryptorProviderClass.when(() -> CryptorProvider.forScheme(cipherCombo)).thenReturn(cryptorProvider);
 		when(VaultConfig.decode("jwt-vault-config")).thenReturn(configLoader);
 		when(configLoader.getKeyId()).thenReturn(URI.create("test:key"));
 		when(keyLoader.loadKey(Mockito.any())).thenReturn(masterkey);
 		when(masterkey.getEncoded()).thenReturn(rawKey);
 		when(masterkey.clone()).thenReturn(clonedMasterkey);
 		when(configLoader.verify(rawKey, Constants.VAULT_VERSION)).thenReturn(vaultConfig);
-		when(cryptorProvider.withKey(clonedMasterkey)).thenReturn(cryptor);
+		when(cryptorProvider.provide(clonedMasterkey, csprng)).thenReturn(cryptor);
 		when(vaultConfig.getCipherCombo()).thenReturn(cipherCombo);
-		when(cipherCombo.getCryptorProvider(csprng)).thenReturn(cryptorProvider);
-		when(cryptorProvider.withKey(masterkey)).thenReturn(cryptor);
 		when(cryptor.fileNameCryptor()).thenReturn(fileNameCryptor);
 		when(fileNameCryptor.hashDirectoryId("")).thenReturn("ABCDEFGHIJKLMNOP");
 		when(pathToVault.resolve(Constants.DATA_DIR_NAME)).thenReturn(dataDirPath);
@@ -103,6 +104,7 @@ public void setup() throws IOException, MasterkeyLoadingFailedException {
 	public void tearDown() {
 		vaultConficClass.close();
 		filesClass.close();
+		cryptorProviderClass.close();
 	}
 
 	@Test
diff --git a/src/test/java/org/cryptomator/cryptofs/VaultConfigTest.java b/src/test/java/org/cryptomator/cryptofs/VaultConfigTest.java
@@ -6,6 +6,7 @@
 import com.auth0.jwt.interfaces.DecodedJWT;
 import com.auth0.jwt.interfaces.Verification;
 import org.cryptomator.cryptofs.common.Constants;
+import org.cryptomator.cryptolib.api.CryptorProvider;
 import org.cryptomator.cryptolib.api.Masterkey;
 import org.cryptomator.cryptolib.api.MasterkeyLoader;
 import org.cryptomator.cryptolib.api.MasterkeyLoadingFailedException;
@@ -47,7 +48,7 @@ public class WithValidToken {
 
 		@BeforeEach
 		public void setup() throws MasterkeyLoadingFailedException {
-			originalConfig = VaultConfig.createNew().cipherCombo(VaultCipherCombo.SIV_CTRMAC).shorteningThreshold(220).build();
+			originalConfig = VaultConfig.createNew().cipherCombo(CryptorProvider.Scheme.SIV_CTRMAC).shorteningThreshold(220).build();
 			token = originalConfig.toToken("TEST_KEY", rawKey);
 		}
 
@@ -76,11 +77,11 @@ public void testLoadWithInvalidKey(int pos) {
 
 	@Test
 	public void testCreateNew() {
-		var config = VaultConfig.createNew().cipherCombo(VaultCipherCombo.SIV_CTRMAC).shorteningThreshold(220).build();
+		var config = VaultConfig.createNew().cipherCombo(CryptorProvider.Scheme.SIV_CTRMAC).shorteningThreshold(220).build();
 
 		Assertions.assertNotNull(config.getId());
 		Assertions.assertEquals(Constants.VAULT_VERSION, config.getVaultVersion());
-		Assertions.assertEquals(VaultCipherCombo.SIV_CTRMAC, config.getCipherCombo());
+		Assertions.assertEquals(CryptorProvider.Scheme.SIV_CTRMAC, config.getCipherCombo());
 		Assertions.assertEquals(220, config.getShorteningThreshold());
 	}
 
diff --git a/src/test/java/org/cryptomator/cryptofs/attr/CryptoBasicFileAttributesTest.java b/src/test/java/org/cryptomator/cryptofs/attr/CryptoBasicFileAttributesTest.java
@@ -40,6 +40,7 @@ public void setup() {
 		Mockito.when(cryptor.fileContentCryptor()).thenReturn(contentCryptor);
 		Mockito.when(contentCryptor.cleartextChunkSize()).thenReturn(32 * 1024);
 		Mockito.when(contentCryptor.ciphertextChunkSize()).thenReturn(16 + 32 * 1024 + 32);
+		Mockito.doCallRealMethod().when(contentCryptor).cleartextSize(Mockito.anyLong());
 		ciphertextFilePath = Mockito.mock(Path.class, "ciphertextFile");
 		delegateAttr = Mockito.mock(BasicFileAttributes.class);
 
diff --git a/src/test/java/org/cryptomator/cryptofs/health/api/HealthCheckIntegrationTest.java b/src/test/java/org/cryptomator/cryptofs/health/api/HealthCheckIntegrationTest.java
@@ -1,6 +1,7 @@
 package org.cryptomator.cryptofs.health.api;
 
 import org.cryptomator.cryptofs.VaultConfig;
+import org.cryptomator.cryptolib.api.CryptorProvider;
 import org.cryptomator.cryptolib.common.MasterkeyFileAccess;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
@@ -38,7 +39,7 @@ public static void main(String[] args) throws IOException, NoSuchAlgorithmExcept
 
 			try (var masterkey = masterkeyFileAccess.load(masterkeyFile, pw)) {
 				var verifiedCfg = unverifiedCfg.verify(masterkey.getEncoded(), unverifiedCfg.allegedVaultVersion());
-				var cryptor = verifiedCfg.getCipherCombo().getCryptorProvider(SecureRandom.getInstanceStrong()).withKey(masterkey);
+				var cryptor = CryptorProvider.forScheme(verifiedCfg.getCipherCombo()).provide(masterkey, SecureRandom.getInstanceStrong());
 				var executor = Executors.newSingleThreadExecutor();
 				HealthCheck.allChecks().forEach(check -> {
 					System.out.println("Running " + check.identifier());
