Merge branch 'release/1.5.0-beta3'

[ci skip]

.github/FUNDING.yml

@@ -1,6 +1,6 @@
 # These are supported funding model platforms
 
-github: [overheadhunter, tobihagemann] # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+github: [cryptomator] # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
 patreon: # Replace with a single Patreon username
 open_collective: # Replace with a single Open Collective username
 ko_fi: # Replace with a single Ko-fi username

.github/stale.yml

@@ -1,12 +1,14 @@
 # Number of days of inactivity before an issue becomes stale
-daysUntilStale: 90
+daysUntilStale: 180
 # Number of days of inactivity before a stale issue is closed
 daysUntilClose: 30
 # Issues with these labels will never be considered stale
 exemptLabels:
   - type:security-issue # never close automatically
+  - type:feature-request # never close automatically
   - state:awaiting-response # handled by different bot
   - state:blocked
+  - state:confirmed
 # Set to true to ignore issues in a milestone (defaults to false)
 exemptMilestones: true
 # Label to use when marking an issue as stale

.idea/compiler.xml

@@ -7,20 +7,20 @@
         <sourceTestOutputDir name="target/generated-test-sources/test-annotations" />
         <outputRelativeToContentRoot value="true" />
         <processorPath useClasspath="false">
-          <entry name="$MAVEN_REPOSITORY$/com/google/dagger/dagger-compiler/2.25.2/dagger-compiler-2.25.2.jar" />
+          <entry name="$MAVEN_REPOSITORY$/com/google/dagger/dagger-compiler/2.26/dagger-compiler-2.26.jar" />
-          <entry name="$MAVEN_REPOSITORY$/com/google/dagger/dagger/2.25.2/dagger-2.25.2.jar" />
+          <entry name="$MAVEN_REPOSITORY$/com/google/dagger/dagger/2.26/dagger-2.26.jar" />
           <entry name="$MAVEN_REPOSITORY$/javax/inject/javax.inject/1/javax.inject-1.jar" />
-          <entry name="$MAVEN_REPOSITORY$/com/google/dagger/dagger-producers/2.25.2/dagger-producers-2.25.2.jar" />
+          <entry name="$MAVEN_REPOSITORY$/com/google/dagger/dagger-producers/2.26/dagger-producers-2.26.jar" />
           <entry name="$MAVEN_REPOSITORY$/com/google/guava/failureaccess/1.0.1/failureaccess-1.0.1.jar" />
           <entry name="$MAVEN_REPOSITORY$/com/google/guava/guava/27.1-jre/guava-27.1-jre.jar" />
           <entry name="$MAVEN_REPOSITORY$/com/google/guava/listenablefuture/9999.0-empty-to-avoid-conflict-with-guava/listenablefuture-9999.0-empty-to-avoid-conflict-with-guava.jar" />
-          <entry name="$MAVEN_REPOSITORY$/com/google/code/findbugs/jsr305/3.0.2/jsr305-3.0.2.jar" />
+          <entry name="$MAVEN_REPOSITORY$/com/google/code/findbugs/jsr305/3.0.1/jsr305-3.0.1.jar" />
           <entry name="$MAVEN_REPOSITORY$/org/checkerframework/checker-qual/2.5.2/checker-qual-2.5.2.jar" />
           <entry name="$MAVEN_REPOSITORY$/com/google/errorprone/error_prone_annotations/2.2.0/error_prone_annotations-2.2.0.jar" />
           <entry name="$MAVEN_REPOSITORY$/com/google/j2objc/j2objc-annotations/1.1/j2objc-annotations-1.1.jar" />
           <entry name="$MAVEN_REPOSITORY$/org/codehaus/mojo/animal-sniffer-annotations/1.17/animal-sniffer-annotations-1.17.jar" />
           <entry name="$MAVEN_REPOSITORY$/org/checkerframework/checker-compat-qual/2.5.3/checker-compat-qual-2.5.3.jar" />
-          <entry name="$MAVEN_REPOSITORY$/com/google/dagger/dagger-spi/2.25.2/dagger-spi-2.25.2.jar" />
+          <entry name="$MAVEN_REPOSITORY$/com/google/dagger/dagger-spi/2.26/dagger-spi-2.26.jar" />
           <entry name="$MAVEN_REPOSITORY$/com/squareup/javapoet/1.11.1/javapoet-1.11.1.jar" />
           <entry name="$MAVEN_REPOSITORY$/com/google/googlejavaformat/google-java-format/1.5/google-java-format-1.5.jar" />
           <entry name="$MAVEN_REPOSITORY$/com/google/errorprone/javac-shaded/9-dev-r4023-3/javac-shaded-9-dev-r4023-3.jar" />
@@ -31,8 +31,8 @@
           <entry name="$MAVEN_REPOSITORY$/org/jetbrains/annotations/13.0/annotations-13.0.jar" />
           <entry name="$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-metadata-jvm/0.1.0/kotlinx-metadata-jvm-0.1.0.jar" />
         </processorPath>
-        <module name="commons" />
         <module name="keychain" />
+        <module name="commons" />
         <module name="ui" />
         <module name="launcher" />
       </profile>

.idea/encodings.xml

@@ -1,11 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
-  <component name="Encoding" addBOMForNewFiles="with NO BOM">
+  <component name="Encoding" defaultCharsetForPropertiesFiles="UTF-8">
     <file url="file://$PROJECT_DIR$/main" charset="UTF-8" />
-    <file url="file://$PROJECT_DIR$/main/buildkit" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/main/commons/src/main/java" charset="UTF-8" />
-    <file url="file://$PROJECT_DIR$/main/commons" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/main/keychain/src/main/java" charset="UTF-8" />
-    <file url="file://$PROJECT_DIR$/main/keychain" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/main/keychain/src/main/resources" charset="UTF-8" />
-    <file url="file://$PROJECT_DIR$/main/launcher" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/main/launcher/src/main/java" charset="UTF-8" />
-    <file url="file://$PROJECT_DIR$/main/ui" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/main/ui/src/main/java" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/main/ui/src/main/resources" charset="UTF-8" />
+    <file url="PROJECT" charset="UTF-8" />
   </component>
 </project>

main/buildkit/pom.xml

@@ -4,7 +4,7 @@
 	<parent>
 		<groupId>org.cryptomator</groupId>
 		<artifactId>main</artifactId>
-		<version>1.5.0-beta1</version>
+		<version>1.5.0-beta3</version>
 	</parent>
 	<artifactId>buildkit</artifactId>
 	<packaging>pom</packaging>

main/commons/pom.xml

@@ -4,7 +4,7 @@
 	<parent>
 		<groupId>org.cryptomator</groupId>
 		<artifactId>main</artifactId>
-		<version>1.5.0-beta1</version>
+		<version>1.5.0-beta3</version>
 	</parent>
 	<artifactId>commons</artifactId>
 	<name>Cryptomator Commons</name>
@@ -48,6 +48,12 @@
 			<artifactId>easybind</artifactId>
 		</dependency>
 
+		<!-- JWT -->
+		<dependency>
+			<groupId>com.auth0</groupId>
+			<artifactId>java-jwt</artifactId>
+		</dependency>
+
 		<!-- Google -->
 		<dependency>
 			<groupId>com.google.guava</groupId>

main/commons/src/main/java/org/cryptomator/common/CommonsModule.java

@@ -5,7 +5,6 @@
  *******************************************************************************/
 package org.cryptomator.common;
 
-import dagger.Binds;
 import dagger.Module;
 import dagger.Provides;
 import javafx.beans.binding.Binding;
@@ -19,6 +18,8 @@ import org.cryptomator.common.vaults.VaultComponent;
 import org.cryptomator.common.vaults.VaultListManager;
 import org.cryptomator.frontend.webdav.WebDavServer;
 import org.fxmisc.easybind.EasyBind;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import javax.inject.Named;
 import javax.inject.Singleton;
@@ -27,13 +28,29 @@ import java.util.Comparator;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.SynchronousQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
-import java.util.function.Consumer;
 
 @Module(subcomponents = {VaultComponent.class})
 public abstract class CommonsModule {
 
-	private static final int NUM_SCHEDULER_THREADS = 4;
+	private static final Logger LOG = LoggerFactory.getLogger(CommonsModule.class);
+	private static final int NUM_SCHEDULER_THREADS = 2;
+	private static final int NUM_CORE_BG_THREADS = 6;
+	private static final long BG_THREAD_KEEPALIVE_SECONDS = 60l;
+
+	@Provides
+	@Singleton
+	@Named("licensePublicKey")
+	static String provideLicensePublicKey() {
+		// in PEM format without the dash-escaped begin/end lines
+		return "MIGbMBAGByqGSM49AgEGBSuBBAAjA4GGAAQB7NfnqiZbg2KTmoflmZ71PbXru7oW" //
+				+ "fmnV2yv3eDjlDfGruBrqz9TtXBZV/eYWt31xu1osIqaT12lKBvZ511aaAkIBeOEV" //
+				+ "gwcBIlJr6kUw7NKzeJt7r2rrsOyQoOG2nWc/Of/NBqA3mIZRHk5Aq1YupFdD26QE" //
+				+ "r0DzRyj4ixPIt38CQB8=";
+	}
 
 	@Provides
 	@Singleton
@@ -56,21 +73,41 @@ public abstract class CommonsModule {
 
 	@Provides
 	@Singleton
-	static ScheduledExecutorService provideScheduledExecutorService(@Named("shutdownTaskScheduler") Consumer<Runnable> shutdownTaskScheduler) {
+	static ScheduledExecutorService provideScheduledExecutorService(ShutdownHook shutdownHook) {
 		final AtomicInteger threadNumber = new AtomicInteger(1);
 		ScheduledExecutorService executorService = Executors.newScheduledThreadPool(NUM_SCHEDULER_THREADS, r -> {
+			String name = String.format("App Scheduled Executor %02d", threadNumber.getAndIncrement());
 			Thread t = new Thread(r);
-			t.setName("Background Thread " + threadNumber.getAndIncrement());
+			t.setName(name);
+			t.setUncaughtExceptionHandler(CommonsModule::handleUncaughtExceptionInBackgroundThread);
 			t.setDaemon(true);
+			LOG.debug("Starting {}", t.getName());
 			return t;
 		});
-		shutdownTaskScheduler.accept(executorService::shutdown);
+		shutdownHook.runOnShutdown(executorService::shutdown);
 		return executorService;
 	}
 
-	@Binds
+	@Provides
 	@Singleton
-	abstract ExecutorService bindExecutorService(ScheduledExecutorService executor);
+	static ExecutorService provideExecutorService(ShutdownHook shutdownHook) {
+		final AtomicInteger threadNumber = new AtomicInteger(1);
+		ExecutorService executorService = new ThreadPoolExecutor(NUM_CORE_BG_THREADS, Integer.MAX_VALUE, BG_THREAD_KEEPALIVE_SECONDS, TimeUnit.SECONDS, new SynchronousQueue<>(), r -> {
+			String name = String.format("App Background Thread %03d", threadNumber.getAndIncrement());
+			Thread t = new Thread(r);
+			t.setName(name);
+			t.setUncaughtExceptionHandler(CommonsModule::handleUncaughtExceptionInBackgroundThread);
+			t.setDaemon(true);
+			LOG.debug("Starting {}", t.getName());
+			return t;
+		});
+		shutdownHook.runOnShutdown(executorService::shutdown);
+		return executorService;
+	}
+
+	private static void handleUncaughtExceptionInBackgroundThread(Thread thread, Throwable throwable) {
+		LOG.error("Uncaught exception in " + thread.getName(), throwable);
+	}
 
 	@Provides
 	@Singleton

main/commons/src/main/java/org/cryptomator/common/Environment.java

@@ -25,6 +25,7 @@ public class Environment {
 	private static final Path RELATIVE_HOME_DIR = Paths.get("~");
 	private static final Path ABSOLUTE_HOME_DIR = Paths.get(USER_HOME);
 	private static final char PATH_LIST_SEP = ':';
+	private static final int DEFAULT_MIN_PW_LENGTH = 8;
 
 	@Inject
 	public Environment() {
@@ -37,6 +38,7 @@ public class Environment {
 		LOG.debug("cryptomator.keychainPath: {}", System.getProperty("cryptomator.keychainPath"));
 		LOG.debug("cryptomator.logDir: {}", System.getProperty("cryptomator.logDir"));
 		LOG.debug("cryptomator.mountPointsDir: {}", System.getProperty("cryptomator.mountPointsDir"));
+		LOG.debug("cryptomator.minPwLength: {}", System.getProperty("cryptomator.minPwLength"));
 	}
 
 	public boolean useCustomLogbackConfig() {
@@ -63,6 +65,19 @@ public class Environment {
 		return getPath("cryptomator.mountPointsDir").map(this::replaceHomeDir);
 	}
 
+	public int getMinPwLength() {
+		return getInt("cryptomator.minPwLength", DEFAULT_MIN_PW_LENGTH);
+	}
+
+	private int getInt(String propertyName, int defaultValue) {
+		String value = System.getProperty(propertyName);
+		try {
+			return Integer.parseInt(value);
+		} catch (NumberFormatException e) { // includes "null" values
+			return defaultValue;
+		}
+	}
+
 	private Optional<Path> getPath(String propertyName) {
 		String value = System.getProperty(propertyName);
 		return Optional.ofNullable(value).map(Paths::get);

main/commons/src/main/java/org/cryptomator/common/LicenseChecker.java

@@ -0,0 +1,56 @@
+package org.cryptomator.common;
+
+import com.auth0.jwt.JWT;
+import com.auth0.jwt.algorithms.Algorithm;
+import com.auth0.jwt.exceptions.JWTVerificationException;
+import com.auth0.jwt.interfaces.DecodedJWT;
+import com.auth0.jwt.interfaces.JWTVerifier;
+import com.google.common.io.BaseEncoding;
+
+import javax.inject.Inject;
+import javax.inject.Named;
+import javax.inject.Singleton;
+import java.security.KeyFactory;
+import java.security.NoSuchAlgorithmException;
+import java.security.PublicKey;
+import java.security.interfaces.ECPublicKey;
+import java.security.spec.InvalidKeySpecException;
+import java.security.spec.X509EncodedKeySpec;
+import java.util.Optional;
+
+@Singleton
+class LicenseChecker {
+
+	private final JWTVerifier verifier;
+
+	@Inject
+	public LicenseChecker(@Named("licensePublicKey") String pemEncodedPublicKey) {
+		Algorithm algorithm = Algorithm.ECDSA512(decodePublicKey(pemEncodedPublicKey), null);
+		this.verifier = JWT.require(algorithm).build();
+	}
+
+	private static ECPublicKey decodePublicKey(String pemEncodedPublicKey) {
+		try {
+			byte[] keyBytes = BaseEncoding.base64().decode(pemEncodedPublicKey);
+			PublicKey key = KeyFactory.getInstance("EC").generatePublic(new X509EncodedKeySpec(keyBytes));
+			if (key instanceof ECPublicKey) {
+				return (ECPublicKey) key;
+			} else {
+				throw new IllegalStateException("Key not an EC public key.");
+			}
+		} catch (InvalidKeySpecException e) {
+			throw new IllegalArgumentException("Invalid license public key", e);
+		} catch (NoSuchAlgorithmException e) {
+			throw new IllegalStateException(e);
+		}
+	}
+
+	public Optional<DecodedJWT> check(String licenseKey) {
+		try {
+			return Optional.of(verifier.verify(licenseKey));
+		} catch (JWTVerificationException exception) {
+			return Optional.empty();
+		}
+	}
+
+}

main/commons/src/main/java/org/cryptomator/common/LicenseHolder.java

@@ -0,0 +1,79 @@
+package org.cryptomator.common;
+
+import com.auth0.jwt.interfaces.DecodedJWT;
+import javafx.beans.binding.Bindings;
+import javafx.beans.binding.BooleanBinding;
+import javafx.beans.binding.StringBinding;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import org.cryptomator.common.settings.Settings;
+
+import javax.inject.Inject;
+import javax.inject.Singleton;
+import java.util.Optional;
+
+@Singleton
+public class LicenseHolder {
+
+	private final Settings settings;
+	private final LicenseChecker licenseChecker;
+	private final ObjectProperty<DecodedJWT> validJwtClaims;
+	private final StringBinding licenseSubject;
+	private final BooleanBinding validLicenseProperty;
+
+	@Inject
+	public LicenseHolder(LicenseChecker licenseChecker, Settings settings) {
+		this.settings = settings;
+		this.licenseChecker = licenseChecker;
+		this.validJwtClaims = new SimpleObjectProperty<>();
+		this.licenseSubject = Bindings.createStringBinding(this::getLicenseSubject, validJwtClaims);
+		this.validLicenseProperty = validJwtClaims.isNotNull();
+
+		Optional<DecodedJWT> claims = licenseChecker.check(settings.licenseKey().get());
+		validJwtClaims.set(claims.orElse(null));
+	}
+
+	public boolean validateAndStoreLicense(String licenseKey) {
+		Optional<DecodedJWT> claims = licenseChecker.check(licenseKey);
+		validJwtClaims.set(claims.orElse(null));
+		if (claims.isPresent()) {
+			settings.licenseKey().set(licenseKey);
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	/* Observable Properties */
+
+	public Optional<String> getLicenseKey() {
+		DecodedJWT claims = validJwtClaims.get();
+		if (claims != null) {
+			return Optional.of(claims.getToken());
+		} else {
+			return Optional.empty();
+		}
+	}
+
+	public StringBinding licenseSubjectProperty() {
+		return licenseSubject;
+	}
+
+	public String getLicenseSubject() {
+		DecodedJWT claims = validJwtClaims.get();
+		if (claims != null) {
+			return claims.getSubject();
+		} else {
+			return null;
+		}
+	}
+
+	public BooleanBinding validLicenseProperty() {
+		return validLicenseProperty;
+	}
+
+	public boolean isValidLicense() {
+		return validLicenseProperty.get();
+	}
+
+}

main/commons/src/main/java/org/cryptomator/common/Optionals.java

@@ -1,28 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2017 Skymatic UG (haftungsbeschränkt).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the accompanying LICENSE file.
- *******************************************************************************/
-package org.cryptomator.common;
-
-import java.util.Optional;
-import java.util.function.Function;
-
-public final class Optionals {
-
-	private Optionals() {
-	}
-
-	/**
-	 * Returns a function that is equivalent to the input function but immediately gets the value of the returned optional when invoked.
-	 * 
-	 * @param <T> the type of the input to the function
-	 * @param <R> the type of the result of the function
-	 * @param function An {@code Optional}-bearing input function {@code Function<Foo, Optional<Bar>>}
-	 * @return A {@code Function<Foo, Bar>}, that may throw a NoSuchElementException, if the original function returns an empty optional.
-	 */
-	public static <T, R> Function<T, R> unwrap(Function<T, Optional<R>> function) {
-		return t -> function.apply(t).get();
-	}
-
-}

main/commons/src/main/java/org/cryptomator/common/ShutdownHook.java

@@ -0,0 +1,96 @@
+/*******************************************************************************
+ * Copyright (c) 2017 Skymatic UG (haftungsbeschränkt).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the accompanying LICENSE file.
+ *******************************************************************************/
+package org.cryptomator.common;
+
+import com.google.common.util.concurrent.Runnables;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.inject.Inject;
+import javax.inject.Singleton;
+import java.util.Queue;
+import java.util.concurrent.PriorityBlockingQueue;
+
+@Singleton
+public class ShutdownHook extends Thread {
+
+	private static final int PRIO_VERY_LAST = Integer.MIN_VALUE;
+	public static final int PRIO_LAST = PRIO_VERY_LAST + 1;
+	public static final int PRIO_DEFAULT = 0;
+	public static final int PRIO_FIRST = Integer.MAX_VALUE;
+	private static final Logger LOG = LoggerFactory.getLogger(ShutdownHook.class);
+	private static final OrderedTask POISON = new OrderedTask(PRIO_VERY_LAST, Runnables.doNothing());
+	private final Queue<OrderedTask> tasks = new PriorityBlockingQueue<>();
+
+	@Inject
+	ShutdownHook() {
+		super(null, null, "ShutdownTasks", 0);
+		Runtime.getRuntime().addShutdownHook(this);
+		LOG.debug("Registered shutdown hook.");
+	}
+
+	@Override
+	public void run() {
+		LOG.debug("Running graceful shutdown tasks...");
+		tasks.add(POISON);
+		Runnable task;
+		while ((task = tasks.remove()) != POISON) {
+			try {
+				task.run();
+			} catch (RuntimeException e) {
+				LOG.error("Exception while shutting down.", e);
+			}
+		}
+	}
+
+	/**
+	 * Schedules a task to be run during shutdown with default order
+	 *
+	 * @param task The task to be scheduled
+	 */
+	public void runOnShutdown(Runnable task) {
+		runOnShutdown(PRIO_DEFAULT, task);
+	}
+
+	/**
+	 * Schedules a task to be run with the given priority
+	 *
+	 * @param priority Tasks with high priority will be run before task with lower priority
+	 * @param task The task to be scheduled
+	 */
+	public void runOnShutdown(int priority, Runnable task) {
+		tasks.add(new OrderedTask(priority, task));
+	}
+
+	private static class OrderedTask implements Comparable<OrderedTask>, Runnable {
+
+		private final int priority;
+		private final Runnable task;
+
+		public OrderedTask(int priority, Runnable task) {
+			this.priority = priority;
+			this.task = task;
+		}
+
+		@Override
+		public int compareTo(OrderedTask other) {
+			// overflow-safe signum impl:
+			if (this.priority > other.priority) {
+				return -1; // higher prio -> this before other
+			} else if (this.priority < other.priority) {
+				return +1; // lower prio -> other before this
+			} else {
+				return 0; // same prio
+			}
+		}
+
+		@Override
+		public void run() {
+			task.run();
+		}
+	}
+
+}

main/commons/src/main/java/org/cryptomator/common/settings/Settings.java

@@ -15,6 +15,8 @@ import javafx.beans.property.ObjectProperty;
 import javafx.beans.property.SimpleBooleanProperty;
 import javafx.beans.property.SimpleIntegerProperty;
 import javafx.beans.property.SimpleObjectProperty;
+import javafx.beans.property.SimpleStringProperty;
+import javafx.beans.property.StringProperty;
 import javafx.collections.FXCollections;
 import javafx.collections.ObservableList;
 import javafx.geometry.NodeOrientation;
@@ -35,6 +37,7 @@ public class Settings {
 	public static final VolumeImpl DEFAULT_PREFERRED_VOLUME_IMPL = System.getProperty("os.name").toLowerCase().contains("windows") ? VolumeImpl.DOKANY : VolumeImpl.FUSE;
 	public static final UiTheme DEFAULT_THEME = UiTheme.LIGHT;
 	public static final NodeOrientation DEFAULT_USER_INTERFACE_ORIENTATION = NodeOrientation.LEFT_TO_RIGHT;
+	private static final String DEFAULT_LICENSE_KEY = "";
 
 	private final ObservableList<VaultSettings> directories = FXCollections.observableArrayList(VaultSettings::observables);
 	private final BooleanProperty askedForUpdateCheck = new SimpleBooleanProperty(DEFAULT_ASKED_FOR_UPDATE_CHECK);
@@ -47,6 +50,7 @@ public class Settings {
 	private final ObjectProperty<VolumeImpl> preferredVolumeImpl = new SimpleObjectProperty<>(DEFAULT_PREFERRED_VOLUME_IMPL);
 	private final ObjectProperty<UiTheme> theme = new SimpleObjectProperty<>(DEFAULT_THEME);
 	private final ObjectProperty<NodeOrientation> userInterfaceOrientation = new SimpleObjectProperty<>(DEFAULT_USER_INTERFACE_ORIENTATION);
+	private final StringProperty licenseKey = new SimpleStringProperty(DEFAULT_LICENSE_KEY);
 
 	private Consumer<Settings> saveCmd;
 
@@ -65,6 +69,7 @@ public class Settings {
 		preferredVolumeImpl.addListener(this::somethingChanged);
 		theme.addListener(this::somethingChanged);
 		userInterfaceOrientation.addListener(this::somethingChanged);
+		licenseKey.addListener(this::somethingChanged);
 	}
 
 	void setSaveCmd(Consumer<Settings> saveCmd) {
@@ -126,4 +131,8 @@ public class Settings {
 	public ObjectProperty<NodeOrientation> userInterfaceOrientation() {
 		return userInterfaceOrientation;
 	}
+
+	public StringProperty licenseKey() {
+		return licenseKey;
+	}
 }

main/commons/src/main/java/org/cryptomator/common/settings/SettingsJsonAdapter.java

@@ -38,6 +38,7 @@ public class SettingsJsonAdapter extends TypeAdapter<Settings> {
 		out.name("preferredVolumeImpl").value(value.preferredVolumeImpl().get().name());
 		out.name("theme").value(value.theme().get().name());
 		out.name("uiOrientation").value(value.userInterfaceOrientation().get().name());
+		out.name("licenseKey").value(value.licenseKey().get());
 		out.endObject();
 	}
 
@@ -90,6 +91,9 @@ public class SettingsJsonAdapter extends TypeAdapter<Settings> {
 				case "uiOrientation":
 					settings.userInterfaceOrientation().set(parseUiOrientation(in.nextString()));
 					break;
+				case "licenseKey":
+					settings.licenseKey().set(in.nextString());
+					break;
 				default:
 					LOG.warn("Unsupported vault setting found in JSON: " + name);
 					in.skipValue();

main/commons/src/main/java/org/cryptomator/common/settings/SettingsProvider.java

@@ -32,7 +32,6 @@ import java.nio.file.Path;
 import java.nio.file.StandardCopyOption;
 import java.nio.file.StandardOpenOption;
 import java.util.Optional;
-import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
@@ -46,16 +45,17 @@ public class SettingsProvider implements Supplier<Settings> {
 	private static final Logger LOG = LoggerFactory.getLogger(SettingsProvider.class);
 	private static final long SAVE_DELAY_MS = 1000;
 
-	private final ScheduledExecutorService saveScheduler = Executors.newSingleThreadScheduledExecutor();
 	private final AtomicReference<ScheduledFuture<?>> scheduledSaveCmd = new AtomicReference<>();
 	private final AtomicReference<Settings> settings = new AtomicReference<>();
 	private final SettingsJsonAdapter settingsJsonAdapter = new SettingsJsonAdapter();
 	private final Environment env;
+	private final ScheduledExecutorService scheduler;
 	private final Gson gson;
 
 	@Inject
-	public SettingsProvider(Environment env) {
+	public SettingsProvider(Environment env, ScheduledExecutorService scheduler) {
 		this.env = env;
+		this.scheduler = scheduler;
 		this.gson = new GsonBuilder() //
 				.setPrettyPrinting().setLenient().disableHtmlEscaping() //
 				.registerTypeAdapter(Settings.class, settingsJsonAdapter) //
@@ -98,7 +98,7 @@ public class SettingsProvider implements Supplier<Settings> {
 		final Optional<Path> settingsPath = env.getSettingsPath().findFirst(); // alway save to preferred (first) path
 		settingsPath.ifPresent(path -> {
 			Runnable saveCommand = () -> this.save(settings, path);
-			ScheduledFuture<?> scheduledTask = saveScheduler.schedule(saveCommand, SAVE_DELAY_MS, TimeUnit.MILLISECONDS);
+			ScheduledFuture<?> scheduledTask = scheduler.schedule(saveCommand, SAVE_DELAY_MS, TimeUnit.MILLISECONDS);
 			ScheduledFuture<?> previouslyScheduledTask = scheduledSaveCmd.getAndSet(scheduledTask);
 			if (previouslyScheduledTask != null) {
 				previouslyScheduledTask.cancel(false);

main/commons/src/main/java/org/cryptomator/common/vaults/VaultListManager.java

@@ -18,6 +18,7 @@ import org.cryptomator.cryptofs.migration.Migrators;
 import javax.inject.Inject;
 import javax.inject.Singleton;
 import java.io.IOException;
+import java.nio.file.Files;
 import java.nio.file.NoSuchFileException;
 import java.nio.file.Path;
 import java.util.Collection;
@@ -67,7 +68,13 @@ public class VaultListManager {
 	}
 	
 	private Optional<Vault> get(Path vaultPath) {
-		return vaultList.stream().filter(v -> v.getPath().equals(vaultPath)).findAny();
+		return vaultList.stream().filter(v -> {
+			try {
+				return Files.isSameFile(vaultPath, v.getPath());
+			} catch (IOException e) {
+				return false;
+			}
+		}).findAny();
 	}
 
 	private Vault create(VaultSettings vaultSettings) {
@@ -76,7 +83,7 @@ public class VaultListManager {
 		return comp.vault();
 	}
 
-	private VaultState determineVaultState(Path pathToVault) {
+	public static VaultState determineVaultState(Path pathToVault) {
 		try {
 			if (!CryptoFileSystemProvider.containsVault(pathToVault, MASTERKEY_FILENAME)) {
 				return VaultState.MISSING;

main/commons/src/main/java/org/cryptomator/common/vaults/WindowsDriveLetters.java

@@ -41,7 +41,6 @@ public final class WindowsDriveLetters {
 
 	public Set<String> getOccupiedDriveLetters() {
 		if (!SystemUtils.IS_OS_WINDOWS) {
-			LOG.warn("Attempted to get occupied drive letters on non-Windows machine.");
 			return Set.of();
 		} else {
 			Iterable<Path> rootDirs = FileSystems.getDefault().getRootDirectories();

main/commons/src/test/java/org/cryptomator/common/LicenseCheckerTest.java

@@ -0,0 +1,62 @@
+package org.cryptomator.common;
+
+import com.auth0.jwt.interfaces.DecodedJWT;
+import org.cryptomator.common.LicenseChecker;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.Optional;
+
+class LicenseCheckerTest {
+
+	private static final String PUBLIC_KEY = "MIGbMBAGByqGSM49AgEGBSuBBAAjA4GGAAQBgc4HZz+/fBbC7lmEww0AO3NK9wVZ" //
+			+ "PDZ0VEnsaUFLEYpTzb90nITtJUcPUbvOsdZIZ1Q8fnbquAYgxXL5UgHMoywAib47" //
+			+ "6MkyyYgPk0BXZq3mq4zImTRNuaU9slj9TVJ3ScT3L1bXwVuPJDzpr5GOFpaj+WwM" //
+			+ "Al8G7CqwoJOsW7Kddns=";
+	
+	private LicenseChecker licenseChecker;
+
+	@BeforeEach
+	public void setup() {
+		licenseChecker = new LicenseChecker(PUBLIC_KEY);
+	}
+
+	@Test
+	public void testCheckValidLicense() {
+		String license = "eyJhbGciOiJFUzUxMiIsInR5cCI6IkpXVCIsImtpZCI6InhaRGZacHJ5NFA5dlpQWnlHMmZOQlJqLTdMejVvbVZkbTd0SG9DZ1NOZlkifQ.eyJzdWIiOiJjcnlwdG9ib3RAZXhhbXBsZS5jb20iLCJpYXQiOjE1MTYyMzkwMjJ9.AQaBIKQdNCxmRJi2wLOcbagTgi39WhdWwgdpKTYSPicg-aPr_tst_RjmnqMemx3cBe0Blr4nEbj_lAtSKHz_i61fAUyI1xCIAZYbK9Q3ICHIHQl3AiuCpBwFl-k81OB4QDYiKpEc9gLN5dhW_VymJMsgOvyiC0UjC91f2AM7s46byDNj";
+		
+		Optional<DecodedJWT> decoded = licenseChecker.check(license);
+		
+		Assertions.assertTrue(decoded.isPresent());
+		Assertions.assertEquals("cryptobot@example.com", decoded.get().getSubject());
+	}
+
+	@Test
+	public void testCheckInvalidLicenseHeader() {
+		String license = "EyJhbGciOiJFUzUxMiIsInR5cCI6IkpXVCIsImtpZCI6InhaRGZacHJ5NFA5dlpQWnlHMmZOQlJqLTdMejVvbVZkbTd0SG9DZ1NOZlkifQ.eyJzdWIiOiJjcnlwdG9ib3RAZXhhbXBsZS5jb20iLCJpYXQiOjE1MTYyMzkwMjJ9.AQaBIKQdNCxmRJi2wLOcbagTgi39WhdWwgdpKTYSPicg-aPr_tst_RjmnqMemx3cBe0Blr4nEbj_lAtSKHz_i61fAUyI1xCIAZYbK9Q3ICHIHQl3AiuCpBwFl-k81OB4QDYiKpEc9gLN5dhW_VymJMsgOvyiC0UjC91f2AM7s46byDNj";
+
+		Optional<DecodedJWT> decoded = licenseChecker.check(license);
+
+		Assertions.assertFalse(decoded.isPresent());
+	}
+
+	@Test
+	public void testCheckInvalidLicensePayload() {
+		String license = "eyJhbGciOiJFUzUxMiIsInR5cCI6IkpXVCIsImtpZCI6InhaRGZacHJ5NFA5dlpQWnlHMmZOQlJqLTdMejVvbVZkbTd0SG9DZ1NOZlkifQ.EyJzdWIiOiJjcnlwdG9ib3RAZXhhbXBsZS5jb20iLCJpYXQiOjE1MTYyMzkwMjJ9.AQaBIKQdNCxmRJi2wLOcbagTgi39WhdWwgdpKTYSPicg-aPr_tst_RjmnqMemx3cBe0Blr4nEbj_lAtSKHz_i61fAUyI1xCIAZYbK9Q3ICHIHQl3AiuCpBwFl-k81OB4QDYiKpEc9gLN5dhW_VymJMsgOvyiC0UjC91f2AM7s46byDNj";
+
+		Optional<DecodedJWT> decoded = licenseChecker.check(license);
+
+		Assertions.assertFalse(decoded.isPresent());
+	}
+
+	@Test
+	public void testCheckInvalidLicenseSignature() {
+		String license = "eyJhbGciOiJFUzUxMiIsInR5cCI6IkpXVCIsImtpZCI6InhaRGZacHJ5NFA5dlpQWnlHMmZOQlJqLTdMejVvbVZkbTd0SG9DZ1NOZlkifQ.eyJzdWIiOiJjcnlwdG9ib3RAZXhhbXBsZS5jb20iLCJpYXQiOjE1MTYyMzkwMjJ9.aQaBIKQdNCxmRJi2wLOcbagTgi39WhdWwgdpKTYSPicg-aPr_tst_RjmnqMemx3cBe0Blr4nEbj_lAtSKHz_i61fAUyI1xCIAZYbK9Q3ICHIHQl3AiuCpBwFl-k81OB4QDYiKpEc9gLN5dhW_VymJMsgOvyiC0UjC91f2AM7s46byDNj";
+
+		Optional<DecodedJWT> decoded = licenseChecker.check(license);
+
+		Assertions.assertFalse(decoded.isPresent());
+	}
+
+}

main/keychain/pom.xml

@@ -4,7 +4,7 @@
 	<parent>
 		<groupId>org.cryptomator</groupId>
 		<artifactId>main</artifactId>
-		<version>1.5.0-beta1</version>
+		<version>1.5.0-beta3</version>
 	</parent>
 	<artifactId>keychain</artifactId>
 	<name>System Keychain Access</name>

main/keychain/src/main/java/org/cryptomator/keychain/KeychainModule.java

@@ -11,6 +11,7 @@ import dagger.Provides;
 import dagger.multibindings.ElementsIntoSet;
 import org.cryptomator.common.JniModule;
 
+import javax.inject.Singleton;
 import java.util.Optional;
 import java.util.Set;
 
@@ -24,6 +25,7 @@ public class KeychainModule {
 	}
 
 	@Provides
+	@Singleton
 	public Optional<KeychainAccess> provideSupportedKeychain(Set<KeychainAccessStrategy> keychainAccessStrategies) {
 		return keychainAccessStrategies.stream().filter(KeychainAccessStrategy::isSupported).map(KeychainAccess.class::cast).findFirst();
 	}

main/launcher/pom.xml

@@ -4,7 +4,7 @@
 	<parent>
 		<groupId>org.cryptomator</groupId>
 		<artifactId>main</artifactId>
-		<version>1.5.0-beta1</version>
+		<version>1.5.0-beta3</version>
 	</parent>
 	<artifactId>launcher</artifactId>
 	<name>Cryptomator Launcher</name>

main/launcher/src/main/java/org/cryptomator/launcher/CleanShutdownPerformer.java

@@ -1,48 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2017 Skymatic UG (haftungsbeschränkt).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the accompanying LICENSE file.
- *******************************************************************************/
-package org.cryptomator.launcher;
-
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import javax.inject.Inject;
-import javax.inject.Singleton;
-
-@Singleton
-class CleanShutdownPerformer extends Thread {
-
-	private static final Logger LOG = LoggerFactory.getLogger(CleanShutdownPerformer.class);
-	private final ConcurrentMap<Runnable, Boolean> tasks = new ConcurrentHashMap<>();
-
-	@Inject
-	CleanShutdownPerformer() {
-		super(null, null, "ShutdownTasks", 0);
-	}
-
-	@Override
-	public void run() {
-		LOG.debug("Running graceful shutdown tasks...");
-		tasks.keySet().forEach(r -> {
-			try {
-				r.run();
-			} catch (RuntimeException e) {
-				LOG.error("Exception while shutting down.", e);
-			}
-		});
-		tasks.clear();
-	}
-
-	void scheduleShutdownTask(Runnable task) {
-		tasks.put(task, Boolean.TRUE);
-	}
-
-	void registerShutdownHook() {
-		Runtime.getRuntime().addShutdownHook(this);
-	}
-}

main/launcher/src/main/java/org/cryptomator/launcher/Cryptomator.java

@@ -32,17 +32,15 @@ public class Cryptomator {
 	private final IpcFactory ipcFactory;
 	private final Optional<String> applicationVersion;
 	private final CountDownLatch shutdownLatch;
-	private final CleanShutdownPerformer shutdownPerformer;
 	private final UiLauncher uiLauncher;
 
 	@Inject
-	Cryptomator(LoggerConfiguration logConfig, DebugMode debugMode, IpcFactory ipcFactory, @Named("applicationVersion") Optional<String> applicationVersion, @Named("shutdownLatch") CountDownLatch shutdownLatch, CleanShutdownPerformer shutdownPerformer, UiLauncher uiLauncher) {
+	Cryptomator(LoggerConfiguration logConfig, DebugMode debugMode, IpcFactory ipcFactory, @Named("applicationVersion") Optional<String> applicationVersion, @Named("shutdownLatch") CountDownLatch shutdownLatch, UiLauncher uiLauncher) {
 		this.logConfig = logConfig;
 		this.debugMode = debugMode;
 		this.ipcFactory = ipcFactory;
 		this.applicationVersion = applicationVersion;
 		this.shutdownLatch = shutdownLatch;
-		this.shutdownPerformer = shutdownPerformer;
 		this.uiLauncher = uiLauncher;
 	}
 
@@ -90,7 +88,6 @@ public class Cryptomator {
 	 */
 	private int runGuiApplication() {
 		try {
-			shutdownPerformer.registerShutdownHook();
 			uiLauncher.launch();
 			shutdownLatch.await();
 			LOG.info("UI shut down");

main/launcher/src/main/java/org/cryptomator/launcher/CryptomatorModule.java

@@ -7,18 +7,10 @@ import javax.inject.Named;
 import javax.inject.Singleton;
 import java.util.Optional;
 import java.util.concurrent.CountDownLatch;
-import java.util.function.Consumer;
 
 @Module
 class CryptomatorModule {
-
+	
-	@Provides
-	@Singleton
-	@Named("shutdownTaskScheduler")
-	Consumer<Runnable> provideShutdownTaskScheduler(CleanShutdownPerformer shutdownPerformer) {
-		return shutdownPerformer::scheduleShutdownTask;
-	}
-
 	@Provides
 	@Singleton
 	@Named("shutdownLatch")

main/launcher/src/main/java/org/cryptomator/launcher/FileOpenRequestHandler.java

@@ -21,8 +21,10 @@ import java.nio.file.FileSystems;
 import java.nio.file.InvalidPathException;
 import java.nio.file.Path;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.Objects;
 import java.util.concurrent.BlockingQueue;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 @Singleton
@@ -40,7 +42,7 @@ class FileOpenRequestHandler {
 	}
 
 	private void openFiles(OpenFilesEvent evt) {
-		Stream<Path> pathsToOpen = evt.getFiles().stream().map(File::toPath);
+		Collection<Path> pathsToOpen = evt.getFiles().stream().map(File::toPath).collect(Collectors.toList());
 		AppLaunchEvent launchEvent = new AppLaunchEvent(AppLaunchEvent.EventType.OPEN_FILE, pathsToOpen);
 		tryToEnqueueFileOpenRequest(launchEvent);
 	}
@@ -51,16 +53,18 @@ class FileOpenRequestHandler {
 
 	// visible for testing
 	void handleLaunchArgs(FileSystem fs, String[] args) {
-		Stream<Path> pathsToOpen = Arrays.stream(args).map(str -> {
+		Collection<Path> pathsToOpen = Arrays.stream(args).map(str -> {
 			try {
 				return fs.getPath(str);
 			} catch (InvalidPathException e) {
 				LOG.trace("Argument not a valid path: {}", str);
 				return null;
 			}
-		}).filter(Objects::nonNull);
+		}).filter(Objects::nonNull).collect(Collectors.toList());
-		AppLaunchEvent launchEvent = new AppLaunchEvent(AppLaunchEvent.EventType.OPEN_FILE, pathsToOpen);
+		if (!pathsToOpen.isEmpty()) {
-		tryToEnqueueFileOpenRequest(launchEvent);
+			AppLaunchEvent launchEvent = new AppLaunchEvent(AppLaunchEvent.EventType.OPEN_FILE, pathsToOpen);
+			tryToEnqueueFileOpenRequest(launchEvent);
+		}
 	}
 
 

main/launcher/src/main/java/org/cryptomator/launcher/IpcProtocolImpl.java

@@ -8,6 +8,7 @@ import javax.inject.Inject;
 import javax.inject.Named;
 import javax.inject.Singleton;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.concurrent.BlockingQueue;
 import java.util.stream.Stream;
 
@@ -27,7 +28,7 @@ class IpcProtocolImpl implements IpcProtocol {
 
 	@Override
 	public void revealRunningApp() {
-		launchEventQueue.add(new AppLaunchEvent(AppLaunchEvent.EventType.REVEAL_APP, Stream.empty()));
+		launchEventQueue.add(new AppLaunchEvent(AppLaunchEvent.EventType.REVEAL_APP, Collections.emptyList()));
 	}
 
 	@Override

main/launcher/src/main/java/org/cryptomator/logging/LoggerConfiguration.java

@@ -5,9 +5,8 @@ import ch.qos.logback.classic.Logger;
 import ch.qos.logback.classic.LoggerContext;
 import ch.qos.logback.classic.spi.ILoggingEvent;
 import ch.qos.logback.core.Appender;
-import ch.qos.logback.core.hook.DelayingShutdownHook;
-import ch.qos.logback.core.util.Duration;
 import org.cryptomator.common.Environment;
+import org.cryptomator.common.ShutdownHook;
 
 import javax.inject.Inject;
 import javax.inject.Named;
@@ -16,26 +15,27 @@ import java.util.Map;
 
 @Singleton
 public class LoggerConfiguration {
-
+	
-	private static final double SHUTDOWN_DELAY_MS = 100;
-
 	private final LoggerContext context;
 	private final Environment environment;
 	private final Appender<ILoggingEvent> stdout;
 	private final Appender<ILoggingEvent> upgrade;
 	private final Appender<ILoggingEvent> file;
+	private final ShutdownHook shutdownHook;
 
 	@Inject
 	LoggerConfiguration(LoggerContext context, //
 						Environment environment, //
 						@Named("stdoutAppender") Appender<ILoggingEvent> stdout, //
 						@Named("upgradeAppender") Appender<ILoggingEvent> upgrade, //
-						@Named("fileAppender") Appender<ILoggingEvent> file) {
+						@Named("fileAppender") Appender<ILoggingEvent> file, //
+						ShutdownHook shutdownHook) {
 		this.context = context;
 		this.environment = environment;
 		this.stdout = stdout;
 		this.upgrade = upgrade;
 		this.file = file;
+		this.shutdownHook = shutdownHook;
 	}
 
 	public void init() {
@@ -55,16 +55,15 @@ public class LoggerConfiguration {
 			}
 
 			// configure upgrade logger:
-			Logger upgrades = context.getLogger("org.cryptomator.ui.model.upgrade");
+			Logger upgrades = context.getLogger("org.cryptomator.cryptofs.migration");
 			upgrades.setLevel(Level.DEBUG);
 			upgrades.addAppender(stdout);
 			upgrades.addAppender(upgrade);
+			upgrades.addAppender(file);
 			upgrades.setAdditive(false);
 
 			// add shutdown hook
-			DelayingShutdownHook shutdownHook = new DelayingShutdownHook();
+			shutdownHook.runOnShutdown(ShutdownHook.PRIO_LAST, context::stop);
-			shutdownHook.setContext(context);
-			shutdownHook.setDelay(Duration.buildByMilliseconds(SHUTDOWN_DELAY_MS));
 		}
 	}
 

main/launcher/src/test/java/org/cryptomator/launcher/FileOpenRequestHandlerTest.java

@@ -15,16 +15,14 @@ import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import org.mockito.Mockito;
 
-import java.io.IOException;
 import java.nio.file.FileSystem;
 import java.nio.file.InvalidPathException;
 import java.nio.file.Path;
 import java.nio.file.Paths;
-import java.util.List;
+import java.util.Collection;
+import java.util.Collections;
 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.BlockingQueue;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
 
 public class FileOpenRequestHandlerTest {
 
@@ -39,32 +37,30 @@ public class FileOpenRequestHandlerTest {
 
 	@Test
 	@DisplayName("./cryptomator.exe foo bar")
-	public void testOpenArgsWithCorrectPaths() throws IOException {
+	public void testOpenArgsWithCorrectPaths() {
 		inTest.handleLaunchArgs(new String[]{"foo", "bar"});
 
 		AppLaunchEvent evt = queue.poll();
 		Assertions.assertNotNull(evt);
-		List<Path> paths = evt.getPathsToOpen().collect(Collectors.toList());
+		Collection<Path> paths = evt.getPathsToOpen();
 		MatcherAssert.assertThat(paths, CoreMatchers.hasItems(Paths.get("foo"), Paths.get("bar")));
 	}
 
 	@Test
 	@DisplayName("./cryptomator.exe foo (with 'foo' being an invalid path)")
-	public void testOpenArgsWithIncorrectPaths() throws IOException {
+	public void testOpenArgsWithIncorrectPaths() {
 		FileSystem fs = Mockito.mock(FileSystem.class);
 		Mockito.when(fs.getPath("foo")).thenThrow(new InvalidPathException("foo", "foo is not a path"));
 		inTest.handleLaunchArgs(fs, new String[]{"foo"});
 
 		AppLaunchEvent evt = queue.poll();
-		Assertions.assertNotNull(evt);
+		Assertions.assertNull(evt);
-		List<Path> paths = evt.getPathsToOpen().collect(Collectors.toList());
-		Assertions.assertTrue(paths.isEmpty());
 	}
 
 	@Test
 	@DisplayName("./cryptomator.exe foo (with full event queue)")
-	public void testOpenArgsWithFullQueue() throws IOException {
+	public void testOpenArgsWithFullQueue() {
-		queue.add(new AppLaunchEvent(AppLaunchEvent.EventType.OPEN_FILE, Stream.empty()));
+		queue.add(new AppLaunchEvent(AppLaunchEvent.EventType.OPEN_FILE, Collections.emptyList()));
 		Assumptions.assumeTrue(queue.remainingCapacity() == 0);
 
 		inTest.handleLaunchArgs(new String[]{"foo"});

main/pom.xml

@@ -3,13 +3,13 @@
 	<modelVersion>4.0.0</modelVersion>
 	<groupId>org.cryptomator</groupId>
 	<artifactId>main</artifactId>
-	<version>1.5.0-beta1</version>
+	<version>1.5.0-beta3</version>
 	<packaging>pom</packaging>
 	<name>Cryptomator</name>
 
 	<organization>
 		<name>cryptomator.org</name>
-		<url>http://cryptomator.org</url>
+		<url>https://cryptomator.org</url>
 	</organization>
 
 	<developers>
@@ -23,35 +23,34 @@
 	<properties>
 		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 
-		<!-- dependency versions -->
+		<!-- cryptomator dependencies -->
-		<cryptomator.cryptofs.version>1.9.0-rc2</cryptomator.cryptofs.version>
+		<cryptomator.cryptofs.version>1.9.3</cryptomator.cryptofs.version>
-		<cryptomator.jni.version>2.2.1</cryptomator.jni.version>
+		<cryptomator.jni.version>2.2.2</cryptomator.jni.version>
-		<cryptomator.fuse.version>1.2.1</cryptomator.fuse.version>
+		<cryptomator.fuse.version>1.2.2</cryptomator.fuse.version>
-		<cryptomator.dokany.version>1.1.11</cryptomator.dokany.version>
+		<cryptomator.dokany.version>1.1.12</cryptomator.dokany.version>
 		<cryptomator.webdav.version>1.0.10</cryptomator.webdav.version>
 
-		<javafx.version>13.0.1</javafx.version>
+		<!-- 3rd party dependencies -->
-
+		<javafx.version>14-ea+8</javafx.version>
 		<commons-lang3.version>3.9</commons-lang3.version>
-
+		<jwt.version>3.8.3</jwt.version>
 		<easybind.version>1.0.3</easybind.version>
-
 		<guava.version>28.1-jre</guava.version>
-		<dagger.version>2.25.2</dagger.version>
+		<dagger.version>2.26</dagger.version>
 		<gson.version>2.8.6</gson.version>
-
 		<slf4j.version>1.7.29</slf4j.version>
 		<logback.version>1.2.3</logback.version>
 
-		<junit.jupiter.version>5.5.2</junit.jupiter.version>
+		<!-- test dependencies -->
-		<mockito.version>3.1.0</mockito.version>
+		<junit.jupiter.version>5.6.0</junit.jupiter.version>
+		<mockito.version>3.2.4</mockito.version>
 		<hamcrest.version>2.2</hamcrest.version>
 	</properties>
 
 	<repositories>
 		<repository>
 			<id>jcenter</id>
-			<url>http://jcenter.bintray.com</url>
+			<url>https://jcenter.bintray.com</url>
 		</repository>
 	</repositories>
 
@@ -156,6 +155,13 @@
 				<artifactId>commons-lang3</artifactId>
 				<version>${commons-lang3.version}</version>
 			</dependency>
+			
+			<!-- JWT -->
+			<dependency>
+				<groupId>com.auth0</groupId>
+				<artifactId>java-jwt</artifactId>
+				<version>${jwt.version}</version>
+			</dependency>
 
 			<!-- EasyBind -->
 			<dependency>

main/ui/pom.xml

@@ -4,7 +4,7 @@
 	<parent>
 		<groupId>org.cryptomator</groupId>
 		<artifactId>main</artifactId>
-		<version>1.5.0-beta1</version>
+		<version>1.5.0-beta3</version>
 	</parent>
 	<artifactId>ui</artifactId>
 	<name>Cryptomator GUI</name>
@@ -37,7 +37,7 @@
 		<dependency>
 			<groupId>org.fxmisc.easybind</groupId>
 			<artifactId>easybind</artifactId>
-		</dependency>	
+		</dependency>
 
 		<!-- Google -->
 		<dependency>
@@ -65,7 +65,7 @@
 		<dependency>
 			<groupId>com.nulab-inc</groupId>
 			<artifactId>zxcvbn</artifactId>
-			<version>1.2.7</version>
+			<version>1.3.0</version>
 		</dependency>
 		
 		<!-- Logging -->

main/ui/src/main/java/org/cryptomator/ui/addvaultwizard/AddVaultFailureExistingController.java

@@ -15,14 +15,14 @@ import javax.inject.Inject;
 import java.nio.file.Path;
 
 @AddVaultWizardScoped
-public class AddVaultFailureExisitingController implements FxController {
+public class AddVaultFailureExistingController implements FxController {
 
 	private final Stage window;
 	private final Lazy<Scene> previousScene;
 	private final StringBinding vaultName;
 
 	@Inject
-	AddVaultFailureExisitingController(@AddVaultWizardWindow Stage window, @FxmlScene(FxmlFile.ADDVAULT_EXISTING) Lazy<Scene> previousScene, ObjectProperty<Path> pathOfFailedVault){
+	AddVaultFailureExistingController(@AddVaultWizardWindow Stage window, @FxmlScene(FxmlFile.ADDVAULT_EXISTING) Lazy<Scene> previousScene, ObjectProperty<Path> pathOfFailedVault){
 		this.window = window;
 		this.previousScene = previousScene;
 		this.vaultName = Bindings.createStringBinding(() -> pathOfFailedVault.get().getFileName().toString(),pathOfFailedVault);

main/ui/src/main/java/org/cryptomator/ui/addvaultwizard/AddVaultModule.java

@@ -19,18 +19,28 @@ import org.cryptomator.ui.common.FxController;
 import org.cryptomator.ui.common.FxControllerKey;
 import org.cryptomator.ui.common.FxmlFile;
 import org.cryptomator.ui.common.FxmlScene;
+import org.cryptomator.ui.common.NewPasswordController;
+import org.cryptomator.ui.common.PasswordStrengthUtil;
 import org.cryptomator.ui.mainwindow.MainWindow;
+import org.cryptomator.ui.recoverykey.RecoveryKeyDisplayController;
 
 import javax.inject.Named;
 import javax.inject.Provider;
 import java.nio.file.Path;
+import java.util.List;
 import java.util.Map;
-import java.util.Optional;
 import java.util.ResourceBundle;
 
 @Module
 public abstract class AddVaultModule {
 
+	@Provides
+	@AddVaultWizardScoped
+	@Named("newPassword")
+	static ObjectProperty<CharSequence> provideNewPasswordProperty() {
+		return new SimpleObjectProperty<>("");
+	}
+
 	@Provides
 	@AddVaultWizardWindow
 	@AddVaultWizardScoped
@@ -41,13 +51,13 @@ public abstract class AddVaultModule {
 	@Provides
 	@AddVaultWizardWindow
 	@AddVaultWizardScoped
-	static Stage provideStage(@MainWindow Stage owner, ResourceBundle resourceBundle, @Named("windowIcon") Optional<Image> windowIcon) {
+	static Stage provideStage(@MainWindow Stage owner, ResourceBundle resourceBundle, @Named("windowIcons") List<Image> windowIcons) {
 		Stage stage = new Stage();
 		stage.setTitle(resourceBundle.getString("addvaultwizard.title"));
 		stage.setResizable(false);
 		stage.initModality(Modality.WINDOW_MODAL);
 		stage.initOwner(owner);
-		windowIcon.ifPresent(stage.getIcons()::add);
+		stage.getIcons().addAll(windowIcons);
 		return stage;
 	}
 
@@ -150,8 +160,8 @@ public abstract class AddVaultModule {
 
 	@Binds
 	@IntoMap
-	@FxControllerKey(AddVaultFailureExisitingController.class)
+	@FxControllerKey(AddVaultFailureExistingController.class)
-	abstract FxController bindAddVaultFailureExistingController(AddVaultFailureExisitingController controller);
+	abstract FxController bindAddVaultFailureExistingController(AddVaultFailureExistingController controller);
 
 	@Binds
 	@IntoMap
@@ -168,13 +178,27 @@ public abstract class AddVaultModule {
 	@FxControllerKey(CreateNewVaultPasswordController.class)
 	abstract FxController bindCreateNewVaultPasswordController(CreateNewVaultPasswordController controller);
 
-	@Binds
+	@Provides
 	@IntoMap
-	@FxControllerKey(AddVaultSuccessController.class)
+	@FxControllerKey(NewPasswordController.class)
-	abstract FxController bindAddVaultSuccessController(AddVaultSuccessController controller);
+	static FxController provideNewPasswordController(ResourceBundle resourceBundle, PasswordStrengthUtil strengthRater, @Named("newPassword") ObjectProperty<CharSequence> password) {
+		return new NewPasswordController(resourceBundle, strengthRater, password);
+	}
 
 	@Binds
 	@IntoMap
 	@FxControllerKey(CreateNewVaultRecoveryKeyController.class)
 	abstract FxController bindCreateNewVaultRecoveryKeyController(CreateNewVaultRecoveryKeyController controller);
+
+	@Provides
+	@IntoMap
+	@FxControllerKey(RecoveryKeyDisplayController.class)
+	static FxController provideRecoveryKeyDisplayController(@AddVaultWizardWindow Stage window, @Named("vaultName") StringProperty vaultName, @Named("recoveryKey") StringProperty recoveryKey, ResourceBundle localization) {
+		return new RecoveryKeyDisplayController(window, vaultName.get(), recoveryKey.get(), localization);
+	}
+
+	@Binds
+	@IntoMap
+	@FxControllerKey(AddVaultSuccessController.class)
+	abstract FxController bindAddVaultSuccessController(AddVaultSuccessController controller);
 }

main/ui/src/main/java/org/cryptomator/ui/addvaultwizard/CreateNewVaultLocationController.java

@@ -52,8 +52,10 @@ public class CreateNewVaultLocationController implements FxController {
 
 	private Path customVaultPath = DEFAULT_CUSTOM_VAULT_PATH;
 	public ToggleGroup predefinedLocationToggler;
+	public RadioButton iclouddriveRadioButton;
 	public RadioButton dropboxRadioButton;
 	public RadioButton gdriveRadioButton;
+	public RadioButton onedriveRadioButton;
 	public RadioButton customRadioButton;
 
 	@Inject
@@ -91,10 +93,14 @@ public class CreateNewVaultLocationController implements FxController {
 	}
 
 	private void togglePredefinedLocation(@SuppressWarnings("unused") ObservableValue<? extends Toggle> observable, @SuppressWarnings("unused") Toggle oldValue, Toggle newValue) {
-		if (dropboxRadioButton.equals(newValue)) {
+		if (iclouddriveRadioButton.equals(newValue)) {
+			vaultPath.set(locationPresets.getIclouddriveLocation().resolve(vaultName.get()));
+		} else if (dropboxRadioButton.equals(newValue)) {
 			vaultPath.set(locationPresets.getDropboxLocation().resolve(vaultName.get()));
 		} else if (gdriveRadioButton.equals(newValue)) {
 			vaultPath.set(locationPresets.getGdriveLocation().resolve(vaultName.get()));
+		} else if (onedriveRadioButton.equals(newValue)) {
+			vaultPath.set(locationPresets.getOnedriveLocation().resolve(vaultName.get()));
 		} else if (customRadioButton.equals(newValue)) {
 			vaultPath.set(customVaultPath.resolve(vaultName.get()));
 		}

main/ui/src/main/java/org/cryptomator/ui/addvaultwizard/CreateNewVaultPasswordController.java

@@ -5,16 +5,14 @@ import javafx.beans.binding.Bindings;
 import javafx.beans.binding.BooleanBinding;
 import javafx.beans.binding.ObjectBinding;
 import javafx.beans.property.BooleanProperty;
-import javafx.beans.property.IntegerProperty;
 import javafx.beans.property.ObjectProperty;
 import javafx.beans.property.SimpleBooleanProperty;
-import javafx.beans.property.SimpleIntegerProperty;
 import javafx.beans.property.StringProperty;
 import javafx.fxml.FXML;
 import javafx.scene.Scene;
 import javafx.scene.control.ContentDisplay;
-import javafx.scene.control.Label;
+import javafx.scene.control.Toggle;
-import javafx.scene.layout.HBox;
+import javafx.scene.control.ToggleGroup;
 import javafx.stage.Stage;
 import org.cryptomator.common.vaults.Vault;
 import org.cryptomator.common.vaults.VaultListManager;
@@ -24,11 +22,7 @@ import org.cryptomator.ui.common.FxController;
 import org.cryptomator.ui.common.FxmlFile;
 import org.cryptomator.ui.common.FxmlScene;
 import org.cryptomator.ui.common.Tasks;
-import org.cryptomator.ui.controls.FontAwesome5IconView;
-import org.cryptomator.ui.controls.NiceSecurePasswordField;
-import org.cryptomator.ui.common.PasswordStrengthUtil;
 import org.cryptomator.ui.recoverykey.RecoveryKeyFactory;
-import org.fxmisc.easybind.EasyBind;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -58,6 +52,7 @@ public class CreateNewVaultPasswordController implements FxController {
 	private final Stage window;
 	private final Lazy<Scene> chooseLocationScene;
 	private final Lazy<Scene> recoveryKeyScene;
+	private final Lazy<Scene> successScene;
 	private final ExecutorService executor;
 	private final RecoveryKeyFactory recoveryKeyFactory;
 	private final StringProperty vaultNameProperty;
@@ -66,26 +61,22 @@ public class CreateNewVaultPasswordController implements FxController {
 	private final StringProperty recoveryKeyProperty;
 	private final VaultListManager vaultListManager;
 	private final ResourceBundle resourceBundle;
-	private final PasswordStrengthUtil strengthRater;
+	private final ObjectProperty<CharSequence> password;
 	private final ReadmeGenerator readmeGenerator;
-	private final IntegerProperty passwordStrength;
 	private final BooleanProperty processing;
 	private final BooleanProperty readyToCreateVault;
 	private final ObjectBinding<ContentDisplay> createVaultButtonState;
 
-	public NiceSecurePasswordField passwordField;
+	public ToggleGroup recoveryKeyChoice;
-	public NiceSecurePasswordField reenterField;
+	public Toggle showRecoveryKey;
-	public Label passwordStrengthLabel;
+	public Toggle skipRecoveryKey;
-	public HBox passwordMatchBox;
-	public FontAwesome5IconView checkmark;
-	public FontAwesome5IconView cross;
-	public Label passwordMatchLabel;
 
 	@Inject
-	CreateNewVaultPasswordController(@AddVaultWizardWindow Stage window, @FxmlScene(FxmlFile.ADDVAULT_NEW_LOCATION) Lazy<Scene> chooseLocationScene, @FxmlScene(FxmlFile.ADDVAULT_NEW_RECOVERYKEY) Lazy<Scene> recoveryKeyScene, ExecutorService executor, RecoveryKeyFactory recoveryKeyFactory, @Named("vaultName") StringProperty vaultName, ObjectProperty<Path> vaultPath, @AddVaultWizardWindow ObjectProperty<Vault> vault, @Named("recoveryKey") StringProperty recoveryKey, VaultListManager vaultListManager, ResourceBundle resourceBundle, PasswordStrengthUtil strengthRater, ReadmeGenerator readmeGenerator) {
+	CreateNewVaultPasswordController(@AddVaultWizardWindow Stage window, @FxmlScene(FxmlFile.ADDVAULT_NEW_LOCATION) Lazy<Scene> chooseLocationScene, @FxmlScene(FxmlFile.ADDVAULT_NEW_RECOVERYKEY) Lazy<Scene> recoveryKeyScene, @FxmlScene(FxmlFile.ADDVAULT_SUCCESS) Lazy<Scene> successScene, ExecutorService executor, RecoveryKeyFactory recoveryKeyFactory, @Named("vaultName") StringProperty vaultName, ObjectProperty<Path> vaultPath, @AddVaultWizardWindow ObjectProperty<Vault> vault, @Named("recoveryKey") StringProperty recoveryKey, VaultListManager vaultListManager, ResourceBundle resourceBundle, @Named("newPassword") ObjectProperty<CharSequence> password, ReadmeGenerator readmeGenerator) {
 		this.window = window;
 		this.chooseLocationScene = chooseLocationScene;
 		this.recoveryKeyScene = recoveryKeyScene;
+		this.successScene = successScene;
 		this.executor = executor;
 		this.recoveryKeyFactory = recoveryKeyFactory;
 		this.vaultNameProperty = vaultName;
@@ -94,9 +85,8 @@ public class CreateNewVaultPasswordController implements FxController {
 		this.recoveryKeyProperty = recoveryKey;
 		this.vaultListManager = vaultListManager;
 		this.resourceBundle = resourceBundle;
-		this.strengthRater = strengthRater;
+		this.password = password;
 		this.readmeGenerator = readmeGenerator;
-		this.passwordStrength = new SimpleIntegerProperty(-1);
 		this.processing = new SimpleBooleanProperty();
 		this.readyToCreateVault = new SimpleBooleanProperty();
 		this.createVaultButtonState = Bindings.createObjectBinding(this::getCreateVaultButtonState, processing);
@@ -104,22 +94,8 @@ public class CreateNewVaultPasswordController implements FxController {
 
 	@FXML
 	public void initialize() {
-		//binds the actual strength value to the rating of the password util
+		BooleanBinding isValidNewPassword = Bindings.createBooleanBinding(() -> password.get() != null && password.get().length() > 0, password);
-		passwordStrength.bind(Bindings.createIntegerBinding(() -> strengthRater.computeRate(passwordField.getCharacters().toString()), passwordField.textProperty()));
+		readyToCreateVault.bind(isValidNewPassword.and(recoveryKeyChoice.selectedToggleProperty().isNotNull()).and(processing.not()));
-		//binding indicating if the passwords not match
-		BooleanBinding passwordsMatch = Bindings.createBooleanBinding(() -> CharSequence.compare(passwordField.getCharacters(), reenterField.getCharacters()) == 0, passwordField.textProperty(), reenterField.textProperty());
-		BooleanBinding reenterFieldNotEmpty = reenterField.textProperty().isNotEmpty();
-		readyToCreateVault.bind(reenterFieldNotEmpty.and(passwordsMatch).and(processing.not()));
-		//make match indicator invisible when passwords do not match or one is empty
-		passwordMatchBox.visibleProperty().bind(reenterFieldNotEmpty);
-		checkmark.visibleProperty().bind(passwordsMatch.and(reenterFieldNotEmpty));
-		checkmark.managedProperty().bind(checkmark.visibleProperty());
-		cross.visibleProperty().bind(passwordsMatch.not().and(reenterFieldNotEmpty));
-		cross.managedProperty().bind(cross.visibleProperty());
-		passwordMatchLabel.textProperty().bind(Bindings.when(passwordsMatch.and(reenterFieldNotEmpty)).then(resourceBundle.getString("addvaultwizard.new.passwordsMatch")).otherwise(resourceBundle.getString("addvaultwizard.new.passwordsDoNotMatch")));
-
-		//bindsings for the password strength indicator
-		passwordStrengthLabel.textProperty().bind(EasyBind.map(passwordStrength, strengthRater::getStrengthDescription));
 	}
 
 	@FXML
@@ -130,7 +106,7 @@ public class CreateNewVaultPasswordController implements FxController {
 	@FXML
 	public void next() {
 		Path pathToVault = vaultPathProperty.get();
-		
+
 		try {
 			Files.createDirectory(pathToVault);
 		} catch (FileAlreadyExistsException e) {
@@ -141,12 +117,41 @@ public class CreateNewVaultPasswordController implements FxController {
 			LOG.error("", e);
 		}
 
+		if (showRecoveryKey.equals(recoveryKeyChoice.getSelectedToggle())) {
+			showRecoveryKeyScene();
+		} else if (skipRecoveryKey.equals(recoveryKeyChoice.getSelectedToggle())) {
+			showSuccessScene();
+		} else {
+			throw new IllegalStateException("Unexpected toggle state");
+		}
+	}
+
+	private void showRecoveryKeyScene() {
+		Path pathToVault = vaultPathProperty.get();
 		processing.set(true);
 		Tasks.create(() -> {
-			initializeVault(pathToVault, passwordField.getCharacters());
+			initializeVault(pathToVault, password.get());
-			return recoveryKeyFactory.createRecoveryKey(pathToVault, passwordField.getCharacters());
+			return recoveryKeyFactory.createRecoveryKey(pathToVault, password.get());
 		}).onSuccess(recoveryKey -> {
-			initializationSucceeded(pathToVault, recoveryKey);
+			initializationSucceeded(pathToVault);
+			recoveryKeyProperty.set(recoveryKey);
+			window.setScene(recoveryKeyScene.get());
+		}).onError(IOException.class, e -> {
+			// TODO show generic error screen
+			LOG.error("", e);
+		}).andFinally(() -> {
+			processing.set(false);
+		}).runOnce(executor);
+	}
+
+	private void showSuccessScene() {
+		Path pathToVault = vaultPathProperty.get();
+		processing.set(true);
+		Tasks.create(() -> {
+			initializeVault(pathToVault, password.get());
+		}).onSuccess(() -> {
+			initializationSucceeded(pathToVault);
+			window.setScene(successScene.get());
 		}).onError(IOException.class, e -> {
 			// TODO show generic error screen
 			LOG.error("", e);
@@ -175,13 +180,11 @@ public class CreateNewVaultPasswordController implements FxController {
 		}
 		LOG.info("Created vault at {}", path);
 	}
-	
+
-	private void initializationSucceeded(Path pathToVault, String recoveryKey) {
+	private void initializationSucceeded(Path pathToVault) {
 		try {
 			Vault newVault = vaultListManager.add(pathToVault);
 			vaultProperty.set(newVault);
-			recoveryKeyProperty.set(recoveryKey);
-			window.setScene(recoveryKeyScene.get());
 		} catch (NoSuchFileException e) {
 			throw new UncheckedIOException(e);
 		}
@@ -197,14 +200,6 @@ public class CreateNewVaultPasswordController implements FxController {
 		return vaultNameProperty;
 	}
 
-	public IntegerProperty passwordStrengthProperty() {
-		return passwordStrength;
-	}
-
-	public int getPasswordStrength() {
-		return passwordStrength.get();
-	}
-
 	public BooleanProperty readyToCreateVaultProperty() {
 		return readyToCreateVault;
 	}

main/ui/src/main/java/org/cryptomator/ui/addvaultwizard/CreateNewVaultRecoveryKeyController.java

@@ -1,7 +1,6 @@
 package org.cryptomator.ui.addvaultwizard;
 
 import dagger.Lazy;
-import javafx.beans.property.StringProperty;
 import javafx.fxml.FXML;
 import javafx.scene.Scene;
 import javafx.stage.Stage;
@@ -10,33 +9,20 @@ import org.cryptomator.ui.common.FxmlFile;
 import org.cryptomator.ui.common.FxmlScene;
 
 import javax.inject.Inject;
-import javax.inject.Named;
 
 public class CreateNewVaultRecoveryKeyController implements FxController {
 
 	private final Stage window;
 	private final Lazy<Scene> successScene;
-	private final StringProperty recoveryKeyProperty;
 
 	@Inject
-	CreateNewVaultRecoveryKeyController(@AddVaultWizardWindow Stage window, @FxmlScene(FxmlFile.ADDVAULT_SUCCESS) Lazy<Scene> successScene, @Named("recoveryKey")StringProperty recoveryKey) {
+	CreateNewVaultRecoveryKeyController(@AddVaultWizardWindow Stage window, @FxmlScene(FxmlFile.ADDVAULT_SUCCESS) Lazy<Scene> successScene) {
 		this.window = window;
 		this.successScene = successScene;
-		this.recoveryKeyProperty = recoveryKey;
 	}
 
 	@FXML
 	public void next() {
 		window.setScene(successScene.get());
 	}
-
-	/* Getter/Setter */
-
-	public String getRecoveryKey() {
-		return recoveryKeyProperty.get();
-	}
-
-	public StringProperty recoveryKeyProperty() {
-		return recoveryKeyProperty;
-	}
 }

main/ui/src/main/java/org/cryptomator/ui/addvaultwizard/LocationPresets.java

@@ -13,20 +13,30 @@ import java.nio.file.Paths;
 public class LocationPresets {
 
 	private static final String USER_HOME = System.getProperty("user.home");
+	private static final String[] ICLOUDDRIVE_LOCATIONS = {"~/Library/Mobile Documents/iCloud~com~setolabs~Cryptomator/Documents"};
 	private static final String[] DROPBOX_LOCATIONS = {"~/Dropbox"};
 	private static final String[] GDRIVE_LOCATIONS = {"~/Google Drive"};
+	private static final String[] ONEDRIVE_LOCATIONS = {"~/OneDrive"};
 
+	private final ReadOnlyObjectProperty<Path> iclouddriveLocation;
 	private final ReadOnlyObjectProperty<Path> dropboxLocation;
 	private final ReadOnlyObjectProperty<Path> gdriveLocation;
+	private final ReadOnlyObjectProperty<Path> onedriveLocation;
+	private final BooleanBinding foundIclouddrive;
 	private final BooleanBinding foundDropbox;
 	private final BooleanBinding foundGdrive;
+	private final BooleanBinding foundOnedrive;
 
 	@Inject
 	public LocationPresets() {
+		this.iclouddriveLocation = new SimpleObjectProperty<>(existingWritablePath(ICLOUDDRIVE_LOCATIONS));
 		this.dropboxLocation = new SimpleObjectProperty<>(existingWritablePath(DROPBOX_LOCATIONS));
 		this.gdriveLocation = new SimpleObjectProperty<>(existingWritablePath(GDRIVE_LOCATIONS));
+		this.onedriveLocation = new SimpleObjectProperty<>(existingWritablePath(ONEDRIVE_LOCATIONS));
+		this.foundIclouddrive = iclouddriveLocation.isNotNull();
 		this.foundDropbox = dropboxLocation.isNotNull();
 		this.foundGdrive = gdriveLocation.isNotNull();
+		this.foundOnedrive = onedriveLocation.isNotNull();
 	}
 
 	private static Path existingWritablePath(String... candidates) {
@@ -49,6 +59,22 @@ public class LocationPresets {
 
 	/* Observables */
 
+	public ReadOnlyObjectProperty<Path> iclouddriveLocationProperty() {
+		return iclouddriveLocation;
+	}
+
+	public Path getIclouddriveLocation() {
+		return iclouddriveLocation.get();
+	}
+
+	public BooleanBinding foundIclouddriveProperty() {
+		return foundIclouddrive;
+	}
+
+	public boolean isFoundIclouddrive() {
+		return foundIclouddrive.get();
+	}
+
 	public ReadOnlyObjectProperty<Path> dropboxLocationProperty() {
 		return dropboxLocation;
 	}
@@ -73,7 +99,7 @@ public class LocationPresets {
 		return gdriveLocation.get();
 	}
 
-	public BooleanBinding froundGdriveProperty() {
+	public BooleanBinding foundGdriveProperty() {
 		return foundGdrive;
 	}
 
@@ -81,4 +107,20 @@ public class LocationPresets {
 		return foundGdrive.get();
 	}
 
+	public ReadOnlyObjectProperty<Path> onedriveLocationProperty() {
+		return onedriveLocation;
+	}
+
+	public Path getOnedriveLocation() {
+		return onedriveLocation.get();
+	}
+
+	public BooleanBinding foundOnedriveProperty() {
+		return foundOnedrive;
+	}
+
+	public boolean isFoundOnedrive() {
+		return foundOnedrive.get();
+	}
+
 }

main/ui/src/main/java/org/cryptomator/ui/addvaultwizard/ReadmeGenerator.java

@@ -10,7 +10,7 @@ public class ReadmeGenerator {
 	// specs: https://web.archive.org/web/20190708132914/http://www.kleinlercher.at/tools/Windows_Protocols/Word2007RTFSpec9.pdf
 	private static final String RTF_HEADER = "{\\rtf1\\fbidis\\ansi\\uc0\\fs32\n";
 	private static final String RTF_FOOTER = "}";
-	private static final String HELP_URL = "{\\field{\\*\\fldinst HYPERLINK \"http://www.google.com/\"}{\\fldrslt google.com}}";
+	private static final String HELP_URL = "{\\field{\\*\\fldinst HYPERLINK \"http://docs.cryptoamtor.org/\"}{\\fldrslt docs.cryptoamtor.org}}";
 
 	private final ResourceBundle resourceBundle;
 

main/ui/src/main/java/org/cryptomator/ui/changepassword/ChangePasswordController.java

@@ -3,6 +3,7 @@ package org.cryptomator.ui.changepassword;
 import javafx.beans.binding.Bindings;
 import javafx.beans.binding.BooleanBinding;
 import javafx.beans.property.IntegerProperty;
+import javafx.beans.property.ObjectProperty;
 import javafx.beans.property.SimpleIntegerProperty;
 import javafx.fxml.FXML;
 import javafx.scene.control.Button;
@@ -22,6 +23,7 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import javax.inject.Inject;
+import javax.inject.Named;
 import java.io.IOException;
 import java.util.ResourceBundle;
 
@@ -33,47 +35,24 @@ public class ChangePasswordController implements FxController {
 
 	private final Stage window;
 	private final Vault vault;
-	private final ResourceBundle resourceBundle;
+	private final ObjectProperty<CharSequence> newPassword;
-	private final PasswordStrengthUtil strengthRater;
-	private final IntegerProperty passwordStrength;
 
 	public NiceSecurePasswordField oldPasswordField;
-	public NiceSecurePasswordField newPasswordField;
-	public NiceSecurePasswordField reenterPasswordField;
-	public Label passwordStrengthLabel;
-	public HBox passwordMatchBox;
-	public FontAwesome5IconView checkmark;
-	public FontAwesome5IconView cross;
-	public Label passwordMatchLabel;
 	public CheckBox finalConfirmationCheckbox;
 	public Button finishButton;
 
 	@Inject
-	public ChangePasswordController(@ChangePasswordWindow Stage window, @ChangePasswordWindow Vault vault, ResourceBundle resourceBundle, PasswordStrengthUtil strengthRater) {
+	public ChangePasswordController(@ChangePasswordWindow Stage window, @ChangePasswordWindow Vault vault, @Named("newPassword") ObjectProperty<CharSequence> newPassword) {
 		this.window = window;
 		this.vault = vault;
-		this.resourceBundle = resourceBundle;
+		this.newPassword = newPassword;
-		this.strengthRater = strengthRater;
-		this.passwordStrength = new SimpleIntegerProperty(-1);
 	}
 
 	@FXML
 	public void initialize() {
-		//binds the actual strength value to the rating of the password util
+		BooleanBinding hasNotConfirmedCheckbox = finalConfirmationCheckbox.selectedProperty().not();
-		passwordStrength.bind(Bindings.createIntegerBinding(() -> strengthRater.computeRate(newPasswordField.getCharacters().toString()), newPasswordField.textProperty()));
+		BooleanBinding isInvalidNewPassword = Bindings.createBooleanBinding(() -> newPassword.get() == null || newPassword.get().length() == 0, newPassword); 
-		//binding indicating if the passwords not match
+		finishButton.disableProperty().bind(hasNotConfirmedCheckbox.or(isInvalidNewPassword));
-		BooleanBinding passwordsMatch = Bindings.createBooleanBinding(() -> CharSequence.compare(newPasswordField.getCharacters(), reenterPasswordField.getCharacters()) == 0, newPasswordField.textProperty(), reenterPasswordField.textProperty());
-		BooleanBinding reenterFieldNotEmpty = reenterPasswordField.textProperty().isNotEmpty();
-		//disable the finish button when passwords do not match or one is empty
-		finishButton.disableProperty().bind(reenterFieldNotEmpty.not().or(passwordsMatch.not()).or(finalConfirmationCheckbox.selectedProperty().not()));
-		//make match indicator invisible when passwords do not match or one is empty
-		passwordMatchBox.visibleProperty().bind(reenterFieldNotEmpty);
-		checkmark.visibleProperty().bind(passwordsMatch.and(reenterFieldNotEmpty));
-		checkmark.managedProperty().bind(checkmark.visibleProperty());
-		cross.visibleProperty().bind(passwordsMatch.not().and(reenterFieldNotEmpty));
-		cross.managedProperty().bind(cross.visibleProperty());
-		passwordMatchLabel.textProperty().bind(Bindings.when(passwordsMatch.and(reenterFieldNotEmpty)).then(resourceBundle.getString("changepassword.passwordsMatch")).otherwise(resourceBundle.getString("changepassword.passwordsDoNotMatch")));
-		passwordStrengthLabel.textProperty().bind(EasyBind.map(passwordStrength, strengthRater::getStrengthDescription));
 	}
 
 	@FXML
@@ -84,15 +63,15 @@ public class ChangePasswordController implements FxController {
 	@FXML
 	public void finish() {
 		try {
-			CryptoFileSystemProvider.changePassphrase(vault.getPath(), MASTERKEY_FILENAME, oldPasswordField.getCharacters(), newPasswordField.getCharacters());
+			CryptoFileSystemProvider.changePassphrase(vault.getPath(), MASTERKEY_FILENAME, oldPasswordField.getCharacters(), newPassword.get());
 			LOG.info("Successful changed password for {}", vault.getDisplayableName());
 			window.close();
 		} catch (IOException e) {
-			//TODO
+			// TODO show generic error screen
 			LOG.error("IO error occured during password change. Unable to perform operation.", e);
 			e.printStackTrace();
 		} catch (InvalidPassphraseException e) {
-			//TODO
+			// TODO shake
 			LOG.info("Wrong old password.");
 		}
 	}
@@ -102,12 +81,5 @@ public class ChangePasswordController implements FxController {
 	public Vault getVault() {
 		return vault;
 	}
-
+	
-	public IntegerProperty passwordStrengthProperty() {
-		return passwordStrength;
-	}
-
-	public int getPasswordStrength() {
-		return passwordStrength.get();
-	}
 }

main/ui/src/main/java/org/cryptomator/ui/changepassword/ChangePasswordModule.java

@@ -4,6 +4,8 @@ import dagger.Binds;
 import dagger.Module;
 import dagger.Provides;
 import dagger.multibindings.IntoMap;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleObjectProperty;
 import javafx.scene.Scene;
 import javafx.scene.image.Image;
 import javafx.stage.Modality;
@@ -14,15 +16,25 @@ import org.cryptomator.ui.common.FxController;
 import org.cryptomator.ui.common.FxControllerKey;
 import org.cryptomator.ui.common.FxmlFile;
 import org.cryptomator.ui.common.FxmlScene;
+import org.cryptomator.ui.common.NewPasswordController;
+import org.cryptomator.ui.common.PasswordStrengthUtil;
 
 import javax.inject.Named;
 import javax.inject.Provider;
+import java.nio.CharBuffer;
+import java.util.List;
 import java.util.Map;
-import java.util.Optional;
 import java.util.ResourceBundle;
 
 @Module
 abstract class ChangePasswordModule {
+	
+	@Provides
+	@ChangePasswordScoped
+	@Named("newPassword")
+	static ObjectProperty<CharSequence> provideNewPasswordProperty() {
+		return new SimpleObjectProperty<>("");
+	}
 
 	@Provides
 	@ChangePasswordWindow
@@ -34,13 +46,13 @@ abstract class ChangePasswordModule {
 	@Provides
 	@ChangePasswordWindow
 	@ChangePasswordScoped
-	static Stage provideStage(@Named("changePasswordOwner") Stage owner, ResourceBundle resourceBundle, @Named("windowIcon") Optional<Image> windowIcon) {
+	static Stage provideStage(@Named("changePasswordOwner") Stage owner, ResourceBundle resourceBundle, @Named("windowIcons") List<Image> windowIcons) {
 		Stage stage = new Stage();
 		stage.setTitle(resourceBundle.getString("changepassword.title"));
 		stage.setResizable(false);
 		stage.initModality(Modality.WINDOW_MODAL);
 		stage.initOwner(owner);
-		windowIcon.ifPresent(stage.getIcons()::add);
+		stage.getIcons().addAll(windowIcons);
 		return stage;
 	}
 
@@ -58,5 +70,12 @@ abstract class ChangePasswordModule {
 	@IntoMap
 	@FxControllerKey(ChangePasswordController.class)
 	abstract FxController bindUnlockController(ChangePasswordController controller);
+	
+	@Provides
+	@IntoMap
+	@FxControllerKey(NewPasswordController.class)
+	static FxController provideNewPasswordController(ResourceBundle resourceBundle, PasswordStrengthUtil strengthRater, @Named("newPassword") ObjectProperty<CharSequence> password) {
+		return new NewPasswordController(resourceBundle, strengthRater, password);
+	}
 
 }

main/ui/src/main/java/org/cryptomator/ui/common/Animations.java

@@ -0,0 +1,36 @@
+package org.cryptomator.ui.common;
+
+import javafx.animation.KeyFrame;
+import javafx.animation.KeyValue;
+import javafx.animation.Timeline;
+import javafx.beans.value.WritableValue;
+import javafx.stage.Window;
+import javafx.util.Duration;
+
+public class Animations {
+	
+	public static Timeline createShakeWindowAnimation(Window window) {
+		WritableValue<Double> writableWindowX = new WritableValue<>() {
+			@Override
+			public Double getValue() {
+				return window.getX();
+			}
+
+			@Override
+			public void setValue(Double value) {
+				window.setX(value);
+			}
+		};
+		return new Timeline( //
+				new KeyFrame(Duration.ZERO, new KeyValue(writableWindowX, window.getX())), //
+				new KeyFrame(new Duration(100), new KeyValue(writableWindowX, window.getX() - 22.0)), //
+				new KeyFrame(new Duration(200), new KeyValue(writableWindowX, window.getX() + 18.0)), //
+				new KeyFrame(new Duration(300), new KeyValue(writableWindowX, window.getX() - 14.0)), //
+				new KeyFrame(new Duration(400), new KeyValue(writableWindowX, window.getX() + 10.0)), //
+				new KeyFrame(new Duration(500), new KeyValue(writableWindowX, window.getX() - 6.0)), //
+				new KeyFrame(new Duration(600), new KeyValue(writableWindowX, window.getX() + 2.0)), //
+				new KeyFrame(new Duration(700), new KeyValue(writableWindowX, window.getX())) //
+		);
+	}
+
+}

main/ui/src/main/java/org/cryptomator/ui/common/FxmlFile.java

@@ -12,15 +12,21 @@ public enum FxmlFile {
 	CHANGEPASSWORD("/fxml/changepassword.fxml"), //
 	FORGET_PASSWORD("/fxml/forget_password.fxml"), //
 	MAIN_WINDOW("/fxml/main_window.fxml"), //
+	MIGRATION_CAPABILITY_ERROR("/fxml/migration_capability_error.fxml"), //
+	MIGRATION_GENERIC_ERROR("/fxml/migration_generic_error.fxml"), //
 	MIGRATION_RUN("/fxml/migration_run.fxml"), //
 	MIGRATION_START("/fxml/migration_start.fxml"), //
 	MIGRATION_SUCCESS("/fxml/migration_success.fxml"), //
 	PREFERENCES("/fxml/preferences.fxml"), //
 	QUIT("/fxml/quit.fxml"), //
 	RECOVERYKEY_CREATE("/fxml/recoverykey_create.fxml"), //
-	RECOVERYKEY_DISPLAY("/fxml/recoverykey_display.fxml"), //
+	RECOVERYKEY_RECOVER("/fxml/recoverykey_recover.fxml"), //
+	RECOVERYKEY_RESET_PASSWORD("/fxml/recoverykey_reset_password.fxml"), //
+	RECOVERYKEY_SUCCESS("/fxml/recoverykey_success.fxml"), //
 	REMOVE_VAULT("/fxml/remove_vault.fxml"), //
 	UNLOCK("/fxml/unlock.fxml"),
+	UNLOCK_GENERIC_ERROR("/fxml/unlock_generic_error.fxml"), //
+	UNLOCK_INVALID_MOUNT_POINT("/fxml/unlock_invalid_mount_point.fxml"), //
 	UNLOCK_SUCCESS("/fxml/unlock_success.fxml"), //
 	VAULT_OPTIONS("/fxml/vault_options.fxml"), //
 	WRONGFILEALERT("/fxml/wrongfilealert.fxml");

main/ui/src/main/java/org/cryptomator/ui/common/NewPasswordController.java

@@ -0,0 +1,74 @@
+package org.cryptomator.ui.common;
+
+import javafx.beans.Observable;
+import javafx.beans.binding.Bindings;
+import javafx.beans.binding.BooleanBinding;
+import javafx.beans.property.IntegerProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleIntegerProperty;
+import javafx.fxml.FXML;
+import javafx.scene.control.Label;
+import org.cryptomator.ui.controls.FontAwesome5IconView;
+import org.cryptomator.ui.controls.NiceSecurePasswordField;
+import org.fxmisc.easybind.EasyBind;
+
+import java.util.ResourceBundle;
+
+public class NewPasswordController implements FxController {
+
+	private final ResourceBundle resourceBundle;
+	private final PasswordStrengthUtil strengthRater;
+	private final ObjectProperty<CharSequence> password;
+	private final IntegerProperty passwordStrength = new SimpleIntegerProperty(-1);
+
+	public NiceSecurePasswordField passwordField;
+	public NiceSecurePasswordField reenterField;
+	public Label passwordStrengthLabel;
+	public Label passwordMatchLabel;
+	public FontAwesome5IconView checkmark;
+	public FontAwesome5IconView cross;
+
+	public NewPasswordController(ResourceBundle resourceBundle, PasswordStrengthUtil strengthRater, ObjectProperty<CharSequence> password) {
+		this.resourceBundle = resourceBundle;
+		this.strengthRater = strengthRater;
+		this.password = password;
+	}
+
+	@FXML
+	public void initialize() {
+		BooleanBinding passwordsMatch = Bindings.createBooleanBinding(this::hasSamePasswordInBothFields, passwordField.textProperty(), reenterField.textProperty());
+		BooleanBinding reenterFieldNotEmpty = reenterField.textProperty().isNotEmpty();
+		passwordStrength.bind(Bindings.createIntegerBinding(() -> strengthRater.computeRate(passwordField.getCharacters()), passwordField.textProperty()));
+		passwordStrengthLabel.textProperty().bind(EasyBind.map(passwordStrength, strengthRater::getStrengthDescription));
+		
+		passwordMatchLabel.visibleProperty().bind(reenterFieldNotEmpty);
+		passwordMatchLabel.graphicProperty().bind(Bindings.when(passwordsMatch.and(reenterFieldNotEmpty)).then(checkmark).otherwise(cross));
+		passwordMatchLabel.textProperty().bind(Bindings.when(passwordsMatch.and(reenterFieldNotEmpty)).then(resourceBundle.getString("newPassword.passwordsMatch")).otherwise(resourceBundle.getString("newPassword.passwordsDoNotMatch")));
+
+		passwordField.textProperty().addListener(this::passwordsDidChange);
+		reenterField.textProperty().addListener(this::passwordsDidChange);
+	}
+
+	private void passwordsDidChange(@SuppressWarnings("unused") Observable observable) {
+		if (hasSamePasswordInBothFields() && strengthRater.fulfillsMinimumRequirements(passwordField.getCharacters())) {
+			password.set(passwordField.getCharacters());
+		} else {
+			password.set("");
+		}
+	}
+
+	private boolean hasSamePasswordInBothFields() {
+		return CharSequence.compare(passwordField.getCharacters(), reenterField.getCharacters()) == 0;
+	}
+
+	/* Getter/Setter */
+
+	public IntegerProperty passwordStrengthProperty() {
+		return passwordStrength;
+	}
+
+	public int getPasswordStrength() {
+		return passwordStrength.get();
+	}
+
+}

main/ui/src/main/java/org/cryptomator/ui/common/PasswordStrengthUtil.java

@@ -8,12 +8,11 @@
  *******************************************************************************/
 package org.cryptomator.ui.common;
 
-import com.google.common.base.Strings;
 import com.nulabinc.zxcvbn.Zxcvbn;
+import org.cryptomator.common.Environment;
 import org.cryptomator.ui.fxapp.FxApplicationScoped;
 
 import javax.inject.Inject;
-import java.util.ArrayList;
 import java.util.List;
 import java.util.ResourceBundle;
 
@@ -22,30 +21,37 @@ public class PasswordStrengthUtil {
 
 	private static final int PW_TRUNC_LEN = 100; // truncate very long passwords, since zxcvbn memory and runtime depends vastly on the length
 	private static final String RESSOURCE_PREFIX = "passwordStrength.messageLabel.";
+	private static final List<String> SANITIZED_INPUTS = List.of("cryptomator");
 
-	private final Zxcvbn zxcvbn;
-	private final List<String> sanitizedInputs;
 	private final ResourceBundle resourceBundle;
+	private final int minPwLength;
+	private final Zxcvbn zxcvbn;
 
 	@Inject
-	public PasswordStrengthUtil(ResourceBundle resourceBundle) {
+	public PasswordStrengthUtil(ResourceBundle resourceBundle, Environment environment) {
 		this.resourceBundle = resourceBundle;
+		this.minPwLength = environment.getMinPwLength();
 		this.zxcvbn = new Zxcvbn();
-		this.sanitizedInputs = List.of("cryptomator");
 	}
 
-	public int computeRate(String password) {
+	public boolean fulfillsMinimumRequirements(CharSequence password) {
-		if (Strings.isNullOrEmpty(password)) {
+		return password.length() >= minPwLength;
+	}
+
+	public int computeRate(CharSequence password) {
+		if (password == null || password.length() < minPwLength) {
 			return -1;
 		} else {
 			int numCharsToRate = Math.min(PW_TRUNC_LEN, password.length());
-			return zxcvbn.measure(password.substring(0, numCharsToRate), sanitizedInputs).getScore();
+			return zxcvbn.measure(password.subSequence(0, numCharsToRate), SANITIZED_INPUTS).getScore();
 		}
 	}
 
 	public String getStrengthDescription(Number score) {
-		if (resourceBundle.containsKey(RESSOURCE_PREFIX + score.intValue())) {
+		if (score.intValue() == -1) {
-			return resourceBundle.getString("passwordStrength.messageLabel." + score.intValue());
+			return String.format(resourceBundle.getString(RESSOURCE_PREFIX + "tooShort"), minPwLength);
+		} else if (resourceBundle.containsKey(RESSOURCE_PREFIX + score.intValue())) {
+			return resourceBundle.getString(RESSOURCE_PREFIX + score.intValue());
 		} else {
 			return "";
 		}

main/ui/src/main/java/org/cryptomator/ui/common/StackTraceController.java

@@ -0,0 +1,28 @@
+package org.cryptomator.ui.common;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+import java.nio.charset.StandardCharsets;
+
+public class StackTraceController implements FxController {
+
+	private final String stackTrace;
+
+	public StackTraceController(Throwable cause) {
+		this.stackTrace = provideStackTrace(cause);
+	}
+
+	private static String provideStackTrace(Throwable cause) {
+		ByteArrayOutputStream baos = new ByteArrayOutputStream();
+		cause.printStackTrace(new PrintStream(baos));
+		return baos.toString(StandardCharsets.UTF_8);
+	}
+
+	/* Getter/Setter */
+
+	public String getStackTrace() {
+		return stackTrace;
+	}
+
+
+}

main/ui/src/main/java/org/cryptomator/ui/common/Tasks.java

@@ -73,21 +73,21 @@ public class Tasks {
 			return new TaskImpl<>(callable, successHandler, errorHandlers, finallyHandler);
 		}
 
-		public Task<T> runOnce(ExecutorService executorService) {
+		public Task<T> runOnce(ExecutorService executor) {
 			Task<T> task = build();
-			executorService.submit(task);
+			executor.submit(task);
 			return task;
 		}
 
-		public Task<T> scheduleOnce(ScheduledExecutorService executorService, long delay, TimeUnit unit) {
+		public Task<T> scheduleOnce(ScheduledExecutorService scheduler, long delay, TimeUnit unit) {
 			Task<T> task = build();
-			executorService.schedule(task, delay, unit);
+			scheduler.schedule(task, delay, unit);
 			return task;
 		}
 
-		public ScheduledService<T> schedulePeriodically(ExecutorService executorService, Duration initialDelay, Duration period) {
+		public ScheduledService<T> schedulePeriodically(ExecutorService executor, Duration initialDelay, Duration period) {
 			ScheduledService<T> service = new RestartingService<>(this::build);
-			service.setExecutor(executorService);
+			service.setExecutor(executor);
 			service.setDelay(initialDelay);
 			service.setPeriod(period);
 			Platform.runLater(service::start);

main/ui/src/main/java/org/cryptomator/ui/common/VaultService.java

@@ -0,0 +1,350 @@
+package org.cryptomator.ui.common;
+
+import javafx.concurrent.Task;
+import org.cryptomator.common.vaults.Vault;
+import org.cryptomator.common.vaults.VaultState;
+import org.cryptomator.common.vaults.Volume;
+import org.cryptomator.cryptolib.api.InvalidPassphraseException;
+import org.cryptomator.keychain.KeychainAccess;
+import org.cryptomator.ui.fxapp.FxApplicationScoped;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.inject.Inject;
+import java.nio.CharBuffer;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.stream.Collectors;
+
+@FxApplicationScoped
+public class VaultService {
+
+	private static final Logger LOG = LoggerFactory.getLogger(VaultService.class);
+
+	private final ExecutorService executorService;
+	private final Optional<KeychainAccess> keychain;
+
+	@Inject
+	public VaultService(ExecutorService executorService, Optional<KeychainAccess> keychain) {
+		this.executorService = executorService;
+		this.keychain = keychain;
+	}
+
+	public void reveal(Vault vault) {
+		executorService.execute(createRevealTask(vault));
+	}
+
+	/**
+	 * Creates but doesn't start a reveal task.
+	 *
+	 * @param vault The vault to reveal
+	 */
+	public Task<Vault> createRevealTask(Vault vault) {
+		Task<Vault> task = new RevealVaultTask(vault);
+		task.setOnSucceeded(evt -> LOG.info("Revealed {}", vault.getDisplayableName()));
+		task.setOnFailed(evt -> LOG.error("Failed to reveal " + vault.getDisplayableName(), evt.getSource().getException()));
+		return task;
+	}
+
+	/**
+	 * Attempts to unlock all given vaults in a background thread using passwords stored in the system keychain.
+	 *
+	 * @param vaults The vaults to unlock
+	 * @implNote No-op if no system keychain is present
+	 */
+	public void attemptAutoUnlock(Collection<Vault> vaults) {
+		if (!keychain.isPresent()) {
+			LOG.debug("No system keychain found. Unable to auto unlock without saved passwords.");
+		} else {
+			for (Vault vault : vaults) {
+				attemptAutoUnlock(vault, keychain.get());
+			}
+		}
+	}
+
+	/**
+	 * Unlocks a vault in a background thread using a stored passphrase
+	 *
+	 * @param vault The vault to unlock
+	 * @param keychainAccess The system keychain holding the passphrase for the vault
+	 */
+	public void attemptAutoUnlock(Vault vault, KeychainAccess keychainAccess) {
+		executorService.execute(createAutoUnlockTask(vault, keychainAccess));
+	}
+
+	/**
+	 * Creates but doesn't start an auto-unlock task.
+	 *
+	 * @param vault The vault to unlock
+	 * @param keychainAccess The system keychain holding the passphrase for the vault
+	 * @return The task
+	 */
+	public Task<Vault> createAutoUnlockTask(Vault vault, KeychainAccess keychainAccess) {
+		Task<Vault> task = new AutoUnlockVaultTask(vault, keychainAccess);
+		task.setOnSucceeded(evt -> LOG.info("Auto-unlocked {}", vault.getDisplayableName()));
+		task.setOnFailed(evt -> LOG.error("Failed to auto-unlock " + vault.getDisplayableName(), evt.getSource().getException()));
+		return task;
+	}
+
+	/**
+	 * Unlocks a vault in a background thread
+	 *
+	 * @param vault The vault to unlock
+	 * @param passphrase The password to use - wipe this param asap
+	 * @implNote A copy of the passphrase will be made, which is wiped as soon as the task ran.
+	 */
+	public void unlock(Vault vault, CharSequence passphrase) {
+		executorService.execute(createUnlockTask(vault, passphrase));
+	}
+
+	/**
+	 * Creates but doesn't start an unlock task.
+	 *
+	 * @param vault The vault to unlock
+	 * @param passphrase The password to use - wipe this param asap
+	 * @return The task
+	 * @implNote A copy of the passphrase will be made, which is wiped as soon as the task ran.
+	 */
+	public Task<Vault> createUnlockTask(Vault vault, CharSequence passphrase) {
+		Task<Vault> task = new UnlockVaultTask(vault, passphrase);
+		task.setOnSucceeded(evt -> LOG.info("Unlocked {}", vault.getDisplayableName()));
+		task.setOnFailed(evt -> LOG.error("Failed to unlock " + vault.getDisplayableName(), evt.getSource().getException()));
+		return task;
+	}
+
+	/**
+	 * Locks a vault in a background thread.
+	 *
+	 * @param vault The vault to lock
+	 * @param forced Whether to attempt a forced lock
+	 */
+	public void lock(Vault vault, boolean forced) {
+		executorService.execute(createLockTask(vault, forced));
+	}
+
+	/**
+	 * Creates but doesn't start a lock task.
+	 *
+	 * @param vault The vault to lock
+	 * @param forced Whether to attempt a forced lock
+	 * @return The task
+	 */
+	public Task<Vault> createLockTask(Vault vault, boolean forced) {
+		Task<Vault> task = new LockVaultTask(vault, forced);
+		task.setOnSucceeded(evt -> LOG.info("Locked {}", vault.getDisplayableName()));
+		task.setOnFailed(evt -> LOG.error("Failed to lock " + vault.getDisplayableName(), evt.getSource().getException()));
+		return task;
+	}
+
+	/**
+	 * Locks all given vaults in a background thread.
+	 *
+	 * @param vaults The vaults to lock
+	 * @param forced Whether to attempt a forced lock
+	 */
+	public void lockAll(Collection<Vault> vaults, boolean forced) {
+		executorService.execute(createLockAllTask(vaults, forced));
+	}
+
+	/**
+	 * Creates but doesn't start a lock-all task.
+	 *
+	 * @param vaults The list of vaults to be locked
+	 * @param forced Whether to attempt a forced lock
+	 * @return Meta-Task that waits until all vaults are locked or fails after the first failure of a subtask
+	 */
+	public Task<Collection<Vault>> createLockAllTask(Collection<Vault> vaults, boolean forced) {
+		List<Task<Vault>> lockTasks = vaults.stream().map(v -> new LockVaultTask(v, forced)).collect(Collectors.toUnmodifiableList());
+		lockTasks.forEach(executorService::execute);
+		Task<Collection<Vault>> task = new WaitForTasksTask(lockTasks);
+		String vaultNames = vaults.stream().map(Vault::getDisplayableName).collect(Collectors.joining(", "));
+		task.setOnSucceeded(evt -> LOG.info("Locked {}", vaultNames));
+		task.setOnFailed(evt -> LOG.error("Failed to lock vaults " + vaultNames, evt.getSource().getException()));
+		return task;
+	}
+
+	private static class RevealVaultTask extends Task<Vault> {
+
+		private final Vault vault;
+
+		/**
+		 * @param vault The vault to lock
+		 */
+		public RevealVaultTask(Vault vault) {
+			this.vault = vault;
+		}
+
+		@Override
+		protected Vault call() throws Volume.VolumeException {
+			vault.reveal();
+			return vault;
+		}
+	}
+
+	/**
+	 * A task that waits for completion of multiple other tasks
+	 */
+	private static class WaitForTasksTask extends Task<Collection<Vault>> {
+
+		private final Collection<Task<Vault>> startedTasks;
+
+		public WaitForTasksTask(Collection<Task<Vault>> tasks) {
+			this.startedTasks = List.copyOf(tasks);
+		}
+
+		@Override
+		protected Collection<Vault> call() throws Exception {
+			Iterator<Task<Vault>> remainingTasks = startedTasks.iterator();
+			Collection<Vault> completed = new ArrayList<>();
+			try {
+				// wait for all tasks:
+				while (remainingTasks.hasNext()) {
+					Vault lockedVault = remainingTasks.next().get();
+					completed.add(lockedVault);
+				}
+			} catch (ExecutionException e) {
+				// cancel all remaining:
+				while (remainingTasks.hasNext()) {
+					remainingTasks.next().cancel(true);
+				}
+				throw e;
+			}
+			return List.copyOf(completed);
+		}
+	}
+
+	private static class AutoUnlockVaultTask extends Task<Vault> {
+
+		private final Vault vault;
+		private final KeychainAccess keychain;
+
+		public AutoUnlockVaultTask(Vault vault, KeychainAccess keychain) {
+			this.vault = vault;
+			this.keychain = keychain;
+		}
+
+		@Override
+		protected Vault call() throws Exception {
+			char[] storedPw = null;
+			try {
+				storedPw = keychain.loadPassphrase(vault.getId());
+				if (storedPw == null) {
+					throw new InvalidPassphraseException();
+				}
+				vault.unlock(CharBuffer.wrap(storedPw));
+			} finally {
+				if (storedPw != null) {
+					Arrays.fill(storedPw, ' ');
+				}
+			}
+			return vault;
+		}
+
+		@Override
+		protected void scheduled() {
+			vault.setState(VaultState.PROCESSING);
+		}
+
+		@Override
+		protected void succeeded() {
+			vault.setState(VaultState.UNLOCKED);
+		}
+
+		@Override
+		protected void failed() {
+			vault.setState(VaultState.LOCKED);
+		}
+	}
+
+	private static class UnlockVaultTask extends Task<Vault> {
+
+		private final Vault vault;
+		private final CharBuffer passphrase;
+
+		/**
+		 * @param vault The vault to unlock
+		 * @param passphrase The password to use - wipe this param asap
+		 * @implNote A copy of the passphrase will be made, which is wiped as soon as the task ran.
+		 */
+		public UnlockVaultTask(Vault vault, CharSequence passphrase) {
+			this.vault = vault;
+			this.passphrase = CharBuffer.allocate(passphrase.length());
+			for (int i = 0; i < passphrase.length(); i++) {
+				this.passphrase.put(i, passphrase.charAt(i));
+			}
+		}
+
+		@Override
+		protected Vault call() throws Exception {
+			try {
+				vault.unlock(passphrase);
+			} finally {
+				Arrays.fill(passphrase.array(), ' ');
+			}
+			return vault;
+		}
+
+		@Override
+		protected void scheduled() {
+			vault.setState(VaultState.PROCESSING);
+		}
+
+		@Override
+		protected void succeeded() {
+			vault.setState(VaultState.UNLOCKED);
+		}
+
+		@Override
+		protected void failed() {
+			vault.setState(VaultState.LOCKED);
+		}
+	}
+
+	/**
+	 * A task that locks a vault
+	 */
+	private static class LockVaultTask extends Task<Vault> {
+
+		private final Vault vault;
+		private final boolean forced;
+
+		/**
+		 * @param vault The vault to lock
+		 * @param forced Whether to attempt a forced lock
+		 */
+		public LockVaultTask(Vault vault, boolean forced) {
+			this.vault = vault;
+			this.forced = forced;
+		}
+
+		@Override
+		protected Vault call() throws Volume.VolumeException {
+			vault.lock(forced);
+			return vault;
+		}
+
+		@Override
+		protected void scheduled() {
+			vault.setState(VaultState.PROCESSING);
+		}
+
+		@Override
+		protected void succeeded() {
+			vault.setState(VaultState.LOCKED);
+		}
+
+		@Override
+		protected void failed() {
+			vault.setState(VaultState.UNLOCKED);
+		}
+
+	}
+
+
+}

main/ui/src/main/java/org/cryptomator/ui/controls/FontAwesome5Icon.java

@@ -5,28 +5,35 @@ package org.cryptomator.ui.controls;
  */
 public enum FontAwesome5Icon {
 	ANCHOR("\uF13D"), //
-	ARROW_ALT_UP("\uF357"), //
+	ARROW_UP("\uF062"), //
 	CHECK("\uF00C"), //
 	COG("\uF013"), //
 	COGS("\uF085"), //
-	EXCLAMATION("\uF12A"),
+	COPY("\uF0C5"), //
+	CROWN("\uF521"), //
+	EXCLAMATION("\uF12A"), //
+	EXCLAMATION_CIRCLE("\uF06A"), //
 	EXCLAMATION_TRIANGLE("\uF071"), //
 	EYE("\uF06E"), //
 	EYE_SLASH("\uF070"), //
 	FILE_IMPORT("\uF56F"), //
 	FOLDER_OPEN("\uF07C"), //
+	HAND_HOLDING_HEART("\uF4BE"), //
+	HEART("\uF004"), //
 	HDD("\uF0A0"), //
 	KEY("\uF084"), //
-	LOCK_ALT("\uF30D"), //
+	LINK("\uF0C1"), //
-	LOCK_OPEN_ALT("\uF3C2"), //
+	LOCK("\uF023"), //
-	MINUS("\uF068"), //
+	LOCK_OPEN("\uF3C1"), //
+	MAGIC("\uF0D0"), //
 	PLUS("\uF067"), //
+	PRINT("\uF02F"), //
 	QUESTION("\uF128"), //
-	SPARKLES("\uF890"), //
 	SPINNER("\uF110"), //
 	SYNC("\uF021"), //
 	TIMES("\uF00D"), //
 	WRENCH("\uF0AD"), //
+	WINDOW_MINIMIZE("\uF2D1"), //
 	;
 
 	private final String unicode;

main/ui/src/main/java/org/cryptomator/ui/controls/FontAwesome5IconView.java

@@ -18,7 +18,7 @@ public class FontAwesome5IconView extends Text {
 
 	private static final FontAwesome5Icon DEFAULT_GLYPH = FontAwesome5Icon.ANCHOR;
 	private static final double DEFAULT_GLYPH_SIZE = 12.0;
-	private static final String FONT_PATH = "/css/fontawesome5-pro-solid.otf";
+	private static final String FONT_PATH = "/css/fontawesome5-free-solid.otf";
 	private static final Font FONT;
 
 	private ObjectProperty<FontAwesome5Icon> glyph = new SimpleObjectProperty<>(this, "glyph", DEFAULT_GLYPH);

main/ui/src/main/java/org/cryptomator/ui/controls/NiceSecurePasswordField.java

@@ -32,7 +32,7 @@ public class NiceSecurePasswordField extends StackPane {
 		iconContainer.getStyleClass().add(ICONS_STLYE_CLASS);
 		StackPane.setAlignment(iconContainer, Pos.CENTER_RIGHT);
 
-		capsLockedIcon.setGlyph(FontAwesome5Icon.ARROW_ALT_UP);
+		capsLockedIcon.setGlyph(FontAwesome5Icon.ARROW_UP);
 		capsLockedIcon.setGlyphSize(ICON_SIZE);
 		capsLockedIcon.visibleProperty().bind(passwordField.capsLockedProperty());
 		capsLockedIcon.managedProperty().bind(passwordField.capsLockedProperty());
@@ -89,7 +89,7 @@ public class NiceSecurePasswordField extends StackPane {
 	}
 
 	public void swipe() {
-		passwordField.swipe();;
+		passwordField.swipe();
 	}
 
 	public void selectAll() {

main/ui/src/main/java/org/cryptomator/ui/forgetPassword/ForgetPasswordModule.java

@@ -20,8 +20,8 @@ import org.cryptomator.ui.common.FxmlScene;
 
 import javax.inject.Named;
 import javax.inject.Provider;
+import java.util.List;
 import java.util.Map;
-import java.util.Optional;
 import java.util.ResourceBundle;
 
 @Module
@@ -37,13 +37,13 @@ abstract class ForgetPasswordModule {
 	@Provides
 	@ForgetPasswordWindow
 	@ForgetPasswordScoped
-	static Stage provideStage(ResourceBundle resourceBundle, @Named("windowIcon") Optional<Image> windowIcon, @Named("forgetPasswordOwner") Stage owner) {
+	static Stage provideStage(ResourceBundle resourceBundle, @Named("windowIcons") List<Image> windowIcons, @Named("forgetPasswordOwner") Stage owner) {
 		Stage stage = new Stage();
 		stage.setTitle(resourceBundle.getString("forgetPassword.title"));
 		stage.setResizable(false);
 		stage.initModality(Modality.WINDOW_MODAL);
 		stage.initOwner(owner);
-		windowIcon.ifPresent(stage.getIcons()::add);
+		stage.getIcons().addAll(windowIcons);
 		return stage;
 	}
 

main/ui/src/main/java/org/cryptomator/ui/fxapp/FxApplication.java

@@ -9,6 +9,7 @@ import javafx.beans.value.ObservableValue;
 import javafx.collections.FXCollections;
 import javafx.collections.ObservableSet;
 import javafx.stage.Stage;
+import org.cryptomator.common.LicenseHolder;
 import org.cryptomator.common.settings.Settings;
 import org.cryptomator.common.settings.UiTheme;
 import org.cryptomator.common.vaults.Vault;
@@ -16,8 +17,10 @@ import org.cryptomator.jni.JniException;
 import org.cryptomator.jni.MacApplicationUiAppearance;
 import org.cryptomator.jni.MacApplicationUiState;
 import org.cryptomator.jni.MacFunctions;
+import org.cryptomator.ui.common.VaultService;
 import org.cryptomator.ui.mainwindow.MainWindowComponent;
 import org.cryptomator.ui.preferences.PreferencesComponent;
+import org.cryptomator.ui.preferences.SelectedPreferencesTab;
 import org.cryptomator.ui.quit.QuitComponent;
 import org.cryptomator.ui.unlock.UnlockComponent;
 import org.slf4j.Logger;
@@ -38,17 +41,21 @@ public class FxApplication extends Application {
 	private final UnlockComponent.Builder unlockWindowBuilder;
 	private final QuitComponent.Builder quitWindowBuilder;
 	private final Optional<MacFunctions> macFunctions;
+	private final VaultService vaultService;
+	private final LicenseHolder licenseHolder;
 	private final ObservableSet<Stage> visibleStages = FXCollections.observableSet();
 	private final BooleanBinding hasVisibleStages = Bindings.isNotEmpty(visibleStages);
 
 	@Inject
-	FxApplication(Settings settings, Lazy<MainWindowComponent> mainWindow, Lazy<PreferencesComponent> preferencesWindow, UnlockComponent.Builder unlockWindowBuilder, QuitComponent.Builder quitWindowBuilder, Optional<MacFunctions> macFunctions) {
+	FxApplication(Settings settings, Lazy<MainWindowComponent> mainWindow, Lazy<PreferencesComponent> preferencesWindow, UnlockComponent.Builder unlockWindowBuilder, QuitComponent.Builder quitWindowBuilder, Optional<MacFunctions> macFunctions, VaultService vaultService, LicenseHolder licenseHolder) {
 		this.settings = settings;
 		this.mainWindow = mainWindow;
 		this.preferencesWindow = preferencesWindow;
 		this.unlockWindowBuilder = unlockWindowBuilder;
 		this.quitWindowBuilder = quitWindowBuilder;
 		this.macFunctions = macFunctions;
+		this.vaultService = vaultService;
+		this.licenseHolder = licenseHolder;
 	}
 
 	public void start() {
@@ -79,9 +86,9 @@ public class FxApplication extends Application {
 		}
 	}
 
-	public void showPreferencesWindow() {
+	public void showPreferencesWindow(SelectedPreferencesTab selectedTab) {
 		Platform.runLater(() -> {
-			Stage stage = preferencesWindow.get().showPreferencesWindow();
+			Stage stage = preferencesWindow.get().showPreferencesWindow(selectedTab);
 			addVisibleStage(stage);
 			LOG.debug("Showing Preferences");
 		});
@@ -111,11 +118,16 @@ public class FxApplication extends Application {
 		});
 	}
 
+	public VaultService getVaultService() {
+		return vaultService;
+	}
+
 	private void themeChanged(@SuppressWarnings("unused") ObservableValue<? extends UiTheme> observable, @SuppressWarnings("unused") UiTheme oldValue, UiTheme newValue) {
 		loadSelectedStyleSheet(newValue);
 	}
 
-	private void loadSelectedStyleSheet(UiTheme theme) {
+	private void loadSelectedStyleSheet(UiTheme desiredTheme) {
+		UiTheme theme = licenseHolder.isValidLicense() ? desiredTheme : UiTheme.LIGHT;
 		switch (theme) {
 //			case CUSTOM:
 //				// TODO

main/ui/src/main/java/org/cryptomator/ui/fxapp/FxApplicationModule.java

@@ -5,8 +5,10 @@
  *******************************************************************************/
 package org.cryptomator.ui.fxapp;
 
+import dagger.Binds;
 import dagger.Module;
 import dagger.Provides;
+import javafx.application.Application;
 import javafx.beans.property.ObjectProperty;
 import javafx.beans.property.SimpleObjectProperty;
 import javafx.scene.image.Image;
@@ -20,7 +22,9 @@ import org.cryptomator.ui.unlock.UnlockComponent;
 import javax.inject.Named;
 import java.io.IOException;
 import java.io.InputStream;
-import java.util.Optional;
+import java.io.UncheckedIOException;
+import java.util.Collections;
+import java.util.List;
 
 @Module(includes = {UpdateCheckerModule.class}, subcomponents = {MainWindowComponent.class, PreferencesComponent.class, UnlockComponent.class, QuitComponent.class})
 abstract class FxApplicationModule {
@@ -32,19 +36,32 @@ abstract class FxApplicationModule {
 	}
 
 	@Provides
-	@Named("windowIcon")
+	@Named("windowIcons")
 	@FxApplicationScoped
-	static Optional<Image> provideWindowIcon() {
+	static List<Image> provideWindowIcons() {
 		if (SystemUtils.IS_OS_MAC) {
-			return Optional.empty();
+			return Collections.emptyList();
 		}
-		try (InputStream in = FxApplicationModule.class.getResourceAsStream("/window_icon_32.png")) { // TODO: use some higher res depending on display?
+
-			return Optional.of(new Image(in));
+		try {
+			return List.of( //
+					createImageFromResource("/window_icon_32.png"), //
+					createImageFromResource("/window_icon_512.png") //
+			);
 		} catch (IOException e) {
-			return Optional.empty();
+			throw new UncheckedIOException("Failed to load embedded resource.", e);
 		}
 	}
 
+	private static Image createImageFromResource(String resourceName) throws IOException {
+		try (InputStream in = FxApplicationModule.class.getResourceAsStream(resourceName)) {
+			return new Image(in);
+		}
+	}
+
+	@Binds
+	abstract Application bindApplication(FxApplication application);
+
 	@Provides
 	static MainWindowComponent provideMainWindowComponent(MainWindowComponent.Builder builder) {
 		return builder.build();

main/ui/src/main/java/org/cryptomator/ui/launcher/AppLaunchEvent.java

@@ -1,16 +1,17 @@
 package org.cryptomator.ui.launcher;
 
 import java.nio.file.Path;
+import java.util.Collection;
 import java.util.stream.Stream;
 
 public class AppLaunchEvent {
 
-	private final Stream<Path> pathsToOpen;
 	private final EventType type;
+	private final Collection<Path> pathsToOpen;
 
 	public enum EventType {REVEAL_APP, OPEN_FILE}
 
-	public AppLaunchEvent(EventType type, Stream<Path> pathsToOpen) {
+	public AppLaunchEvent(EventType type, Collection<Path> pathsToOpen) {
 		this.type = type;
 		this.pathsToOpen = pathsToOpen;
 	}
@@ -19,7 +20,7 @@ public class AppLaunchEvent {
 		return type;
 	}
 
-	public Stream<Path> getPathsToOpen() {
+	public Collection<Path> getPathsToOpen() {
 		return pathsToOpen;
 	}
 }

main/ui/src/main/java/org/cryptomator/ui/launcher/AppLifecycleListener.java

@@ -0,0 +1,125 @@
+package org.cryptomator.ui.launcher;
+
+import javafx.application.Platform;
+import javafx.beans.Observable;
+import javafx.collections.ObservableList;
+import org.cryptomator.common.ShutdownHook;
+import org.cryptomator.common.vaults.Vault;
+import org.cryptomator.common.vaults.VaultState;
+import org.cryptomator.common.vaults.Volume;
+import org.cryptomator.ui.preferences.SelectedPreferencesTab;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.inject.Inject;
+import javax.inject.Named;
+import javax.inject.Singleton;
+import java.awt.Desktop;
+import java.awt.EventQueue;
+import java.awt.desktop.QuitResponse;
+import java.util.EnumSet;
+import java.util.EventObject;
+import java.util.Set;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+@Singleton
+public class AppLifecycleListener {
+
+	private static final Logger LOG = LoggerFactory.getLogger(AppLifecycleListener.class);
+	public static final Set<VaultState> STATES_ALLOWING_TERMINATION = EnumSet.of(VaultState.LOCKED, VaultState.NEEDS_MIGRATION, VaultState.MISSING, VaultState.ERROR);
+
+	private final FxApplicationStarter fxApplicationStarter;
+	private final CountDownLatch shutdownLatch;
+	private final ObservableList<Vault> vaults;
+	private final AtomicBoolean allowQuitWithoutPrompt;
+
+	@Inject
+	AppLifecycleListener(FxApplicationStarter fxApplicationStarter, @Named("shutdownLatch") CountDownLatch shutdownLatch, ShutdownHook shutdownHook, ObservableList<Vault> vaults) {
+		this.fxApplicationStarter = fxApplicationStarter;
+		this.shutdownLatch = shutdownLatch;
+		this.vaults = vaults;
+		this.allowQuitWithoutPrompt = new AtomicBoolean(true);
+		vaults.addListener(this::vaultListChanged);
+
+		// register preferences shortcut
+		if (Desktop.getDesktop().isSupported(Desktop.Action.APP_PREFERENCES)) {
+			Desktop.getDesktop().setPreferencesHandler(this::showPreferencesWindow);
+		}
+
+		// register quit handler
+		if (Desktop.getDesktop().isSupported(Desktop.Action.APP_QUIT_HANDLER)) {
+			Desktop.getDesktop().setQuitHandler(this::handleQuitRequest);
+		}
+
+		shutdownHook.runOnShutdown(this::forceUnmountRemainingVaults);
+	}
+
+	/**
+	 * Gracefully terminates the application.
+	 */
+	public void quit() {
+		handleQuitRequest(null, new QuitResponse() {
+			@Override
+			public void performQuit() {
+				System.exit(0);
+			}
+
+			@Override
+			public void cancelQuit() {
+				// no-op
+			}
+		});
+	}
+
+	private void handleQuitRequest(@SuppressWarnings("unused") EventObject e, QuitResponse response) {
+		QuitResponse decoratedQuitResponse = decorateQuitResponse(response);
+		if (allowQuitWithoutPrompt.get()) {
+			decoratedQuitResponse.performQuit();
+		} else {
+			fxApplicationStarter.get(true).thenAccept(app -> app.showQuitWindow(decoratedQuitResponse));
+		}
+	}
+
+	private QuitResponse decorateQuitResponse(QuitResponse originalQuitResponse) {
+		return new QuitResponse() {
+			@Override
+			public void performQuit() {
+				Platform.exit(); // will be no-op, if JavaFX never started.
+				shutdownLatch.countDown(); // main thread is waiting for this latch
+				EventQueue.invokeLater(originalQuitResponse::performQuit); // this will eventually call System.exit(0)
+			}
+
+			@Override
+			public void cancelQuit() {
+				originalQuitResponse.cancelQuit();
+			}
+		};
+	}
+
+	private void vaultListChanged(@SuppressWarnings("unused") Observable observable) {
+		assert Platform.isFxApplicationThread();
+		boolean allVaultsAllowTermination = vaults.stream().map(Vault::getState).allMatch(STATES_ALLOWING_TERMINATION::contains);
+		boolean suddenTerminationChanged = allowQuitWithoutPrompt.compareAndSet(!allVaultsAllowTermination, allVaultsAllowTermination);
+		if (suddenTerminationChanged) {
+			LOG.debug("Allow quitting without prompt: {}", allVaultsAllowTermination);
+		}
+	}
+
+	private void showPreferencesWindow(@SuppressWarnings("unused") EventObject actionEvent) {
+		fxApplicationStarter.get(true).thenAccept(app -> app.showPreferencesWindow(SelectedPreferencesTab.ANY));
+	}
+
+	private void forceUnmountRemainingVaults() {
+		for (Vault vault : vaults) {
+			if (vault.isUnlocked()) {
+				try {
+					vault.lock(true);
+				} catch (Volume.VolumeException e) {
+					LOG.error("Failed to unmount vault " + vault.getPath(), e);
+				}
+			}
+		}
+	}
+
+}

main/ui/src/main/java/org/cryptomator/ui/launcher/UiLauncher.java

@@ -1,6 +1,8 @@
 package org.cryptomator.ui.launcher;
 
+import javafx.collections.ObservableList;
 import org.cryptomator.common.settings.Settings;
+import org.cryptomator.common.vaults.Vault;
 import org.cryptomator.jni.JniException;
 import org.cryptomator.jni.MacApplicationUiState;
 import org.cryptomator.jni.MacFunctions;
@@ -13,9 +15,8 @@ import javax.inject.Inject;
 import javax.inject.Singleton;
 import java.awt.Desktop;
 import java.awt.SystemTray;
-import java.awt.desktop.AppReopenedEvent;
 import java.awt.desktop.AppReopenedListener;
-import java.awt.desktop.SystemEventListener;
+import java.util.Collection;
 import java.util.Optional;
 
 @Singleton
@@ -24,14 +25,16 @@ public class UiLauncher {
 	private static final Logger LOG = LoggerFactory.getLogger(UiLauncher.class);
 
 	private final Settings settings;
+	private final ObservableList<Vault> vaults;
 	private final TrayMenuComponent.Builder trayComponent;
 	private final FxApplicationStarter fxApplicationStarter;
 	private final AppLaunchEventHandler launchEventHandler;
 	private final Optional<MacFunctions> macFunctions;
 
 	@Inject
-	public UiLauncher(Settings settings, TrayMenuComponent.Builder trayComponent, FxApplicationStarter fxApplicationStarter, AppLaunchEventHandler launchEventHandler, Optional<MacFunctions> macFunctions) {
+	public UiLauncher(Settings settings, ObservableList<Vault> vaults, TrayMenuComponent.Builder trayComponent, FxApplicationStarter fxApplicationStarter, AppLaunchEventHandler launchEventHandler, Optional<MacFunctions> macFunctions) {
 		this.settings = settings;
+		this.vaults = vaults;
 		this.trayComponent = trayComponent;
 		this.fxApplicationStarter = fxApplicationStarter;
 		this.launchEventHandler = launchEventHandler;
@@ -48,7 +51,7 @@ public class UiLauncher {
 		}
 
 		// show window on start?
-		if (settings.startHidden().get()) {
+		if (hasTrayIcon && settings.startHidden().get()) {
 			LOG.debug("Hiding application...");
 			macFunctions.map(MacFunctions::uiState).ifPresent(JniException.ignore(MacApplicationUiState::transformToAgentApplication));
 		} else {
@@ -58,6 +61,12 @@ public class UiLauncher {
 		// register app reopen listener
 		Desktop.getDesktop().addAppEventListener((AppReopenedListener) e -> showMainWindowAsync(hasTrayIcon));
 
+		// auto unlock
+		Collection<Vault> vaultsWithAutoUnlockEnabled = vaults.filtered(v -> v.getVaultSettings().unlockAfterStartup().get());
+		if (!vaultsWithAutoUnlockEnabled.isEmpty()) {
+			fxApplicationStarter.get(hasTrayIcon).thenAccept(app -> app.getVaultService().attemptAutoUnlock(vaultsWithAutoUnlockEnabled));
+		}
+
 		launchEventHandler.startHandlingLaunchEvents(hasTrayIcon);
 	}
 

main/ui/src/main/java/org/cryptomator/ui/mainwindow/MainWindowController.java

@@ -1,30 +1,24 @@
 package org.cryptomator.ui.mainwindow;
 
-import javafx.beans.binding.BooleanBinding;
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.SimpleBooleanProperty;
 import javafx.fxml.FXML;
+import javafx.scene.input.DragEvent;
 import javafx.scene.input.TransferMode;
-import javafx.scene.layout.HBox;
+import javafx.scene.layout.StackPane;
-import javafx.scene.layout.Pane;
-import javafx.scene.layout.Region;
-import javafx.scene.layout.VBox;
-import javafx.stage.Stage;
-import org.cryptomator.common.vaults.Vault;
 import org.cryptomator.common.vaults.VaultListManager;
 import org.cryptomator.ui.common.FxController;
-import org.cryptomator.ui.fxapp.FxApplication;
-import org.cryptomator.ui.fxapp.UpdateChecker;
 import org.cryptomator.ui.wrongfilealert.WrongFileAlertComponent;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import javax.inject.Inject;
-import javax.inject.Named;
 import java.io.File;
+import java.nio.file.Files;
 import java.nio.file.NoSuchFileException;
 import java.nio.file.Path;
-import java.util.Collection;
+import java.util.Set;
 import java.util.stream.Collectors;
-import java.util.stream.Stream;
 
 @MainWindowScoped
 public class MainWindowController implements FxController {
@@ -32,27 +26,14 @@ public class MainWindowController implements FxController {
 	private static final Logger LOG = LoggerFactory.getLogger(MainWindowController.class);
 	private static final String MASTERKEY_FILENAME = "masterkey.cryptomator"; // TODO: deduplicate constant declared in multiple classes
 
-	private final Stage window;
-	private final FxApplication application;
-	private final boolean minimizeToSysTray;
-	private final UpdateChecker updateChecker;
-	private final BooleanBinding updateAvailable;
 	private final VaultListManager vaultListManager;
 	private final WrongFileAlertComponent.Builder wrongFileAlert;
-	public HBox titleBar;
+	private final BooleanProperty draggingOver = new SimpleBooleanProperty();
-	public VBox root;
+	private final BooleanProperty draggingVaultOver = new SimpleBooleanProperty();
-	public Pane dragAndDropIndicator;
+	public StackPane root;
-	public Region resizer;
-	private double xOffset;
-	private double yOffset;
 
 	@Inject
-	public MainWindowController(@MainWindow Stage window, FxApplication application, @Named("trayMenuSupported") boolean minimizeToSysTray, UpdateChecker updateChecker, VaultListManager vaultListManager, WrongFileAlertComponent.Builder wrongFileAlert) {
+	public MainWindowController(VaultListManager vaultListManager, WrongFileAlertComponent.Builder wrongFileAlert) {
-		this.window = window;
-		this.application = application;
-		this.minimizeToSysTray = minimizeToSysTray;
-		this.updateChecker = updateChecker;
-		this.updateAvailable = updateChecker.latestVersionProperty().isNotNull();
 		this.vaultListManager = vaultListManager;
 		this.wrongFileAlert = wrongFileAlert;
 	}
@@ -60,77 +41,70 @@ public class MainWindowController implements FxController {
 	@FXML
 	public void initialize() {
 		LOG.debug("init MainWindowController");
-		titleBar.setOnMousePressed(event -> {
+		root.setOnDragEntered(this::handleDragEvent);
-			xOffset = event.getSceneX();
+		root.setOnDragOver(this::handleDragEvent);
-			yOffset = event.getSceneY();
+		root.setOnDragDropped(this::handleDragEvent);
-		});
+		root.setOnDragExited(this::handleDragEvent);
-		titleBar.setOnMouseDragged(event -> {
-			window.setX(event.getScreenX() - xOffset);
-			window.setY(event.getScreenY() - yOffset);
-		});
-		resizer.setOnMouseDragged(event -> {
-			// we know for a fact that window is borderless. i.e. the scene starts at 0/0 of the window.
-			window.setWidth(event.getSceneX());
-			window.setHeight(event.getSceneY());
-		});
-		updateChecker.automaticallyCheckForUpdatesIfEnabled();
-		dragAndDropIndicator.setVisible(false);
-		root.setOnDragOver(event -> {
-			if (event.getGestureSource() != root && event.getDragboard().hasFiles()) {
-				/* allow for both copying and moving, whatever user chooses */
-				event.acceptTransferModes(TransferMode.COPY_OR_MOVE);
-				dragAndDropIndicator.setVisible(true);
-			}
-			event.consume();
-		});
-		root.setOnDragExited(event -> dragAndDropIndicator.setVisible(false));
-		root.setOnDragDropped(event -> {
-			if (event.getGestureSource() != root && event.getDragboard().hasFiles()) {
-				/* allow for both copying and moving, whatever user chooses */
-				event.acceptTransferModes(TransferMode.COPY_OR_MOVE);
-				Collection<Vault> vaultPaths = event.getDragboard().getFiles().stream().map(File::toPath).flatMap(this::addVault).collect(Collectors.toSet());
-				if (vaultPaths.isEmpty()) {
-					wrongFileAlert.build().showWrongFileAlertWindow();
-				}
-			}
-			event.consume();
-		});
 	}
 
-	private Stream<Vault> addVault(Path pathToVault) {
+	private void handleDragEvent(DragEvent event) {
+		if (DragEvent.DRAG_ENTERED.equals(event.getEventType()) && event.getGestureSource() == null) {
+			draggingOver.set(true);
+		} else if (DragEvent.DRAG_OVER.equals(event.getEventType()) && event.getGestureSource() == null && event.getDragboard().hasFiles()) {
+			event.acceptTransferModes(TransferMode.ANY);
+			draggingVaultOver.set(event.getDragboard().getFiles().stream().map(File::toPath).anyMatch(this::containsVault));
+		} else if (DragEvent.DRAG_DROPPED.equals(event.getEventType()) && event.getGestureSource() == null && event.getDragboard().hasFiles()) {
+			Set<Path> vaultPaths = event.getDragboard().getFiles().stream().map(File::toPath).filter(this::containsVault).collect(Collectors.toSet());
+			if (vaultPaths.isEmpty()) {
+				wrongFileAlert.build().showWrongFileAlertWindow();
+			} else {
+				vaultPaths.forEach(this::addVault);
+			}
+			event.setDropCompleted(!vaultPaths.isEmpty());
+			event.consume();
+		} else if (DragEvent.DRAG_EXITED.equals(event.getEventType())) {
+			draggingOver.set(false);
+			draggingVaultOver.set(false);
+		}
+	}
+
+	private boolean containsVault(Path path) {
+		if (path.getFileName().toString().equals(MASTERKEY_FILENAME)) {
+			return true;
+		} else if (Files.isDirectory(path) && Files.exists(path.resolve(MASTERKEY_FILENAME))) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	private void addVault(Path pathToVault) {
 		try {
 			if (pathToVault.getFileName().toString().equals(MASTERKEY_FILENAME)) {
-				return Stream.of(vaultListManager.add(pathToVault.getParent()));
+				vaultListManager.add(pathToVault.getParent());
 			} else {
-				return Stream.of(vaultListManager.add(pathToVault));
+				vaultListManager.add(pathToVault);
 			}
 		} catch (NoSuchFileException e) {
 			LOG.debug("Not a vault: {}", pathToVault);
 		}
-		return Stream.empty();
-	}
-
-	@FXML
-	public void close() {
-		if (minimizeToSysTray) {
-			window.close();
-		} else {
-			window.setIconified(true);
-		}
-	}
-
-	@FXML
-	public void showPreferences() {
-		application.showPreferencesWindow();
 	}
 
 	/* Getter/Setter */
 
-	public BooleanBinding updateAvailableProperty() {
+	public BooleanProperty draggingOverProperty() {
-		return updateAvailable;
+		return draggingOver;
 	}
 
-	public boolean isUpdateAvailable() {
+	public boolean isDraggingOver() {
-		return updateAvailable.get();
+		return draggingOver.get();
+	}
+
+	public BooleanProperty draggingVaultOverProperty() {
+		return draggingVaultOver;
+	}
+
+	public boolean isDraggingVaultOver() {
+		return draggingVaultOver.get();
 	}
 }

main/ui/src/main/java/org/cryptomator/ui/mainwindow/MainWindowModule.java

@@ -25,8 +25,8 @@ import org.cryptomator.ui.wrongfilealert.WrongFileAlertComponent;
 
 import javax.inject.Named;
 import javax.inject.Provider;
+import java.util.List;
 import java.util.Map;
-import java.util.Optional;
 import java.util.ResourceBundle;
 
 @Module(subcomponents = {AddVaultWizardComponent.class, MigrationComponent.class, RemoveVaultComponent.class, VaultOptionsComponent.class, WrongFileAlertComponent.class})
@@ -42,7 +42,7 @@ abstract class MainWindowModule {
 	@Provides
 	@MainWindow
 	@MainWindowScoped
-	static Stage provideStage(@Named("windowIcon") Optional<Image> windowIcon) {
+	static Stage provideStage(@Named("windowIcons") List<Image> windowIcons) {
 		Stage stage = new Stage(StageStyle.UNDECORATED);
 		// TODO: min/max values chosen arbitrarily. We might wanna take a look at the user's resolution...
 		stage.setMinWidth(650);
@@ -50,7 +50,7 @@ abstract class MainWindowModule {
 		stage.setMaxWidth(1000);
 		stage.setMaxHeight(700);
 		stage.setTitle("Cryptomator");
-		windowIcon.ifPresent(stage.getIcons()::add);
+		stage.getIcons().addAll(windowIcons);
 		return stage;
 	}
 
@@ -68,6 +68,16 @@ abstract class MainWindowModule {
 	@FxControllerKey(MainWindowController.class)
 	abstract FxController bindMainWindowController(MainWindowController controller);
 
+	@Binds
+	@IntoMap
+	@FxControllerKey(MainWindowTitleController.class)
+	abstract FxController bindMainWindowTitleController(MainWindowTitleController controller);
+
+	@Binds
+	@IntoMap
+	@FxControllerKey(ResizeController.class)
+	abstract FxController bindResizeController(ResizeController controller);
+
 	@Binds
 	@IntoMap
 	@FxControllerKey(VaultListController.class)

main/ui/src/main/java/org/cryptomator/ui/mainwindow/MainWindowSceneFactory.java

@@ -17,22 +17,22 @@ public class MainWindowSceneFactory extends DefaultSceneFactory {
 
 	protected static final KeyCodeCombination SHORTCUT_N = new KeyCodeCombination(KeyCode.N, KeyCombination.SHORTCUT_DOWN);
 
-	private final Lazy<MainWindowController> mainWindowController;
+	private final Lazy<MainWindowTitleController> mainWindowTitleController;
 	private final Lazy<VaultListController> vaultListController;
 
 	@Inject
-	public MainWindowSceneFactory(Settings settings, Lazy<MainWindowController> mainWindowController, Lazy<VaultListController> vaultListController) {
+	public MainWindowSceneFactory(Settings settings, Lazy<MainWindowTitleController> mainWindowTitleController, Lazy<VaultListController> vaultListController) {
 		super(settings);
-		this.mainWindowController = mainWindowController;
+		this.mainWindowTitleController = mainWindowTitleController;
 		this.vaultListController = vaultListController;
 	}
 
 	@Override
 	protected void setupDefaultAccelerators(Scene scene, Stage stage) {
 		if (SystemUtils.IS_OS_WINDOWS) {
-			scene.getAccelerators().put(ALT_F4, mainWindowController.get()::close);
+			scene.getAccelerators().put(ALT_F4, mainWindowTitleController.get()::close);
 		} else {
-			scene.getAccelerators().put(SHORTCUT_W, mainWindowController.get()::close);
+			scene.getAccelerators().put(SHORTCUT_W, mainWindowTitleController.get()::close);
 		}
 		scene.getAccelerators().put(SHORTCUT_N, vaultListController.get()::didClickAddVault);
 	}

main/ui/src/main/java/org/cryptomator/ui/mainwindow/MainWindowTitleController.java

@@ -0,0 +1,107 @@
+package org.cryptomator.ui.mainwindow;
+
+import javafx.beans.binding.BooleanBinding;
+import javafx.fxml.FXML;
+import javafx.scene.layout.HBox;
+import javafx.stage.Stage;
+import org.cryptomator.common.LicenseHolder;
+import org.cryptomator.ui.common.FxController;
+import org.cryptomator.ui.fxapp.FxApplication;
+import org.cryptomator.ui.fxapp.UpdateChecker;
+import org.cryptomator.ui.launcher.AppLifecycleListener;
+import org.cryptomator.ui.preferences.SelectedPreferencesTab;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.inject.Inject;
+import javax.inject.Named;
+
+@MainWindowScoped
+public class MainWindowTitleController implements FxController {
+
+	private static final Logger LOG = LoggerFactory.getLogger(MainWindowTitleController.class);
+
+	public HBox titleBar;
+
+	private final AppLifecycleListener appLifecycle;
+	private final Stage window;
+	private final FxApplication application;
+	private final boolean minimizeToSysTray;
+	private final UpdateChecker updateChecker;
+	private final BooleanBinding updateAvailable;
+	private final LicenseHolder licenseHolder;
+
+	private double xOffset;
+	private double yOffset;
+
+	@Inject
+	MainWindowTitleController(AppLifecycleListener appLifecycle, @MainWindow Stage window, FxApplication application, @Named("trayMenuSupported") boolean minimizeToSysTray, UpdateChecker updateChecker, LicenseHolder licenseHolder) {
+		this.appLifecycle = appLifecycle;
+		this.window = window;
+		this.application = application;
+		this.minimizeToSysTray = minimizeToSysTray;
+		this.updateChecker = updateChecker;
+		this.updateAvailable = updateChecker.latestVersionProperty().isNotNull();
+		this.licenseHolder = licenseHolder;
+	}
+
+	@FXML
+	public void initialize() {
+		LOG.debug("init MainWindowTitleController");
+		updateChecker.automaticallyCheckForUpdatesIfEnabled();
+		titleBar.setOnMousePressed(event -> {
+			xOffset = event.getSceneX();
+			yOffset = event.getSceneY();
+		});
+		titleBar.setOnMouseDragged(event -> {
+			window.setX(event.getScreenX() - xOffset);
+			window.setY(event.getScreenY() - yOffset);
+		});
+		window.setOnCloseRequest(event -> {
+			close();
+			event.consume();
+		});
+	}
+
+	@FXML
+	public void close() {
+		if (minimizeToSysTray) {
+			window.close();
+		} else {
+			appLifecycle.quit();
+		}
+	}
+
+	@FXML
+	public void minimize() {
+		window.setIconified(true);
+	}
+
+	@FXML
+	public void showPreferences() {
+		application.showPreferencesWindow(SelectedPreferencesTab.ANY);
+	}
+
+	@FXML
+	public void showDonationKeyPreferences() {
+		application.showPreferencesWindow(SelectedPreferencesTab.DONATION_KEY);
+	}
+
+	/* Getter/Setter */
+
+	public LicenseHolder getLicenseHolder() {
+		return licenseHolder;
+	}
+
+	public BooleanBinding updateAvailableProperty() {
+		return updateAvailable;
+	}
+
+	public boolean isUpdateAvailable() {
+		return updateAvailable.get();
+	}
+
+	public boolean isMinimizeToSysTray() {
+		return minimizeToSysTray;
+	}
+}

main/ui/src/main/java/org/cryptomator/ui/mainwindow/ResizeController.java

@@ -0,0 +1,102 @@
+package org.cryptomator.ui.mainwindow;
+
+import javafx.fxml.FXML;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.layout.Region;
+import javafx.stage.Stage;
+import org.cryptomator.ui.common.FxController;
+
+import javax.inject.Inject;
+
+@MainWindow
+public class ResizeController implements FxController {
+
+	private final Stage window;
+
+	public Region tlResizer;
+	public Region trResizer;
+	public Region blResizer;
+	public Region brResizer;
+
+	private double origX, origY, origW, origH;
+
+	@Inject
+	ResizeController(@MainWindow Stage window) {
+		this.window = window;
+		// TODO inject settings and save current position and size
+	}
+
+	@FXML
+	public void initialize() {
+		tlResizer.setOnMousePressed(this::startResize);
+		trResizer.setOnMousePressed(this::startResize);
+		blResizer.setOnMousePressed(this::startResize);
+		brResizer.setOnMousePressed(this::startResize);
+		tlResizer.setOnMouseDragged(this::resizeTopLeft);
+		trResizer.setOnMouseDragged(this::resizeTopRight);
+		blResizer.setOnMouseDragged(this::resizeBottomLeft);
+		brResizer.setOnMouseDragged(this::resizeBottomRight);
+	}
+
+	private void startResize(MouseEvent evt) {
+		origX = window.getX();
+		origY = window.getY();
+		origW = window.getWidth();
+		origH = window.getHeight();
+	}
+
+	private void resizeTopLeft(MouseEvent evt) {
+		resizeTop(evt);
+		resizeLeft(evt);
+	}
+
+	private void resizeTopRight(MouseEvent evt) {
+		resizeTop(evt);
+		resizeRight(evt);
+	}
+
+	private void resizeBottomLeft(MouseEvent evt) {
+		resizeBottom(evt);
+		resizeLeft(evt);
+	}
+
+	private void resizeBottomRight(MouseEvent evt) {
+		resizeBottom(evt);
+		resizeRight(evt);
+	}
+
+	private void resizeTop(MouseEvent evt) {
+		double newY = evt.getScreenY();
+		double dy = newY - origY;
+		double newH = origH - dy;
+		if (newH < window.getMaxHeight() && newH > window.getMinHeight()) {
+			window.setY(newY);
+			window.setHeight(newH);
+		}
+	}
+
+	private void resizeLeft(MouseEvent evt) {
+		double newX = evt.getScreenX();
+		double dx = newX - origX;
+		double newW = origW - dx;
+		if (newW < window.getMaxWidth() && newW > window.getMinWidth()) {
+			window.setX(newX);
+			window.setWidth(newW);
+		}
+	}
+
+	private void resizeBottom(MouseEvent evt) {
+		double newH = evt.getSceneY();
+		if (newH < window.getMaxHeight() && newH > window.getMinHeight()) {
+			window.setHeight(newH);
+		}
+	}
+
+	private void resizeRight(MouseEvent evt) {
+		double newW = evt.getSceneX();
+		if (newW < window.getMaxWidth() && newW > window.getMinWidth()) {
+			window.setWidth(newW);
+		}
+	}
+
+}

main/ui/src/main/java/org/cryptomator/ui/mainwindow/VaultDetailController.java

@@ -33,11 +33,11 @@ public class VaultDetailController implements FxController {
 	private FontAwesome5Icon getGlyphForVaultState(VaultState state) {
 		switch (state) {
 			case LOCKED:
-				return FontAwesome5Icon.LOCK_ALT;
+				return FontAwesome5Icon.LOCK;
 			case PROCESSING:
 				return FontAwesome5Icon.SPINNER;
 			case UNLOCKED:
-				return FontAwesome5Icon.LOCK_OPEN_ALT;
+				return FontAwesome5Icon.LOCK_OPEN;
 			default:
 				return FontAwesome5Icon.EXCLAMATION_TRIANGLE;
 		}

main/ui/src/main/java/org/cryptomator/ui/mainwindow/VaultDetailUnlockedController.java

@@ -4,53 +4,32 @@ import javafx.beans.property.ObjectProperty;
 import javafx.beans.property.ReadOnlyObjectProperty;
 import javafx.fxml.FXML;
 import org.cryptomator.common.vaults.Vault;
-import org.cryptomator.common.vaults.VaultState;
-import org.cryptomator.common.vaults.Volume;
 import org.cryptomator.ui.common.FxController;
-import org.cryptomator.ui.common.Tasks;
+import org.cryptomator.ui.common.VaultService;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import javax.inject.Inject;
-import java.util.concurrent.ExecutorService;
 
 @MainWindowScoped
 public class VaultDetailUnlockedController implements FxController {
 
-	private static final Logger LOG = LoggerFactory.getLogger(VaultDetailUnlockedController.class);
-
 	private final ReadOnlyObjectProperty<Vault> vault;
-	private final ExecutorService executor;
+	private final VaultService vaultService;
 
 	@Inject
-	public VaultDetailUnlockedController(ObjectProperty<Vault> vault, ExecutorService executor) {
+	public VaultDetailUnlockedController(ObjectProperty<Vault> vault, VaultService vaultService) {
 		this.vault = vault;
-		this.executor = executor;
+		this.vaultService = vaultService;
 	}
 
 	@FXML
 	public void revealAccessLocation() {
-		try {
+		vaultService.reveal(vault.get());
-			vault.get().reveal();
-		} catch (Volume.VolumeException e) {
-			LOG.error("Failed to reveal vault.", e);
-		}
 	}
 
 	@FXML
 	public void lock() {
-		Vault v = vault.get();
+		vaultService.lock(vault.get(), false);
-		v.setState(VaultState.PROCESSING);
+		// TODO count lock attempts, and allow forced lock
-		Tasks.create(() -> {
-			v.lock(false);
-		}).onSuccess(() -> {
-			LOG.trace("Regular unmount succeeded.");
-			v.setState(VaultState.LOCKED);
-		}).onError(Exception.class, e -> {
-			v.setState(VaultState.UNLOCKED);
-			LOG.error("Regular unmount failed.", e);
-			// TODO
-		}).runOnce(executor);
 	}
 
 	/* Getter/Setter */

main/ui/src/main/java/org/cryptomator/ui/mainwindow/VaultListCellController.java

@@ -25,11 +25,11 @@ public class VaultListCellController implements FxController {
 	private FontAwesome5Icon getGlyphForVaultState(VaultState state) {
 		switch (state) {
 			case LOCKED:
-				return FontAwesome5Icon.LOCK_ALT;
+				return FontAwesome5Icon.LOCK;
 			case PROCESSING:
 				return FontAwesome5Icon.SPINNER;
 			case UNLOCKED:
-				return FontAwesome5Icon.LOCK_OPEN_ALT;
+				return FontAwesome5Icon.LOCK_OPEN;
 			default:
 				return FontAwesome5Icon.EXCLAMATION_TRIANGLE;
 		}

main/ui/src/main/java/org/cryptomator/ui/mainwindow/VaultListController.java

@@ -1,14 +1,18 @@
 package org.cryptomator.ui.mainwindow;
 
+import javafx.beans.Observable;
 import javafx.beans.binding.Bindings;
 import javafx.beans.binding.BooleanBinding;
 import javafx.beans.property.ObjectProperty;
+import javafx.beans.value.ObservableValue;
 import javafx.collections.ListChangeListener;
 import javafx.collections.ObservableList;
 import javafx.fxml.FXML;
 import javafx.scene.control.ListView;
 import javafx.stage.Stage;
 import org.cryptomator.common.vaults.Vault;
+import org.cryptomator.common.vaults.VaultListManager;
+import org.cryptomator.common.vaults.VaultState;
 import org.cryptomator.ui.addvaultwizard.AddVaultWizardComponent;
 import org.cryptomator.ui.common.FxController;
 import org.cryptomator.ui.removevault.RemoveVaultComponent;
@@ -23,7 +27,6 @@ public class VaultListController implements FxController {
 
 	private static final Logger LOG = LoggerFactory.getLogger(VaultListController.class);
 
-	private final Stage window;
 	private final ObservableList<Vault> vaults;
 	private final ObjectProperty<Vault> selectedVault;
 	private final VaultListCellFactory cellFactory;
@@ -34,8 +37,7 @@ public class VaultListController implements FxController {
 	public ListView<Vault> vaultList;
 
 	@Inject
-	VaultListController(@MainWindow Stage window, ObservableList<Vault> vaults, ObjectProperty<Vault> selectedVault, VaultListCellFactory cellFactory, AddVaultWizardComponent.Builder addVaultWizard, RemoveVaultComponent.Builder removeVault) {
+	VaultListController(ObservableList<Vault> vaults, ObjectProperty<Vault> selectedVault, VaultListCellFactory cellFactory, AddVaultWizardComponent.Builder addVaultWizard, RemoveVaultComponent.Builder removeVault) {
-		this.window = window;
 		this.vaults = vaults;
 		this.selectedVault = selectedVault;
 		this.cellFactory = cellFactory;
@@ -43,6 +45,7 @@ public class VaultListController implements FxController {
 		this.removeVault = removeVault;
 		this.noVaultSelected = selectedVault.isNull();
 		this.emptyVaultList = Bindings.isEmpty(vaults);
+		selectedVault.addListener(this::selectedVaultDidChange);
 	}
 
 	public void initialize() {
@@ -59,6 +62,23 @@ public class VaultListController implements FxController {
 		});
 	}
 
+	private void selectedVaultDidChange(@SuppressWarnings("unused") ObservableValue<? extends Vault> observableValue, @SuppressWarnings("unused") Vault oldValue, Vault newValue) {
+		VaultState reportedState = newValue.getState();
+		switch (reportedState) {
+			case LOCKED:
+			case NEEDS_MIGRATION:
+			case MISSING:
+				VaultState determinedState = VaultListManager.determineVaultState(newValue.getPath());
+				newValue.setState(determinedState);
+				break;
+			case ERROR:
+			case UNLOCKED:
+			case PROCESSING:
+			default:
+				// no-op
+		}
+	}
+
 	@FXML
 	public void didClickAddVault() {
 		addVaultWizard.build().showAddVaultWizard();

main/ui/src/main/java/org/cryptomator/ui/migration/MigrationCapabilityErrorController.java

@@ -0,0 +1,57 @@
+package org.cryptomator.ui.migration;
+
+import dagger.Lazy;
+import javafx.beans.binding.Bindings;
+import javafx.beans.binding.StringBinding;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.ReadOnlyObjectProperty;
+import javafx.fxml.FXML;
+import javafx.scene.Scene;
+import javafx.stage.Stage;
+import org.cryptomator.cryptofs.common.FileSystemCapabilityChecker;
+import org.cryptomator.ui.common.FxController;
+import org.cryptomator.ui.common.FxmlFile;
+import org.cryptomator.ui.common.FxmlScene;
+
+import javax.inject.Inject;
+import javax.inject.Named;
+import java.util.ResourceBundle;
+
+@MigrationScoped
+public class MigrationCapabilityErrorController implements FxController {
+
+	private final Stage window;
+	private final ResourceBundle localization;
+	private final Lazy<Scene> startScene;
+	private final StringBinding missingCapabilityDescription;
+	private final ReadOnlyObjectProperty<FileSystemCapabilityChecker.Capability> missingCapability;
+
+	@Inject
+	MigrationCapabilityErrorController(@MigrationWindow Stage window, @Named("capabilityErrorCause") ObjectProperty<FileSystemCapabilityChecker.Capability> missingCapability, ResourceBundle localization, @FxmlScene(FxmlFile.MIGRATION_START) Lazy<Scene> startScene) {
+		this.window = window;
+		this.missingCapability = missingCapability;
+		this.localization = localization;
+		this.startScene = startScene;
+		this.missingCapabilityDescription = Bindings.createStringBinding(this::getMissingCapabilityDescription, missingCapability);
+	}
+
+	@FXML
+	public void back() {
+		window.setScene(startScene.get());
+	}
+
+	/* Getters */
+
+	public StringBinding missingCapabilityDescriptionProperty() {
+		return missingCapabilityDescription;
+	}
+
+	public String getMissingCapabilityDescription() {
+		FileSystemCapabilityChecker.Capability c = missingCapability.get();
+		if (c != null) {
+			return localization.getString("migration.error.missingFileSystemCapabilities.reason." + c.name());
+		} else {
+			return null;
+		}
+	}
+}

main/ui/src/main/java/org/cryptomator/ui/migration/MigrationGenericErrorController.java

@@ -0,0 +1,29 @@
+package org.cryptomator.ui.migration;
+
+import dagger.Lazy;
+import javafx.fxml.FXML;
+import javafx.scene.Scene;
+import javafx.stage.Stage;
+import org.cryptomator.ui.common.FxController;
+import org.cryptomator.ui.common.FxmlFile;
+import org.cryptomator.ui.common.FxmlScene;
+
+import javax.inject.Inject;
+
+@MigrationScoped
+public class MigrationGenericErrorController implements FxController {
+
+	private final Stage window;
+	private final Lazy<Scene> startScene;
+
+	@Inject
+	MigrationGenericErrorController(@MigrationWindow Stage window, @FxmlScene(FxmlFile.MIGRATION_START) Lazy<Scene> startScene) {
+		this.window = window;
+		this.startScene = startScene;
+	}
+
+	@FXML
+	public void back() {
+		window.setScene(startScene.get());
+	}
+}

main/ui/src/main/java/org/cryptomator/ui/migration/MigrationModule.java

@@ -4,22 +4,26 @@ import dagger.Binds;
 import dagger.Module;
 import dagger.Provides;
 import dagger.multibindings.IntoMap;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleObjectProperty;
 import javafx.scene.Scene;
 import javafx.scene.image.Image;
 import javafx.stage.Modality;
 import javafx.stage.Stage;
+import org.cryptomator.cryptofs.common.FileSystemCapabilityChecker;
 import org.cryptomator.ui.common.DefaultSceneFactory;
 import org.cryptomator.ui.common.FXMLLoaderFactory;
 import org.cryptomator.ui.common.FxController;
 import org.cryptomator.ui.common.FxControllerKey;
 import org.cryptomator.ui.common.FxmlFile;
 import org.cryptomator.ui.common.FxmlScene;
+import org.cryptomator.ui.common.StackTraceController;
 import org.cryptomator.ui.mainwindow.MainWindow;
 
 import javax.inject.Named;
 import javax.inject.Provider;
+import java.util.List;
 import java.util.Map;
-import java.util.Optional;
 import java.util.ResourceBundle;
 
 @Module
@@ -35,16 +39,30 @@ abstract class MigrationModule {
 	@Provides
 	@MigrationWindow
 	@MigrationScoped
-	static Stage provideStage(@MainWindow Stage owner, ResourceBundle resourceBundle, @Named("windowIcon") Optional<Image> windowIcon) {
+	static Stage provideStage(@MainWindow Stage owner, ResourceBundle resourceBundle, @Named("windowIcons") List<Image> windowIcons) {
 		Stage stage = new Stage();
 		stage.setTitle(resourceBundle.getString("migration.title"));
 		stage.setResizable(false);
 		stage.initModality(Modality.WINDOW_MODAL);
 		stage.initOwner(owner);
-		windowIcon.ifPresent(stage.getIcons()::add);
+		stage.getIcons().addAll(windowIcons);
 		return stage;
 	}
 
+	@Provides
+	@Named("genericErrorCause")
+	@MigrationScoped
+	static ObjectProperty<Throwable> provideGenericErrorCause() {
+		return new SimpleObjectProperty<>();
+	}
+
+	@Provides
+	@Named("capabilityErrorCause")
+	@MigrationScoped
+	static ObjectProperty<FileSystemCapabilityChecker.Capability> provideCapabilityErrorCause() {
+		return new SimpleObjectProperty<>();
+	}
+
 	@Provides
 	@FxmlScene(FxmlFile.MIGRATION_START)
 	@MigrationScoped
@@ -66,6 +84,21 @@ abstract class MigrationModule {
 		return fxmlLoaders.createScene("/fxml/migration_success.fxml");
 	}
 
+	@Provides
+	@FxmlScene(FxmlFile.MIGRATION_CAPABILITY_ERROR)
+	@MigrationScoped
+	static Scene provideMigrationCapabilityErrorScene(@MigrationWindow FXMLLoaderFactory fxmlLoaders) {
+		return fxmlLoaders.createScene("/fxml/migration_capability_error.fxml");
+	}
+
+	@Provides
+	@FxmlScene(FxmlFile.MIGRATION_GENERIC_ERROR)
+	@MigrationScoped
+	static Scene provideMigrationGenericErrorScene(@MigrationWindow FXMLLoaderFactory fxmlLoaders) {
+		return fxmlLoaders.createScene("/fxml/migration_generic_error.fxml");
+	}
+
+
 	// ------------------
 
 	@Binds
@@ -83,4 +116,21 @@ abstract class MigrationModule {
 	@FxControllerKey(MigrationSuccessController.class)
 	abstract FxController bindMigrationSuccessController(MigrationSuccessController controller);
 
+	@Binds
+	@IntoMap
+	@FxControllerKey(MigrationCapabilityErrorController.class)
+	abstract FxController bindMigrationCapabilityErrorController(MigrationCapabilityErrorController controller);
+
+	@Binds
+	@IntoMap
+	@FxControllerKey(MigrationGenericErrorController.class)
+	abstract FxController bindMigrationGenericErrorController(MigrationGenericErrorController controller);
+
+	@Provides
+	@IntoMap
+	@FxControllerKey(StackTraceController.class)
+	static FxController provideStackTraceController(@Named("genericErrorCause") ObjectProperty<Throwable> errorCause) {
+		return new StackTraceController(errorCause.get());
+	}
+
 }

main/ui/src/main/java/org/cryptomator/ui/migration/MigrationRunController.java

@@ -1,32 +1,28 @@
 package org.cryptomator.ui.migration;
 
 import dagger.Lazy;
-import javafx.animation.KeyFrame;
+import javafx.application.Platform;
-import javafx.animation.KeyValue;
-import javafx.animation.Timeline;
 import javafx.beans.binding.Bindings;
 import javafx.beans.binding.ObjectBinding;
 import javafx.beans.property.BooleanProperty;
 import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.ObjectProperty;
 import javafx.beans.property.ReadOnlyDoubleProperty;
 import javafx.beans.property.SimpleBooleanProperty;
 import javafx.beans.property.SimpleDoubleProperty;
-import javafx.beans.value.WritableValue;
-import javafx.concurrent.ScheduledService;
-import javafx.concurrent.Task;
 import javafx.fxml.FXML;
 import javafx.scene.Scene;
 import javafx.scene.control.ContentDisplay;
 import javafx.stage.Stage;
-import javafx.util.Duration;
 import org.cryptomator.common.vaults.Vault;
 import org.cryptomator.common.vaults.VaultState;
+import org.cryptomator.cryptofs.common.FileSystemCapabilityChecker;
 import org.cryptomator.cryptofs.migration.Migrators;
 import org.cryptomator.cryptofs.migration.api.MigrationProgressListener;
-import org.cryptomator.cryptofs.migration.api.NoApplicableMigratorException;
 import org.cryptomator.cryptolib.api.InvalidPassphraseException;
 import org.cryptomator.keychain.KeychainAccess;
 import org.cryptomator.keychain.KeychainAccessException;
+import org.cryptomator.ui.common.Animations;
 import org.cryptomator.ui.common.FxController;
 import org.cryptomator.ui.common.FxmlFile;
 import org.cryptomator.ui.common.FxmlScene;
@@ -36,44 +32,54 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import javax.inject.Inject;
+import javax.inject.Named;
 import java.util.Arrays;
 import java.util.Optional;
 import java.util.concurrent.ExecutorService;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
 
 @MigrationScoped
 public class MigrationRunController implements FxController {
 
 	private static final Logger LOG = LoggerFactory.getLogger(MigrationRunController.class);
 	private static final String MASTERKEY_FILENAME = "masterkey.cryptomator"; // TODO: deduplicate constant declared in multiple classes
-	private static final Duration MIGRATION_PROGRESS_UPDATE_INTERVAL = Duration.millis(25);
+	private static final long MIGRATION_PROGRESS_UPDATE_MILLIS = 50;
 
 	private final Stage window;
 	private final Vault vault;
 	private final ExecutorService executor;
+	private final ScheduledExecutorService scheduler;
 	private final Optional<KeychainAccess> keychainAccess;
+	private final ObjectProperty<FileSystemCapabilityChecker.Capability> missingCapability;
+	private final ObjectProperty<Throwable> errorCause;
 	private final Lazy<Scene> startScene;
 	private final Lazy<Scene> successScene;
 	private final ObjectBinding<ContentDisplay> migrateButtonContentDisplay;
+	private final Lazy<Scene> capabilityErrorScene;
+	private final Lazy<Scene> genericErrorScene;
 	private final BooleanProperty migrationButtonDisabled;
 	private final DoubleProperty migrationProgress;
-	private final ScheduledService<Double> migrationProgressObservationService;
 	private volatile double volatileMigrationProgress = -1.0;
 	public NiceSecurePasswordField passwordField;
 
 	@Inject
-	public MigrationRunController(@MigrationWindow Stage window, @MigrationWindow Vault vault, ExecutorService executor, Optional<KeychainAccess> keychainAccess, @FxmlScene(FxmlFile.MIGRATION_START) Lazy<Scene> startScene, @FxmlScene(FxmlFile.MIGRATION_SUCCESS) Lazy<Scene> successScene) {
+	public MigrationRunController(@MigrationWindow Stage window, @MigrationWindow Vault vault, ExecutorService executor, ScheduledExecutorService scheduler, Optional<KeychainAccess> keychainAccess, @Named("capabilityErrorCause") ObjectProperty<FileSystemCapabilityChecker.Capability> missingCapability, @Named("genericErrorCause") ObjectProperty<Throwable> errorCause, @FxmlScene(FxmlFile.MIGRATION_START) Lazy<Scene> startScene, @FxmlScene(FxmlFile.MIGRATION_SUCCESS) Lazy<Scene> successScene, @FxmlScene(FxmlFile.MIGRATION_CAPABILITY_ERROR) Lazy<Scene> capabilityErrorScene, @FxmlScene(FxmlFile.MIGRATION_GENERIC_ERROR) Lazy<Scene> genericErrorScene) {
 		this.window = window;
 		this.vault = vault;
 		this.executor = executor;
+		this.scheduler = scheduler;
 		this.keychainAccess = keychainAccess;
+		this.missingCapability = missingCapability;
+		this.errorCause = errorCause;
 		this.startScene = startScene;
 		this.successScene = successScene;
 		this.migrateButtonContentDisplay = Bindings.createObjectBinding(this::getMigrateButtonContentDisplay, vault.stateProperty());
+		this.capabilityErrorScene = capabilityErrorScene;
+		this.genericErrorScene = genericErrorScene;
 		this.migrationButtonDisabled = new SimpleBooleanProperty();
 		this.migrationProgress = new SimpleDoubleProperty(volatileMigrationProgress);
-		this.migrationProgressObservationService = new MigrationProgressObservationService();
-		migrationProgressObservationService.setExecutor(executor);
-		migrationProgressObservationService.setPeriod(MIGRATION_PROGRESS_UPDATE_INTERVAL);
 	}
 
 	public void initialize() {
@@ -93,36 +99,42 @@ public class MigrationRunController implements FxController {
 		LOG.info("Migrating vault {}", vault.getPath());
 		CharSequence password = passwordField.getCharacters();
 		vault.setState(VaultState.PROCESSING);
-		migrationProgressObservationService.start();
+		ScheduledFuture<?> progressSyncTask = scheduler.scheduleAtFixedRate(() -> {
+			Platform.runLater(() -> {
+				migrationProgress.set(volatileMigrationProgress);
+			});
+		}, 0, MIGRATION_PROGRESS_UPDATE_MILLIS, TimeUnit.MILLISECONDS);
 		Tasks.create(() -> {
 			Migrators migrators = Migrators.get();
 			migrators.migrate(vault.getPath(), MASTERKEY_FILENAME, password, this::migrationProgressChanged);
 			return migrators.needsMigration(vault.getPath(), MASTERKEY_FILENAME);
 		}).onSuccess(needsAnotherMigration -> {
-			LOG.info("Migration of '{}' succeeded.", vault.getDisplayableName());
 			if (needsAnotherMigration) {
+				LOG.info("Migration of '{}' succeeded, but another migration is required.", vault.getDisplayableName());
 				vault.setState(VaultState.NEEDS_MIGRATION);
 			} else {
+				LOG.info("Migration of '{}' succeeded.", vault.getDisplayableName());
 				vault.setState(VaultState.LOCKED);
 				passwordField.swipe();
 				window.setScene(successScene.get());
 			}
 		}).onError(InvalidPassphraseException.class, e -> {
-			shakeWindow();
+			Animations.createShakeWindowAnimation(window).play();
 			passwordField.selectAll();
 			passwordField.requestFocus();
 			vault.setState(VaultState.NEEDS_MIGRATION);
-		}).onError(NoApplicableMigratorException.class, e -> {
+		}).onError(FileSystemCapabilityChecker.MissingCapabilityException.class, e -> {
-			LOG.error("Can not migrate vault.", e);
+			LOG.error("Underlying file system not supported.", e);
 			vault.setState(VaultState.ERROR);
-			// TODO show specific error screen
+			missingCapability.set(e.getMissingCapability());
+			window.setScene(capabilityErrorScene.get());
 		}).onError(Exception.class, e -> { // including RuntimeExceptions
 			LOG.error("Migration failed for technical reasons.", e);
-			vault.setState(VaultState.ERROR);
+			vault.setState(VaultState.NEEDS_MIGRATION);
-			// TODO show generic error screen
+			errorCause.set(e);
+			window.setScene(genericErrorScene.get());
 		}).andFinally(() -> {
-			migrationProgressObservationService.cancel();
+			progressSyncTask.cancel(true);
-			migrationProgressObservationService.reset();
 		}).runOnce(executor);
 	}
 
@@ -161,54 +173,6 @@ public class MigrationRunController implements FxController {
 		}
 	}
 
-	// Sets migrationProgress to volatileMigrationProgress at its configured interval
-	private class MigrationProgressObservationService extends ScheduledService<Double> {
-
-		@Override
-		protected Task<Double> createTask() {
-			return new Task<>() {
-				@Override
-				protected Double call() {
-					return volatileMigrationProgress;
-				}
-			};
-		}
-
-		@Override
-		protected void succeeded() {
-			assert getValue() != null;
-			migrationProgress.set(getValue());
-			super.succeeded();
-		}
-	}
-
-	/* Animations */
-
-	private void shakeWindow() {
-		WritableValue<Double> writableWindowX = new WritableValue<>() {
-			@Override
-			public Double getValue() {
-				return window.getX();
-			}
-
-			@Override
-			public void setValue(Double value) {
-				window.setX(value);
-			}
-		};
-		Timeline timeline = new Timeline( //
-				new KeyFrame(Duration.ZERO, new KeyValue(writableWindowX, window.getX())), //
-				new KeyFrame(new Duration(100), new KeyValue(writableWindowX, window.getX() - 22.0)), //
-				new KeyFrame(new Duration(200), new KeyValue(writableWindowX, window.getX() + 18.0)), //
-				new KeyFrame(new Duration(300), new KeyValue(writableWindowX, window.getX() - 14.0)), //
-				new KeyFrame(new Duration(400), new KeyValue(writableWindowX, window.getX() + 10.0)), //
-				new KeyFrame(new Duration(500), new KeyValue(writableWindowX, window.getX() - 6.0)), //
-				new KeyFrame(new Duration(600), new KeyValue(writableWindowX, window.getX() + 2.0)), //
-				new KeyFrame(new Duration(700), new KeyValue(writableWindowX, window.getX())) //
-		);
-		timeline.play();
-	}
-
 	/* Getter/Setter */
 
 	public Vault getVault() {

main/ui/src/main/java/org/cryptomator/ui/preferences/AutoStartMacStrategy.java

@@ -0,0 +1,43 @@
+package org.cryptomator.ui.preferences;
+
+import org.cryptomator.jni.MacFunctions;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+
+class AutoStartMacStrategy implements AutoStartStrategy {
+
+	private static final Logger LOG = LoggerFactory.getLogger(AutoStartMacStrategy.class);
+
+	private final MacFunctions macFunctions;
+
+	public AutoStartMacStrategy(MacFunctions macFunctions) {
+		this.macFunctions = macFunctions;
+	}
+
+	@Override
+	public CompletionStage<Boolean> isAutoStartEnabled() {
+		boolean enabled = macFunctions.launchServices().isLoginItemEnabled();
+		return CompletableFuture.completedFuture(enabled);
+	}
+
+	@Override
+	public void enableAutoStart() throws TogglingAutoStartFailedException {
+		if (macFunctions.launchServices().enableLoginItem()) {
+			LOG.debug("Added login item.");
+		} else {
+			throw new TogglingAutoStartFailedException("Failed to add login item.");
+		}
+	}
+
+	@Override
+	public void disableAutoStart() throws TogglingAutoStartFailedException {
+		if (macFunctions.launchServices().disableLoginItem()) {
+			LOG.debug("Removed login item.");
+		} else {
+			throw new TogglingAutoStartFailedException("Failed to remove login item.");
+		}
+	}
+}

main/ui/src/main/java/org/cryptomator/ui/preferences/AutoStartModule.java

@@ -0,0 +1,26 @@
+package org.cryptomator.ui.preferences;
+
+import dagger.Module;
+import dagger.Provides;
+import org.apache.commons.lang3.SystemUtils;
+import org.cryptomator.jni.MacFunctions;
+
+import java.util.Optional;
+
+@Module
+abstract class AutoStartModule {
+
+	@Provides
+	@PreferencesScoped
+	public static Optional<AutoStartStrategy> provideAutoStartStrategy(Optional<MacFunctions> macFunctions) {
+		if (SystemUtils.IS_OS_MAC_OSX && macFunctions.isPresent()) {
+			return Optional.of(new AutoStartMacStrategy(macFunctions.get()));
+		} else if (SystemUtils.IS_OS_WINDOWS) {
+			Optional<String> exeName = ProcessHandle.current().info().command();
+			return exeName.map(AutoStartWinStrategy::new);
+		} else {
+			return Optional.empty();
+		}
+	}
+
+}

main/ui/src/main/java/org/cryptomator/ui/preferences/AutoStartStrategy.java

@@ -0,0 +1,24 @@
+package org.cryptomator.ui.preferences;
+
+import java.util.concurrent.CompletionStage;
+
+public interface AutoStartStrategy {
+
+	CompletionStage<Boolean> isAutoStartEnabled();
+
+	void enableAutoStart() throws TogglingAutoStartFailedException;
+
+	void disableAutoStart() throws TogglingAutoStartFailedException;
+
+	class TogglingAutoStartFailedException extends Exception {
+
+		public TogglingAutoStartFailedException(String message) {
+			super(message);
+		}
+
+		public TogglingAutoStartFailedException(String message, Throwable cause) {
+			super(message, cause);
+		}
+		
+	}
+}

main/ui/src/main/java/org/cryptomator/ui/preferences/AutoStartWinStrategy.java

@@ -0,0 +1,91 @@
+package org.cryptomator.ui.preferences;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
+class AutoStartWinStrategy implements AutoStartStrategy {
+
+	private static final Logger LOG = LoggerFactory.getLogger(AutoStartWinStrategy.class);
+	private static final String HKCU_AUTOSTART_KEY = "\"HKCU\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run\"";
+	private static final String AUTOSTART_VALUE = "Cryptomator";
+	private final String exePath;
+
+	public AutoStartWinStrategy(String exePath) {
+		this.exePath = exePath;
+	}
+
+	@Override
+	public CompletionStage<Boolean> isAutoStartEnabled() {
+		ProcessBuilder regQuery = new ProcessBuilder("reg", "query", HKCU_AUTOSTART_KEY, //
+				"/v", AUTOSTART_VALUE);
+		try {
+			Process proc = regQuery.start();
+			return proc.onExit().thenApply(p -> p.exitValue() == 0);
+		} catch (IOException e) {
+			LOG.warn("Failed to query {} from registry key {}", AUTOSTART_VALUE, HKCU_AUTOSTART_KEY);
+			return CompletableFuture.completedFuture(false);
+		}
+	}
+
+	@Override
+	public void enableAutoStart() throws TogglingAutoStartFailedException {
+		ProcessBuilder regAdd = new ProcessBuilder("reg", "add", HKCU_AUTOSTART_KEY, //
+				"/v", AUTOSTART_VALUE, //
+				"/t", "REG_SZ", //
+				"/d", "\"" + exePath + "\"", //
+				"/f");
+		String command = regAdd.command().stream().collect(Collectors.joining(" "));
+		try {
+			Process proc = regAdd.start();
+			boolean finishedInTime = waitForProcess(proc, 5, TimeUnit.SECONDS);
+			if (finishedInTime) {
+				LOG.debug("Added {} to registry key {}.", AUTOSTART_VALUE, HKCU_AUTOSTART_KEY);
+			} else {
+				throw new TogglingAutoStartFailedException("Adding registry value failed.");
+			}
+		} catch (IOException e) {
+			throw new TogglingAutoStartFailedException("Adding registry value failed. " + command, e);
+		}
+	}
+
+	@Override
+	public void disableAutoStart() throws TogglingAutoStartFailedException {
+		ProcessBuilder regRemove = new ProcessBuilder("reg", "delete", HKCU_AUTOSTART_KEY, //
+				"/v", AUTOSTART_VALUE, //
+				"/f");
+		String command = regRemove.command().stream().collect(Collectors.joining(" "));
+		try {
+			Process proc = regRemove.start();
+			boolean finishedInTime = waitForProcess(proc, 5, TimeUnit.SECONDS);
+			if (finishedInTime) {
+				LOG.debug("Removed {} from registry key {}.", AUTOSTART_VALUE, HKCU_AUTOSTART_KEY);
+			} else {
+				throw new TogglingAutoStartFailedException("Removing registry value failed.");
+			}
+		} catch (IOException e) {
+			throw new TogglingAutoStartFailedException("Removing registry value failed. " + command, e);
+		}
+	}
+
+	private static boolean waitForProcess(Process proc, int timeout, TimeUnit timeUnit) {
+		boolean finishedInTime = false;
+		try {
+			finishedInTime = proc.waitFor(timeout, timeUnit);
+		} catch (InterruptedException e) {
+			LOG.error("Timeout while reading registry", e);
+			Thread.currentThread().interrupt();
+		} finally {
+			if (!finishedInTime) {
+				proc.destroyForcibly();
+			}
+		}
+		return finishedInTime;
+	}
+
+}

main/ui/src/main/java/org/cryptomator/ui/preferences/DonationKeyPreferencesController.java

@@ -0,0 +1,45 @@
+package org.cryptomator.ui.preferences;
+
+import javafx.application.Application;
+import javafx.beans.value.ObservableValue;
+import javafx.fxml.FXML;
+import javafx.scene.control.TextArea;
+import org.cryptomator.common.LicenseHolder;
+import org.cryptomator.ui.common.FxController;
+
+import javax.inject.Inject;
+
+@PreferencesScoped
+public class DonationKeyPreferencesController implements FxController {
+	
+	private static final String DONATION_URI = "https://store.cryptomator.org/desktop";
+
+	private final Application application;
+	private final LicenseHolder licenseHolder;
+	public TextArea donationKeyField;
+
+	@Inject
+	DonationKeyPreferencesController(Application application, LicenseHolder licenseHolder) {
+		this.application = application;
+		this.licenseHolder = licenseHolder;
+	}
+
+	@FXML
+	public void initialize() {
+		donationKeyField.setText(licenseHolder.getLicenseKey().orElse(null));
+		donationKeyField.textProperty().addListener(this::registrationKeyChanged);
+	}
+
+	private void registrationKeyChanged(@SuppressWarnings("unused") ObservableValue<? extends String> observable, @SuppressWarnings("unused") String oldValue, String newValue) {
+		licenseHolder.validateAndStoreLicense(newValue);
+	}
+
+	@FXML
+	public void getDonationKey() {
+		application.getHostServices().showDocument(DONATION_URI);
+	}
+
+	public LicenseHolder getLicenseHolder() {
+		return licenseHolder;
+	}
+}

main/ui/src/main/java/org/cryptomator/ui/preferences/GeneralPreferencesController.java

@@ -1,6 +1,9 @@
 package org.cryptomator.ui.preferences;
 
+import javafx.application.Platform;
 import javafx.beans.value.ObservableValue;
+import javafx.concurrent.Task;
+import javafx.fxml.FXML;
 import javafx.geometry.NodeOrientation;
 import javafx.scene.control.CheckBox;
 import javafx.scene.control.ChoiceBox;
@@ -8,6 +11,7 @@ import javafx.scene.control.RadioButton;
 import javafx.scene.control.Toggle;
 import javafx.scene.control.ToggleGroup;
 import javafx.util.StringConverter;
+import org.cryptomator.common.LicenseHolder;
 import org.cryptomator.common.settings.Settings;
 import org.cryptomator.common.settings.UiTheme;
 import org.cryptomator.ui.common.FxController;
@@ -15,25 +19,38 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import javax.inject.Inject;
+import javax.inject.Named;
+import java.util.Optional;
+import java.util.concurrent.ExecutorService;
 
 @PreferencesScoped
 public class GeneralPreferencesController implements FxController {
-	
+
 	private static final Logger LOG = LoggerFactory.getLogger(GeneralPreferencesController.class);
 
 	private final Settings settings;
+	private final boolean trayMenuSupported;
+	private final Optional<AutoStartStrategy> autoStartStrategy;
+	private final LicenseHolder licenseHolder;
+	private final ExecutorService executor;
 	public ChoiceBox<UiTheme> themeChoiceBox;
 	public CheckBox startHiddenCheckbox;
 	public CheckBox debugModeCheckbox;
+	public CheckBox autoStartCheckbox;
 	public ToggleGroup nodeOrientation;
 	public RadioButton nodeOrientationLtr;
 	public RadioButton nodeOrientationRtl;
 
 	@Inject
-	GeneralPreferencesController(Settings settings) {
+	GeneralPreferencesController(Settings settings, @Named("trayMenuSupported") boolean trayMenuSupported, Optional<AutoStartStrategy> autoStartStrategy, LicenseHolder licenseHolder, ExecutorService executor) {
 		this.settings = settings;
+		this.trayMenuSupported = trayMenuSupported;
+		this.autoStartStrategy = autoStartStrategy;
+		this.licenseHolder = licenseHolder;
+		this.executor = executor;
 	}
 
+	@FXML
 	public void initialize() {
 		themeChoiceBox.getItems().addAll(UiTheme.values());
 		themeChoiceBox.valueProperty().bindBidirectional(settings.theme());
@@ -43,9 +60,23 @@ public class GeneralPreferencesController implements FxController {
 
 		debugModeCheckbox.selectedProperty().bindBidirectional(settings.debugMode());
 
-		nodeOrientation.selectedToggleProperty().addListener(this::toggleNodeOrientation);
+		autoStartStrategy.ifPresent(autoStart -> {
+			autoStart.isAutoStartEnabled().thenAccept(enabled -> {
+				Platform.runLater(() -> autoStartCheckbox.setSelected(enabled));
+			});
+		});
+
 		nodeOrientationLtr.setSelected(settings.userInterfaceOrientation().get() == NodeOrientation.LEFT_TO_RIGHT);
 		nodeOrientationRtl.setSelected(settings.userInterfaceOrientation().get() == NodeOrientation.RIGHT_TO_LEFT);
+		nodeOrientation.selectedToggleProperty().addListener(this::toggleNodeOrientation);
+	}
+
+	public boolean isTrayMenuSupported() {
+		return this.trayMenuSupported;
+	}
+
+	public boolean isAutoStartSupported() {
+		return autoStartStrategy.isPresent();
 	}
 
 	private void toggleNodeOrientation(@SuppressWarnings("unused") ObservableValue<? extends Toggle> observable, @SuppressWarnings("unused") Toggle oldValue, Toggle newValue) {
@@ -58,6 +89,20 @@ public class GeneralPreferencesController implements FxController {
 		}
 	}
 
+	@FXML
+	public void toggleAutoStart() {
+		autoStartStrategy.ifPresent(autoStart -> {
+			boolean enableAutoStart = autoStartCheckbox.isSelected();
+			Task<Void> toggleTask = new ToggleAutoStartTask(autoStart, enableAutoStart);
+			toggleTask.setOnFailed(evt -> autoStartCheckbox.setSelected(!enableAutoStart)); // restore previous state
+			executor.execute(toggleTask);
+		});
+	}
+
+	public LicenseHolder getLicenseHolder() {
+		return licenseHolder;
+	}
+
 	/* Helper classes */
 
 	private static class UiThemeConverter extends StringConverter<UiTheme> {
@@ -73,4 +118,25 @@ public class GeneralPreferencesController implements FxController {
 		}
 	}
 
+	private static class ToggleAutoStartTask extends Task<Void> {
+
+		private final AutoStartStrategy autoStart;
+		private final boolean enable;
+
+		public ToggleAutoStartTask(AutoStartStrategy autoStart, boolean enable) {
+			this.autoStart = autoStart;
+			this.enable = enable;
+		}
+
+		@Override
+		protected Void call() throws Exception {
+			if (enable) {
+				autoStart.enableAutoStart();
+			} else {
+				autoStart.disableAutoStart();
+			}
+			return null;
+		}
+	}
+
 }

main/ui/src/main/java/org/cryptomator/ui/preferences/PreferencesComponent.java

@@ -7,9 +7,9 @@ package org.cryptomator.ui.preferences;
 
 import dagger.Lazy;
 import dagger.Subcomponent;
+import javafx.beans.property.ObjectProperty;
 import javafx.scene.Scene;
 import javafx.stage.Stage;
-import org.cryptomator.ui.common.FXMLLoaderFactory;
 import org.cryptomator.ui.common.FxmlFile;
 import org.cryptomator.ui.common.FxmlScene;
 
@@ -23,7 +23,10 @@ public interface PreferencesComponent {
 	@FxmlScene(FxmlFile.PREFERENCES)
 	Lazy<Scene> scene();
 
-	default Stage showPreferencesWindow() {
+	ObjectProperty<SelectedPreferencesTab> selectedTabProperty();
+
+	default Stage showPreferencesWindow(SelectedPreferencesTab selectedTab) {
+		selectedTabProperty().set(selectedTab);
 		Stage stage = window();
 		stage.setScene(scene().get());
 		stage.show();

main/ui/src/main/java/org/cryptomator/ui/preferences/PreferencesController.java

@@ -1,6 +1,9 @@
 package org.cryptomator.ui.preferences;
 
+import javafx.beans.Observable;
 import javafx.beans.binding.BooleanBinding;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.value.ObservableValue;
 import javafx.fxml.FXML;
 import javafx.scene.control.Tab;
 import javafx.scene.control.TabPane;
@@ -15,26 +18,50 @@ import javax.inject.Inject;
 public class PreferencesController implements FxController {
 
 	private final Stage window;
+	private final ObjectProperty<SelectedPreferencesTab> selectedTabProperty;
 	private final BooleanBinding updateAvailable;
 	public TabPane tabPane;
 	public Tab generalTab;
+	public Tab volumeTab;
 	public Tab updatesTab;
+	public Tab donationKeyTab;
 
 	@Inject
-	public PreferencesController(@PreferencesWindow Stage window, UpdateChecker updateChecker) {
+	public PreferencesController(@PreferencesWindow Stage window, ObjectProperty<SelectedPreferencesTab> selectedTabProperty, UpdateChecker updateChecker) {
 		this.window = window;
+		this.selectedTabProperty = selectedTabProperty;
 		this.updateAvailable = updateChecker.latestVersionProperty().isNotNull();
 	}
 
 	@FXML
 	public void initialize() {
 		window.setOnShowing(this::windowWillAppear);
+		selectedTabProperty.addListener(observable -> this.selectChosenTab());
 	}
 
-	private void windowWillAppear(@SuppressWarnings("unused") WindowEvent windowEvent) {
+	private void selectChosenTab() {
-		if (updateAvailable.get()) {
+		Tab toBeSelected = getTabToSelect(selectedTabProperty.get());
-			tabPane.getSelectionModel().select(updatesTab);
+		tabPane.getSelectionModel().select(toBeSelected);
+	}
+
+	private Tab getTabToSelect(SelectedPreferencesTab selectedTab) {
+		switch (selectedTab) {
+			case UPDATES:
+				return updatesTab;
+			case VOLUME:
+				return volumeTab;
+			case DONATION_KEY:
+				return donationKeyTab;
+			case GENERAL:
+				return generalTab;
+			case ANY:
+			default:
+				return updateAvailable.get() ? updatesTab : generalTab;
 		}
 	}
 
+	private void windowWillAppear(@SuppressWarnings("unused") WindowEvent windowEvent) {
+		selectChosenTab();
+	}
+
 }

main/ui/src/main/java/org/cryptomator/ui/preferences/PreferencesModule.java

@@ -4,6 +4,8 @@ import dagger.Binds;
 import dagger.Module;
 import dagger.Provides;
 import dagger.multibindings.IntoMap;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleObjectProperty;
 import javafx.scene.Scene;
 import javafx.scene.image.Image;
 import javafx.stage.Stage;
@@ -16,13 +18,19 @@ import org.cryptomator.ui.common.FxmlScene;
 
 import javax.inject.Named;
 import javax.inject.Provider;
+import java.util.List;
 import java.util.Map;
-import java.util.Optional;
 import java.util.ResourceBundle;
 
-@Module
+@Module(includes = {AutoStartModule.class})
 abstract class PreferencesModule {
 
+	@Provides
+	@PreferencesScoped
+	static ObjectProperty<SelectedPreferencesTab> provideSelectedTabProperty() {
+		return new SimpleObjectProperty<>(SelectedPreferencesTab.ANY);
+	}
+
 	@Provides
 	@PreferencesWindow
 	@PreferencesScoped
@@ -33,11 +41,11 @@ abstract class PreferencesModule {
 	@Provides
 	@PreferencesWindow
 	@PreferencesScoped
-	static Stage provideStage(ResourceBundle resourceBundle, @Named("windowIcon") Optional<Image> windowIcon) {
+	static Stage provideStage(ResourceBundle resourceBundle, @Named("windowIcons") List<Image> windowIcons) {
 		Stage stage = new Stage();
 		stage.setTitle(resourceBundle.getString("preferences.title"));
 		stage.setResizable(false);
-		windowIcon.ifPresent(stage.getIcons()::add);
+		stage.getIcons().addAll(windowIcons);
 		return stage;
 	}
 
@@ -70,4 +78,9 @@ abstract class PreferencesModule {
 	@FxControllerKey(VolumePreferencesController.class)
 	abstract FxController bindVolumePreferencesController(VolumePreferencesController controller);
 
+	@Binds
+	@IntoMap
+	@FxControllerKey(DonationKeyPreferencesController.class)
+	abstract FxController bindDonationKeyPreferencesController(DonationKeyPreferencesController controller);
+
 }

main/ui/src/main/java/org/cryptomator/ui/preferences/SelectedPreferencesTab.java

@@ -0,0 +1,28 @@
+package org.cryptomator.ui.preferences;
+
+public enum SelectedPreferencesTab {
+	/**
+	 * Let the controller decide which tab to show.
+	 */
+	ANY,
+
+	/**
+	 * Show general tab
+	 */
+	GENERAL,
+
+	/**
+	 * Show volume tab
+	 */
+	VOLUME,
+
+	/**
+	 * Show updates tab
+	 */
+	UPDATES,
+
+	/**
+	 * Show donation key tab
+	 */
+	DONATION_KEY,
+}

main/ui/src/main/java/org/cryptomator/ui/quit/QuitController.java

@@ -1,26 +1,22 @@
 package org.cryptomator.ui.quit;
 
-import javafx.application.Platform;
 import javafx.collections.ObservableList;
-import javafx.concurrent.ScheduledService;
 import javafx.concurrent.Task;
 import javafx.fxml.FXML;
 import javafx.scene.control.Button;
 import javafx.scene.control.ContentDisplay;
 import javafx.stage.Stage;
 import org.cryptomator.common.vaults.Vault;
-import org.cryptomator.common.vaults.VaultState;
-import org.cryptomator.common.vaults.Volume;
 import org.cryptomator.ui.common.FxController;
+import org.cryptomator.ui.common.VaultService;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import javax.inject.Inject;
 import java.awt.desktop.QuitResponse;
-import java.util.Iterator;
+import java.util.Collection;
-import java.util.List;
-import java.util.concurrent.Executor;
 import java.util.concurrent.ExecutorService;
+import java.util.stream.Collectors;
 
 @QuitScoped
 public class QuitController implements FxController {
@@ -30,15 +26,17 @@ public class QuitController implements FxController {
 	private final Stage window;
 	private final QuitResponse response;
 	private final ObservableList<Vault> unlockedVaults;
-	private final ExecutorService executor;
+	private final ExecutorService executorService;
+	private final VaultService vaultService;
 	public Button lockAndQuitButton;
 
 	@Inject
-	QuitController(@QuitWindow Stage window, QuitResponse response, ObservableList<Vault> vaults, ExecutorService executor) {
+	QuitController(@QuitWindow Stage window, QuitResponse response, ObservableList<Vault> vaults, ExecutorService executorService, VaultService vaultService) {
 		this.window = window;
 		this.response = response;
 		this.unlockedVaults = vaults.filtered(Vault::isUnlocked);
-		this.executor = executor;
+		this.executorService = executorService;
+		this.vaultService = vaultService;
 	}
 
 	@FXML
@@ -52,84 +50,24 @@ public class QuitController implements FxController {
 	public void lockAndQuit() {
 		lockAndQuitButton.setDisable(true);
 		lockAndQuitButton.setContentDisplay(ContentDisplay.LEFT);
-		
+
-		Iterator<Vault> toBeLocked = List.copyOf(unlockedVaults).iterator();
+		Task<Collection<Vault>> lockAllTask = vaultService.createLockAllTask(unlockedVaults, false);
-		ScheduledService<Void> lockAllService = new LockAllVaultsService(executor, toBeLocked);
+		lockAllTask.setOnSucceeded(evt -> {
-		lockAllService.setOnSucceeded(evt -> {
+			LOG.info("Locked {}", lockAllTask.getValue().stream().map(Vault::getDisplayableName).collect(Collectors.joining(", ")));
-			if (!toBeLocked.hasNext()) {
+			if (unlockedVaults.isEmpty()) {
 				window.close();
 				response.performQuit();
 			}
 		});
-		lockAllService.setOnFailed(evt -> {
+		lockAllTask.setOnFailed(evt -> {
+			LOG.warn("Locking failed", lockAllTask.getException());
 			lockAndQuitButton.setDisable(false);
 			lockAndQuitButton.setContentDisplay(ContentDisplay.TEXT_ONLY);
 			// TODO: show force lock or force quit scene (and DO NOT cancelQuit() here!)
 			// see https://github.com/cryptomator/cryptomator/blob/1.4.16/main/ui/src/main/java/org/cryptomator/ui/model/Vault.java#L151-L163
 			response.cancelQuit();
 		});
-		lockAllService.start();
+		executorService.execute(lockAllTask);
 	}
 
-	/**
-	 * @param vault The vault to lock
-	 * @return Task that tries to lock the given vault gracefully.
-	 */
-	private Task<Void> createGracefulLockTask(Vault vault) {
-		Task task = new Task<Void>() {
-			@Override
-			protected Void call() throws Volume.VolumeException {
-				vault.lock(false);
-				LOG.info("Locked {}", vault.getDisplayableName());
-				return null;
-			}
-		};
-		task.setOnScheduled(evt -> {
-			vault.setState(VaultState.PROCESSING);
-		});
-		task.setOnSucceeded(evt -> {
-			vault.setState(VaultState.LOCKED);
-		});
-		task.setOnFailed(evt -> {
-			LOG.warn("Failed to lock vault", vault);
-		});
-		return task;
-	}
-
-	/**
-	 * @return Task that succeeds immediately
-	 */
-	private Task<Void> createNoopTask() {
-		return new Task<>() {
-			@Override
-			protected Void call() {
-				return null;
-			}
-		};
-	}
-	
-	private class LockAllVaultsService extends ScheduledService<Void> {
-
-		private final Iterator<Vault> vaultsToLock;
-
-		public LockAllVaultsService(Executor executor, Iterator<Vault> vaultsToLock) {
-			this.vaultsToLock = vaultsToLock;
-			setExecutor(executor);
-			setRestartOnFailure(false);
-		}
-
-		@Override
-		protected Task<Void> createTask() {
-			assert Platform.isFxApplicationThread();
-			if (vaultsToLock.hasNext()) {
-				return createGracefulLockTask(vaultsToLock.next());
-			} else {
-				// This should be unreachable code, since vaultsToLock is only accessed on the FX App Thread.
-				// But if quitting the application takes longer for any reason, this service should shut down properly
-				reset();
-				return createNoopTask();
-			}
-		}
-	}
-	
 }

main/ui/src/main/java/org/cryptomator/ui/quit/QuitModule.java

@@ -20,8 +20,8 @@ import org.cryptomator.ui.common.FxmlScene;
 
 import javax.inject.Named;
 import javax.inject.Provider;
+import java.util.List;
 import java.util.Map;
-import java.util.Optional;
 import java.util.ResourceBundle;
 
 @Module
@@ -37,12 +37,12 @@ abstract class QuitModule {
 	@Provides
 	@QuitWindow
 	@QuitScoped
-	static Stage provideStage(@Named("windowIcon") Optional<Image> windowIcon) {
+	static Stage provideStage(@Named("windowIcons") List<Image> windowIcons) {
 		Stage stage = new Stage();
 		stage.setMinWidth(300);
 		stage.setMinHeight(100);
 		stage.initModality(Modality.APPLICATION_MODAL);
-		windowIcon.ifPresent(stage.getIcons()::add);
+		stage.getIcons().addAll(windowIcons);
 		return stage;
 	}
 

main/ui/src/main/java/org/cryptomator/ui/recoverykey/AutoCompleter.java

@@ -0,0 +1,69 @@
+package org.cryptomator.ui.recoverykey;
+
+import com.google.common.base.Strings;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+
+public class AutoCompleter {
+
+	private final List<String> dictionary;
+
+	public AutoCompleter(Collection<String> dictionary) {
+		this.dictionary = unmodifiableSortedRandomAccessList(dictionary);
+	}
+
+	private static <T extends Comparable<T>> List<T> unmodifiableSortedRandomAccessList(Collection<T> items) {
+		List<T> result = new ArrayList<>(items);
+		Collections.sort(result);
+		return Collections.unmodifiableList(result);
+	}
+
+	public Optional<String> autocomplete(String prefix) {
+		if (Strings.isNullOrEmpty(prefix)) {
+			return Optional.empty();
+		}
+		int potentialMatchIdx = findIndexOfLexicographicallyPreceeding(0, dictionary.size(), prefix);
+		if (potentialMatchIdx < dictionary.size()) {
+			String potentialMatch = dictionary.get(potentialMatchIdx);
+			return potentialMatch.startsWith(prefix) ? Optional.of(potentialMatch) : Optional.empty();
+		} else {
+			return Optional.empty();
+		}
+	}
+
+	/**
+	 * Find the index of the first word in {@link #dictionary} that starts with a given prefix.
+	 * 
+	 * This method performs an "unsuccessful" binary search (it doesn't return when encountering an exact match).
+	 * Instead it continues searching in the left half (which includes the exact match) until only one element is left.
+	 * 
+	 * If the dictionary doesn't contain a word "left" of the given prefix, this method returns an invalid index, though.
+	 *
+	 * @param begin Index of first element (inclusive)
+	 * @param end Index of last element (exclusive)
+	 * @param prefix
+	 * @return index between [0, dictLen], i.e. index can exceed the upper bounds of {@link #dictionary}.
+	 */
+	private int findIndexOfLexicographicallyPreceeding(int begin, int end, String prefix) {
+		if (begin >= end) {
+			return begin; // this is usually where a binary search ends "unsuccessful"
+		}
+
+		int mid = (begin + end) / 2;
+		String word = dictionary.get(mid);
+		if (prefix.compareTo(word) <= 0) { // prefix preceeds or matches word
+			// proceed in left half
+			assert mid < end;
+			return findIndexOfLexicographicallyPreceeding(0, mid, prefix);
+		} else {
+			// proceed in right half
+			assert mid >= begin;
+			return findIndexOfLexicographicallyPreceeding(mid + 1, end, prefix);
+		}
+	}
+
+}

main/ui/src/main/java/org/cryptomator/ui/recoverykey/RecoveryKeyComponent.java

@@ -21,11 +21,21 @@ public interface RecoveryKeyComponent {
 	Stage window();
 
 	@FxmlScene(FxmlFile.RECOVERYKEY_CREATE)
-	Lazy<Scene> scene();
+	Lazy<Scene> creationScene();
+
+	@FxmlScene(FxmlFile.RECOVERYKEY_RECOVER)
+	Lazy<Scene> recoverScene();
 
 	default void showRecoveryKeyCreationWindow() {
 		Stage stage = window();
-		stage.setScene(scene().get());
+		stage.setScene(creationScene().get());
+		stage.sizeToScene();
+		stage.show();
+	}
+
+	default void showRecoveryKeyRecoverWindow() {
+		Stage stage = window();
+		stage.setScene(recoverScene().get());
 		stage.sizeToScene();
 		stage.show();
 	}

main/ui/src/main/java/org/cryptomator/ui/recoverykey/RecoveryKeyCreationController.java

@@ -1,27 +1,21 @@
 package org.cryptomator.ui.recoverykey;
 
 import dagger.Lazy;
-import javafx.animation.KeyFrame;
-import javafx.animation.KeyValue;
-import javafx.animation.Timeline;
-import javafx.beans.property.ReadOnlyStringProperty;
 import javafx.beans.property.StringProperty;
-import javafx.beans.value.WritableValue;
+import javafx.concurrent.Task;
 import javafx.fxml.FXML;
 import javafx.scene.Scene;
 import javafx.stage.Stage;
-import javafx.util.Duration;
 import org.cryptomator.common.vaults.Vault;
 import org.cryptomator.cryptolib.api.InvalidPassphraseException;
+import org.cryptomator.ui.common.Animations;
 import org.cryptomator.ui.common.FxController;
 import org.cryptomator.ui.common.FxmlFile;
 import org.cryptomator.ui.common.FxmlScene;
-import org.cryptomator.ui.common.Tasks;
 import org.cryptomator.ui.controls.NiceSecurePasswordField;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import javax.annotation.Nullable;
 import javax.inject.Inject;
 import java.io.IOException;
 import java.util.concurrent.ExecutorService;
@@ -40,7 +34,7 @@ public class RecoveryKeyCreationController implements FxController {
 	public NiceSecurePasswordField passwordField;
 
 	@Inject
-	public RecoveryKeyCreationController(@RecoveryKeyWindow Stage window, @FxmlScene(FxmlFile.RECOVERYKEY_DISPLAY) Lazy<Scene> successScene, @RecoveryKeyWindow Vault vault, RecoveryKeyFactory recoveryKeyFactory, ExecutorService executor, @RecoveryKeyWindow StringProperty recoveryKey) {
+	public RecoveryKeyCreationController(@RecoveryKeyWindow Stage window, @FxmlScene(FxmlFile.RECOVERYKEY_SUCCESS) Lazy<Scene> successScene, @RecoveryKeyWindow Vault vault, RecoveryKeyFactory recoveryKeyFactory, ExecutorService executor, @RecoveryKeyWindow StringProperty recoveryKey) {
 		this.window = window;
 		this.successScene = successScene;
 		this.vault = vault;
@@ -48,19 +42,26 @@ public class RecoveryKeyCreationController implements FxController {
 		this.recoveryKeyFactory = recoveryKeyFactory;
 		this.recoveryKeyProperty = recoveryKey;
 	}
-	
+
 	@FXML
 	public void createRecoveryKey() {
-		Tasks.create(() -> {
+		Task<String> task = new RecoveryKeyCreationTask();
-			return recoveryKeyFactory.createRecoveryKey(vault.getPath(), passwordField.getCharacters());
+		task.setOnScheduled(event -> {
-		}).onSuccess(result -> {
+			LOG.debug("Creating recovery key for {}.", vault.getDisplayablePath());
-			recoveryKeyProperty.set(result);
+		});
+		task.setOnSucceeded(event -> {
+			String recoveryKey = task.getValue();
+			recoveryKeyProperty.set(recoveryKey);
 			window.setScene(successScene.get());
-		}).onError(IOException.class, e -> {
+		});
-			LOG.error("Creation of recovery key failed.", e);
+		task.setOnFailed(event -> {
-		}).onError(InvalidPassphraseException.class, e -> {
+			if (task.getException() instanceof InvalidPassphraseException) {
-			shakeWindow();
+				Animations.createShakeWindowAnimation(window).play();
-		}).runOnce(executor);
+			} else {
+				LOG.error("Creation of recovery key failed.", task.getException());
+			}
+		});
+		executor.submit(task);
 	}
 
 	@FXML
@@ -68,31 +69,13 @@ public class RecoveryKeyCreationController implements FxController {
 		window.close();
 	}
 
-	/* Animations */
+	private class RecoveryKeyCreationTask extends Task<String> {
 
-	private void shakeWindow() {
+		@Override
-		WritableValue<Double> writableWindowX = new WritableValue<>() {
+		protected String call() throws IOException {
-			@Override
+			return recoveryKeyFactory.createRecoveryKey(vault.getPath(), passwordField.getCharacters());
-			public Double getValue() {
+		}
-				return window.getX();
-			}
 
-			@Override
-			public void setValue(Double value) {
-				window.setX(value);
-			}
-		};
-		Timeline timeline = new Timeline( //
-				new KeyFrame(Duration.ZERO, new KeyValue(writableWindowX, window.getX())), //
-				new KeyFrame(new Duration(100), new KeyValue(writableWindowX, window.getX() - 22.0)), //
-				new KeyFrame(new Duration(200), new KeyValue(writableWindowX, window.getX() + 18.0)), //
-				new KeyFrame(new Duration(300), new KeyValue(writableWindowX, window.getX() - 14.0)), //
-				new KeyFrame(new Duration(400), new KeyValue(writableWindowX, window.getX() + 10.0)), //
-				new KeyFrame(new Duration(500), new KeyValue(writableWindowX, window.getX() - 6.0)), //
-				new KeyFrame(new Duration(600), new KeyValue(writableWindowX, window.getX() + 2.0)), //
-				new KeyFrame(new Duration(700), new KeyValue(writableWindowX, window.getX())) //
-		);
-		timeline.play();
 	}
 
 	/* Getter/Setter */

main/ui/src/main/java/org/cryptomator/ui/recoverykey/RecoveryKeyDisplayController.java

@@ -1,26 +1,81 @@
 package org.cryptomator.ui.recoverykey;
 
-import javafx.beans.property.ReadOnlyStringProperty;
-import javafx.beans.property.StringProperty;
 import javafx.fxml.FXML;
+import javafx.print.PageLayout;
+import javafx.print.Printer;
+import javafx.print.PrinterJob;
+import javafx.scene.control.Button;
+import javafx.scene.input.Clipboard;
+import javafx.scene.input.ClipboardContent;
+import javafx.scene.text.Font;
+import javafx.scene.text.FontSmoothingType;
+import javafx.scene.text.FontWeight;
+import javafx.scene.text.Text;
+import javafx.scene.text.TextFlow;
 import javafx.stage.Stage;
-import org.cryptomator.common.vaults.Vault;
 import org.cryptomator.ui.common.FxController;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
-import javax.inject.Inject;
+import java.util.ResourceBundle;
 
-@RecoveryKeyScoped
 public class RecoveryKeyDisplayController implements FxController {
+	
+	private static final Logger LOG = LoggerFactory.getLogger(RecoveryKeyDisplayController.class);
 
 	private final Stage window;
-	private final Vault vault;
+	private final String vaultName;
-	private final StringProperty recoveryKeyProperty;
+	private final String recoveryKey;
+	private final ResourceBundle localization;
+	public Button copyButton;
 
-	@Inject
+	public RecoveryKeyDisplayController(Stage window, String vaultName, String recoveryKey, ResourceBundle localization) {
-	public RecoveryKeyDisplayController(@RecoveryKeyWindow Stage window, @RecoveryKeyWindow Vault vault, @RecoveryKeyWindow StringProperty recoveryKey) {
 		this.window = window;
-		this.vault = vault;
+		this.vaultName = vaultName;
-		this.recoveryKeyProperty = recoveryKey;
+		this.recoveryKey = recoveryKey;
+		this.localization = localization;
+	}
+
+	@FXML
+	public void printRecoveryKey() {
+		// TODO localize
+
+		PrinterJob job = PrinterJob.createPrinterJob();
+		if (job != null && job.showPrintDialog(window)) {
+			PageLayout pageLayout = job.getJobSettings().getPageLayout();
+
+			Text heading = new Text("Cryptomator Recovery Key\n" + vaultName + "\n");
+			heading.setFont(Font.font("serif", FontWeight.BOLD, 20));
+			heading.setFontSmoothingType(FontSmoothingType.LCD);
+
+			Text key = new Text(recoveryKey);
+			key.setFont(Font.font("serif", FontWeight.NORMAL, 16));
+			key.setFontSmoothingType(FontSmoothingType.GRAY);
+
+			TextFlow textFlow = new TextFlow();
+			textFlow.setPrefSize(pageLayout.getPrintableWidth(), pageLayout.getPrintableHeight());
+			textFlow.getChildren().addAll(heading, key);
+			textFlow.setLineSpacing(6);
+
+			if (job.printPage(textFlow)) {
+				LOG.info("Recovery key printed.");
+				job.endJob();
+			} else {
+				LOG.warn("Printing recovery key failed.");
+			}
+		} else {
+			LOG.info("Printing recovery key canceled by user.");
+		}
+	}
+
+	@FXML
+	public void copyRecoveryKey() {
+		ClipboardContent clipboardContent = new ClipboardContent();
+		clipboardContent.putString(recoveryKey);
+		Clipboard.getSystemClipboard().setContent(clipboardContent);
+		LOG.info("Recovery key copied to clipboard.");
+
+		copyButton.setText(localization.getString("generic.button.copied"));
 	}
 
 	@FXML
@@ -30,15 +85,15 @@ public class RecoveryKeyDisplayController implements FxController {
 
 	/* Getter/Setter */
 
-	public Vault getVault() {
+	public boolean isPrinterSupported() {
-		return vault;
+		return Printer.getDefaultPrinter() != null;
-	}
-
-	public ReadOnlyStringProperty recoveryKeyProperty() {
-		return recoveryKeyProperty;
 	}
 
 	public String getRecoveryKey() {
-		return recoveryKeyProperty.get();
+		return recoveryKey;
+	}
+
+	public String getVaultName() {
+		return vaultName;
 	}
 }

main/ui/src/main/java/org/cryptomator/ui/recoverykey/RecoveryKeyFactory.java

@@ -10,11 +10,13 @@ import javax.inject.Singleton;
 import java.io.IOException;
 import java.nio.file.Path;
 import java.util.Arrays;
+import java.util.Collection;
 
 @Singleton
 public class RecoveryKeyFactory {
 
 	private static final String MASTERKEY_FILENAME = "masterkey.cryptomator"; // TODO: deduplicate constant declared in multiple classes
+	private static final byte[] PEPPER = new byte[0];
 	
 	private final WordEncoder wordEncoder;
 	
@@ -22,6 +24,10 @@ public class RecoveryKeyFactory {
 	public RecoveryKeyFactory(WordEncoder wordEncoder) {
 		this.wordEncoder = wordEncoder;
 	}
+	
+	public Collection<String> getDictionary() {
+		return wordEncoder.getWords();
+	}
 
 	/**
 	 * @param vaultPath Path to the storage location of a vault
@@ -32,7 +38,7 @@ public class RecoveryKeyFactory {
 	 * @apiNote This is a long-running operation and should be invoked in a background thread
 	 */
 	public String createRecoveryKey(Path vaultPath, CharSequence password) throws IOException, InvalidPassphraseException {
-		byte[] rawKey = CryptoFileSystemProvider.exportRawKey(vaultPath, MASTERKEY_FILENAME, new byte[0], password);
+		byte[] rawKey = CryptoFileSystemProvider.exportRawKey(vaultPath, MASTERKEY_FILENAME, PEPPER, password);
 		try {
 			return createRecoveryKey(rawKey);
 		} finally {
@@ -53,26 +59,53 @@ public class RecoveryKeyFactory {
 		}
 	}
 
+	/**
+	 * Creates a completely new masterkey using a recovery key.
+	 * @param vaultPath Path to the storage location of a vault
+	 * @param recoveryKey A recovery key for this vault
+	 * @param newPassword The new password used to encrypt the keys
+	 * @throws IOException If the masterkey file could not be written
+	 * @throws IllegalArgumentException If the recoveryKey is invalid
+	 * @apiNote This is a long-running operation and should be invoked in a background thread
+	 */
+	public void resetPasswordWithRecoveryKey(Path vaultPath, String recoveryKey, CharSequence newPassword) throws IOException, IllegalArgumentException {
+		final byte[] rawKey = decodeRecoveryKey(recoveryKey);
+		try {
+			CryptoFileSystemProvider.restoreRawKey(vaultPath, MASTERKEY_FILENAME, rawKey, PEPPER, newPassword);
+		} finally {
+			Arrays.fill(rawKey, (byte) 0x00);
+		}
+	}
+
 	/**
 	 * Checks whether a String is a syntactically correct recovery key with a valid checksum
 	 * @param recoveryKey A word sequence which might be a recovery key
 	 * @return <code>true</code> if this seems to be a legitimate recovery key
 	 */
 	public boolean validateRecoveryKey(String recoveryKey) {
-		final byte[] paddedKey;
 		try {
-			paddedKey = wordEncoder.decode(recoveryKey);
+			byte[] key = decodeRecoveryKey(recoveryKey);
+			Arrays.fill(key, (byte) 0x00);
+			return true;
 		} catch (IllegalArgumentException e) {
 			return false;
 		}
-		if (paddedKey.length != 66) {
+	}
-			return false;
+	
+	private byte[] decodeRecoveryKey(String recoveryKey) throws IllegalArgumentException {
+		byte[] paddedKey = new byte[0];
+		try {
+			paddedKey = wordEncoder.decode(recoveryKey);
+			Preconditions.checkArgument(paddedKey.length == 66, "Recovery key doesn't consist of 66 bytes.");
+			byte[] rawKey = Arrays.copyOf(paddedKey, 64);
+			byte[] expectedCrc16 = Arrays.copyOfRange(paddedKey, 64, 66);
+			byte[] actualCrc32 = Hashing.crc32().hashBytes(rawKey).asBytes();
+			byte[] actualCrc16 = Arrays.copyOf(actualCrc32, 2);
+			Preconditions.checkArgument(Arrays.equals(expectedCrc16, actualCrc16), "Recovery key has invalid CRC.");
+			return rawKey;
+		} finally {
+			Arrays.fill(paddedKey, (byte) 0x00);
 		}
-		byte[] rawKey = Arrays.copyOf(paddedKey, 64);
-		byte[] expectedCrc16 = Arrays.copyOfRange(paddedKey, 64, 66);
-		byte[] actualCrc32 = Hashing.crc32().hashBytes(rawKey).asBytes();
-		byte[] actualCrc16 = Arrays.copyOf(actualCrc32, 2);
-		return Arrays.equals(expectedCrc16, actualCrc16);
 	}
 
 }

main/ui/src/main/java/org/cryptomator/ui/recoverykey/RecoveryKeyModule.java

@@ -4,23 +4,28 @@ import dagger.Binds;
 import dagger.Module;
 import dagger.Provides;
 import dagger.multibindings.IntoMap;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleObjectProperty;
 import javafx.beans.property.SimpleStringProperty;
 import javafx.beans.property.StringProperty;
 import javafx.scene.Scene;
 import javafx.scene.image.Image;
 import javafx.stage.Modality;
 import javafx.stage.Stage;
+import org.cryptomator.common.vaults.Vault;
 import org.cryptomator.ui.common.DefaultSceneFactory;
 import org.cryptomator.ui.common.FXMLLoaderFactory;
 import org.cryptomator.ui.common.FxController;
 import org.cryptomator.ui.common.FxControllerKey;
 import org.cryptomator.ui.common.FxmlFile;
 import org.cryptomator.ui.common.FxmlScene;
+import org.cryptomator.ui.common.NewPasswordController;
+import org.cryptomator.ui.common.PasswordStrengthUtil;
 
 import javax.inject.Named;
 import javax.inject.Provider;
+import java.util.List;
 import java.util.Map;
-import java.util.Optional;
 import java.util.ResourceBundle;
 
 @Module
@@ -36,13 +41,13 @@ abstract class RecoveryKeyModule {
 	@Provides
 	@RecoveryKeyWindow
 	@RecoveryKeyScoped
-	static Stage provideStage(ResourceBundle resourceBundle, @Named("windowIcon") Optional<Image> windowIcon, @Named("keyRecoveryOwner") Stage owner) {
+	static Stage provideStage(ResourceBundle resourceBundle, @Named("windowIcons") List<Image> windowIcons, @Named("keyRecoveryOwner") Stage owner) {
 		Stage stage = new Stage();
 		stage.setTitle(resourceBundle.getString("recoveryKey.title"));
 		stage.setResizable(false);
 		stage.initModality(Modality.WINDOW_MODAL);
 		stage.initOwner(owner);
-		windowIcon.ifPresent(stage.getIcons()::add);
+		stage.getIcons().addAll(windowIcons);
 		return stage;
 	}
 	
@@ -52,7 +57,15 @@ abstract class RecoveryKeyModule {
 	static StringProperty provideRecoveryKeyProperty() {
 		return new SimpleStringProperty();
 	}
-	
+
+	@Provides
+	@RecoveryKeyScoped
+	@Named("newPassword")
+	static ObjectProperty<CharSequence> provideNewPasswordProperty() {
+		return new SimpleObjectProperty<>("");
+	}
+
+
 	// ------------------
 
 	@Provides
@@ -63,10 +76,24 @@ abstract class RecoveryKeyModule {
 	}
 
 	@Provides
-	@FxmlScene(FxmlFile.RECOVERYKEY_DISPLAY)
+	@FxmlScene(FxmlFile.RECOVERYKEY_SUCCESS)
 	@RecoveryKeyScoped
-	static Scene provideRecoveryKeyDisplayScene(@RecoveryKeyWindow FXMLLoaderFactory fxmlLoaders) {
+	static Scene provideRecoveryKeySuccessScene(@RecoveryKeyWindow FXMLLoaderFactory fxmlLoaders) {
-		return fxmlLoaders.createScene("/fxml/recoverykey_display.fxml");
+		return fxmlLoaders.createScene("/fxml/recoverykey_success.fxml");
+	}
+
+	@Provides
+	@FxmlScene(FxmlFile.RECOVERYKEY_RECOVER)
+	@RecoveryKeyScoped
+	static Scene provideRecoveryKeyRecoverScene(@RecoveryKeyWindow FXMLLoaderFactory fxmlLoaders) {
+		return fxmlLoaders.createScene("/fxml/recoverykey_recover.fxml");
+	}
+
+	@Provides
+	@FxmlScene(FxmlFile.RECOVERYKEY_RESET_PASSWORD)
+	@RecoveryKeyScoped
+	static Scene provideRecoveryKeyResetPasswordScene(@RecoveryKeyWindow FXMLLoaderFactory fxmlLoaders) {
+		return fxmlLoaders.createScene("/fxml/recoverykey_reset_password.fxml");
 	}
 
 	// ------------------
@@ -76,9 +103,33 @@ abstract class RecoveryKeyModule {
 	@FxControllerKey(RecoveryKeyCreationController.class)
 	abstract FxController bindRecoveryKeyCreationController(RecoveryKeyCreationController controller);
 
-	@Binds
+	@Provides
 	@IntoMap
 	@FxControllerKey(RecoveryKeyDisplayController.class)
-	abstract FxController bindRecoveryKeyDisplayController(RecoveryKeyDisplayController controller);
+	static FxController provideRecoveryKeyDisplayController(@RecoveryKeyWindow Stage window, @RecoveryKeyWindow Vault vault, @RecoveryKeyWindow StringProperty recoveryKey, ResourceBundle localization) {
+		return new RecoveryKeyDisplayController(window, vault.getDisplayableName(), recoveryKey.get(), localization);
+	}
+
+	@Binds
+	@IntoMap
+	@FxControllerKey(RecoveryKeyRecoverController.class)
+	abstract FxController provideRecoveryKeyRecoverController(RecoveryKeyRecoverController controller);
+
+	@Binds
+	@IntoMap
+	@FxControllerKey(RecoveryKeySuccessController.class)
+	abstract FxController bindRecoveryKeySuccessController(RecoveryKeySuccessController controller);
+
+	@Binds
+	@IntoMap
+	@FxControllerKey(RecoveryKeyResetPasswordController.class)
+	abstract FxController bindRecoveryKeyResetPasswordController(RecoveryKeyResetPasswordController controller);
+
+	@Provides
+	@IntoMap
+	@FxControllerKey(NewPasswordController.class)
+	static FxController provideNewPasswordController(ResourceBundle resourceBundle, PasswordStrengthUtil strengthRater, @Named("newPassword") ObjectProperty<CharSequence> password) {
+		return new NewPasswordController(resourceBundle, strengthRater, password);
+	}
 	
 }

main/ui/src/main/java/org/cryptomator/ui/recoverykey/RecoveryKeyRecoverController.java

@@ -0,0 +1,116 @@
+package org.cryptomator.ui.recoverykey;
+
+import com.google.common.base.CharMatcher;
+import com.google.common.base.Strings;
+import dagger.Lazy;
+import javafx.beans.binding.Bindings;
+import javafx.beans.binding.BooleanBinding;
+import javafx.beans.property.StringProperty;
+import javafx.fxml.FXML;
+import javafx.scene.Scene;
+import javafx.scene.control.TextArea;
+import javafx.scene.control.TextFormatter;
+import javafx.scene.input.KeyCode;
+import javafx.scene.input.KeyEvent;
+import javafx.stage.Stage;
+import org.cryptomator.common.vaults.Vault;
+import org.cryptomator.ui.common.FxController;
+import org.cryptomator.ui.common.FxmlFile;
+import org.cryptomator.ui.common.FxmlScene;
+
+import javax.inject.Inject;
+import java.util.Optional;
+
+@RecoveryKeyScoped
+public class RecoveryKeyRecoverController implements FxController {
+
+	private final static CharMatcher ALLOWED_CHARS = CharMatcher.inRange('a', 'z').or(CharMatcher.is(' '));
+
+	private final Stage window;
+	private final Vault vault;
+	private final StringProperty recoveryKey;
+	private final RecoveryKeyFactory recoveryKeyFactory;
+	private final BooleanBinding validRecoveryKey;
+	private final Lazy<Scene> resetPasswordScene;
+	private final AutoCompleter autoCompleter;
+
+	public TextArea textarea;
+
+	@Inject
+	public RecoveryKeyRecoverController(@RecoveryKeyWindow Stage window, @RecoveryKeyWindow Vault vault, @RecoveryKeyWindow StringProperty recoveryKey, RecoveryKeyFactory recoveryKeyFactory, @FxmlScene(FxmlFile.RECOVERYKEY_RESET_PASSWORD) Lazy<Scene> resetPasswordScene) {
+		this.window = window;
+		this.vault = vault;
+		this.recoveryKey = recoveryKey;
+		this.recoveryKeyFactory = recoveryKeyFactory;
+		this.validRecoveryKey = Bindings.createBooleanBinding(this::isValidRecoveryKey, recoveryKey);
+		this.resetPasswordScene = resetPasswordScene;
+		this.autoCompleter = new AutoCompleter(recoveryKeyFactory.getDictionary());
+	}
+
+	@FXML
+	public void initialize() {
+		recoveryKey.bind(textarea.textProperty());
+	}
+
+	private TextFormatter.Change filterTextChange(TextFormatter.Change change) {
+		if (Strings.isNullOrEmpty(change.getText())) {
+			// pass-through caret/selection changes that don't affect the text
+			return change;
+		}
+		if (!ALLOWED_CHARS.matchesAllOf(change.getText())) {
+			return null; // reject change
+		}
+
+		String text = change.getControlNewText();
+		int caretPos = change.getCaretPosition();
+		if (caretPos == text.length() || text.charAt(caretPos) == ' ') { // are we at the end of a word?
+			int beginOfWord = Math.max(text.substring(0, caretPos).lastIndexOf(' ') + 1, 0);
+			String currentWord = text.substring(beginOfWord, caretPos);
+			Optional<String> suggestion = autoCompleter.autocomplete(currentWord);
+			if (suggestion.isPresent()) {
+				String completion = suggestion.get().substring(currentWord.length());
+				change.setText(change.getText() + completion);
+				change.setAnchor(caretPos + completion.length());
+			}
+		}
+		return change;
+	}
+
+	@FXML
+	public void onKeyPressed(KeyEvent keyEvent) {
+		if (keyEvent.getCode() == KeyCode.TAB && textarea.getAnchor() > textarea.getCaretPosition()) {
+			// apply autocompletion:
+			int pos = textarea.getAnchor();
+			textarea.insertText(pos, " ");
+			textarea.positionCaret(pos + 1);
+		}
+	}
+
+	@FXML
+	public void close() {
+		window.close();
+	}
+
+	@FXML
+	public void recover() {
+		window.setScene(resetPasswordScene.get());
+	}
+
+	/* Getter/Setter */
+
+	public Vault getVault() {
+		return vault;
+	}
+
+	public BooleanBinding validRecoveryKeyProperty() {
+		return validRecoveryKey;
+	}
+
+	public boolean isValidRecoveryKey() {
+		return recoveryKeyFactory.validateRecoveryKey(recoveryKey.get());
+	}
+
+	public TextFormatter getRecoveryKeyTextFormatter() {
+		return new TextFormatter<>(this::filterTextChange);
+	}
+}

main/ui/src/main/java/org/cryptomator/ui/recoverykey/RecoveryKeyResetPasswordController.java

@@ -0,0 +1,94 @@
+package org.cryptomator.ui.recoverykey;
+
+import dagger.Lazy;
+import javafx.beans.binding.Bindings;
+import javafx.beans.binding.BooleanBinding;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.StringProperty;
+import javafx.concurrent.Task;
+import javafx.fxml.FXML;
+import javafx.scene.Scene;
+import javafx.stage.Stage;
+import org.cryptomator.common.vaults.Vault;
+import org.cryptomator.cryptolib.api.InvalidPassphraseException;
+import org.cryptomator.ui.common.Animations;
+import org.cryptomator.ui.common.FxController;
+import org.cryptomator.ui.common.FxmlFile;
+import org.cryptomator.ui.common.FxmlScene;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.inject.Inject;
+import javax.inject.Named;
+import java.io.IOException;
+import java.util.concurrent.ExecutorService;
+
+@RecoveryKeyScoped
+public class RecoveryKeyResetPasswordController implements FxController {
+	
+	private static final Logger LOG = LoggerFactory.getLogger(RecoveryKeyResetPasswordController.class);
+
+	private final Stage window;
+	private final Vault vault;
+	private final RecoveryKeyFactory recoveryKeyFactory;
+	private final ExecutorService executor;
+	private final StringProperty recoveryKey;
+	private final ObjectProperty<CharSequence> newPassword;
+	private final Lazy<Scene> recoverScene;
+	private final BooleanBinding invalidNewPassword;
+
+	@Inject
+	public RecoveryKeyResetPasswordController(@RecoveryKeyWindow Stage window, @RecoveryKeyWindow Vault vault, RecoveryKeyFactory recoveryKeyFactory, ExecutorService executor, @RecoveryKeyWindow StringProperty recoveryKey, @Named("newPassword")ObjectProperty<CharSequence> newPassword, @FxmlScene(FxmlFile.RECOVERYKEY_RECOVER) Lazy<Scene> recoverScene) {
+		this.window = window;
+		this.vault = vault;
+		this.recoveryKeyFactory = recoveryKeyFactory;
+		this.executor = executor;
+		this.recoveryKey = recoveryKey;
+		this.newPassword = newPassword;
+		this.recoverScene = recoverScene;
+		this.invalidNewPassword = Bindings.createBooleanBinding(this::isInvalidNewPassword, newPassword);
+	}
+
+	@FXML
+	public void back() {
+		window.setScene(recoverScene.get());
+	}
+
+	@FXML
+	public void done() {
+		Task<Void> task = new ResetPasswordTask();
+		task.setOnScheduled(event -> {
+			LOG.debug("Using recovery key to reset password for {}.", vault.getDisplayablePath());
+		});
+		task.setOnSucceeded(event -> {
+			LOG.info("Used recovery key to reset password for {}.", vault.getDisplayablePath());
+			// TODO show success screen
+			window.close();
+		});
+		task.setOnFailed(event -> {
+			// TODO show generic error screen
+			LOG.error("Creation of recovery key failed.", task.getException());
+		});
+		executor.submit(task);
+	}
+
+	private class ResetPasswordTask extends Task<Void> {
+
+		@Override
+		protected Void call() throws IOException, IllegalArgumentException {
+			recoveryKeyFactory.resetPasswordWithRecoveryKey(vault.getPath(), recoveryKey.get(), newPassword.get());
+			return null;
+		}
+
+	}
+	
+	/* Getter/Setter */
+
+	public BooleanBinding invalidNewPasswordProperty() {
+		return invalidNewPassword;
+	}
+
+	public boolean isInvalidNewPassword() {
+		return newPassword.get() == null || newPassword.get().length() == 0;
+	}
+}

main/ui/src/main/java/org/cryptomator/ui/recoverykey/RecoveryKeySuccessController.java

@@ -0,0 +1,24 @@
+package org.cryptomator.ui.recoverykey;
+
+import javafx.fxml.FXML;
+import javafx.stage.Stage;
+import org.cryptomator.ui.common.FxController;
+
+import javax.inject.Inject;
+
+@RecoveryKeyScoped
+public class RecoveryKeySuccessController implements FxController {
+
+	private final Stage window;
+
+	@Inject
+	public RecoveryKeySuccessController(@RecoveryKeyWindow Stage window) {
+		this.window = window;
+	}
+
+	@FXML
+	public void close() {
+		window.close();
+	}
+
+}

main/ui/src/main/java/org/cryptomator/ui/recoverykey/WordEncoder.java

@@ -2,6 +2,7 @@ package org.cryptomator.ui.recoverykey;
 
 import com.google.common.base.Preconditions;
 import com.google.common.base.Splitter;
+import com.google.common.base.Strings;
 
 import javax.inject.Inject;
 import javax.inject.Singleton;
@@ -11,6 +12,7 @@ import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.Reader;
 import java.nio.charset.StandardCharsets;
+import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
@@ -31,6 +33,10 @@ class WordEncoder {
 		this(DEFAULT_WORD_FILE);
 	}
 	
+	public List<String> getWords() {
+		return words;
+	}
+	
 	public WordEncoder(String wordFile) {
 		try (InputStream in = getClass().getResourceAsStream(wordFile); //
 			 Reader reader = new InputStreamReader(in, StandardCharsets.US_ASCII.newDecoder()); //
@@ -78,7 +84,7 @@ class WordEncoder {
 	 * @throws IllegalArgumentException If the encoded string doesn't consist of a multiple of two words or one of the words is unknown to this encoder.
 	 */
 	public byte[] decode(String encoded) {
-		List<String> splitted = Splitter.on(DELIMITER).omitEmptyStrings().splitToList(encoded);
+		List<String> splitted = Splitter.on(DELIMITER).omitEmptyStrings().splitToList(Strings.nullToEmpty(encoded));
 		Preconditions.checkArgument(splitted.size() % 2 == 0, "%s needs to be a multiple of two words", encoded);
 		byte[] result = new byte[splitted.size() / 2 * 3];
 		for (int i = 0; i < splitted.size(); i+=2) {

main/ui/src/main/java/org/cryptomator/ui/removevault/RemoveVaultModule.java

@@ -21,8 +21,8 @@ import org.cryptomator.ui.mainwindow.MainWindow;
 
 import javax.inject.Named;
 import javax.inject.Provider;
+import java.util.List;
 import java.util.Map;
-import java.util.Optional;
 import java.util.ResourceBundle;
 
 @Module
@@ -38,13 +38,13 @@ abstract class RemoveVaultModule {
 	@Provides
 	@RemoveVaultWindow
 	@RemoveVaultScoped
-	static Stage provideStage(@MainWindow Stage owner,  ResourceBundle resourceBundle, @Named("windowIcon") Optional<Image> windowIcon) {
+	static Stage provideStage(@MainWindow Stage owner,  ResourceBundle resourceBundle, @Named("windowIcons") List<Image> windowIcons) {
 		Stage stage = new Stage();
 		stage.setTitle(resourceBundle.getString("removeVault.title"));
 		stage.setResizable(false);
 		stage.initModality(Modality.WINDOW_MODAL);
 		stage.initOwner(owner);
-		windowIcon.ifPresent(stage.getIcons()::add);
+		stage.getIcons().addAll(windowIcons);
 		return stage;
 	}
 

main/ui/src/main/java/org/cryptomator/ui/traymenu/TrayMenuController.java

@@ -3,54 +3,37 @@ package org.cryptomator.ui.traymenu;
 import javafx.application.Platform;
 import javafx.beans.Observable;
 import javafx.collections.ObservableList;
-import org.cryptomator.common.settings.Settings;
 import org.cryptomator.common.vaults.Vault;
-import org.cryptomator.common.vaults.VaultState;
+import org.cryptomator.ui.launcher.AppLifecycleListener;
-import org.cryptomator.ui.fxapp.FxApplication;
 import org.cryptomator.ui.launcher.FxApplicationStarter;
-import org.slf4j.Logger;
+import org.cryptomator.ui.preferences.SelectedPreferencesTab;
-import org.slf4j.LoggerFactory;
 
 import javax.inject.Inject;
-import javax.inject.Named;
-import java.awt.Desktop;
 import java.awt.Menu;
 import java.awt.MenuItem;
 import java.awt.PopupMenu;
-import java.awt.desktop.QuitResponse;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
-import java.util.EnumSet;
 import java.util.EventObject;
 import java.util.ResourceBundle;
-import java.util.Set;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Consumer;
 
 @TrayMenuScoped
 class TrayMenuController {
 
-	private static final Logger LOG = LoggerFactory.getLogger(TrayMenuController.class);
-	public static final Set<VaultState> STATES_ALLOWING_TERMINATION = EnumSet.of(VaultState.LOCKED, VaultState.NEEDS_MIGRATION, VaultState.MISSING, VaultState.ERROR);
-
 	private final ResourceBundle resourceBundle;
+	private final AppLifecycleListener appLifecycle;
 	private final FxApplicationStarter fxApplicationStarter;
-	private final CountDownLatch shutdownLatch;
-	private final Settings settings;
 	private final ObservableList<Vault> vaults;
 	private final PopupMenu menu;
-	private final AtomicBoolean allowSuddenTermination;
 
 	@Inject
-	TrayMenuController(ResourceBundle resourceBundle, FxApplicationStarter fxApplicationStarter, @Named("shutdownLatch") CountDownLatch shutdownLatch, Settings settings, ObservableList<Vault> vaults) {
+	TrayMenuController(ResourceBundle resourceBundle, AppLifecycleListener appLifecycle, FxApplicationStarter fxApplicationStarter, ObservableList<Vault> vaults) {
 		this.resourceBundle = resourceBundle;
+		this.appLifecycle = appLifecycle;
 		this.fxApplicationStarter = fxApplicationStarter;
-		this.shutdownLatch = shutdownLatch;
-		this.settings = settings;
 		this.vaults = vaults;
 		this.menu = new PopupMenu();
-		this.allowSuddenTermination = new AtomicBoolean(true);
 	}
 
 	public PopupMenu getMenu() {
@@ -59,39 +42,12 @@ class TrayMenuController {
 
 	public void initTrayMenu() {
 		vaults.addListener(this::vaultListChanged);
-
 		rebuildMenu();
-
-		// register preferences shortcut
-		if (Desktop.getDesktop().isSupported(Desktop.Action.APP_PREFERENCES)) {
-			Desktop.getDesktop().setPreferencesHandler(this::showPreferencesWindow);
-		}
-
-		// register quit handler
-		if (Desktop.getDesktop().isSupported(Desktop.Action.APP_QUIT_HANDLER)) {
-			Desktop.getDesktop().setQuitHandler(this::handleQuitRequest);
-		}
-
-		// allow sudden termination
-		if (Desktop.getDesktop().isSupported(Desktop.Action.APP_SUDDEN_TERMINATION)) {
-			Desktop.getDesktop().enableSuddenTermination();
-		}
 	}
 
 	private void vaultListChanged(@SuppressWarnings("unused") Observable observable) {
 		assert Platform.isFxApplicationThread();
 		rebuildMenu();
-		boolean allVaultsAllowTermination = vaults.stream().map(Vault::getState).allMatch(STATES_ALLOWING_TERMINATION::contains);
-		boolean suddenTerminationChanged = allowSuddenTermination.compareAndSet(!allVaultsAllowTermination, allVaultsAllowTermination);
-		if (suddenTerminationChanged && Desktop.getDesktop().isSupported(Desktop.Action.APP_SUDDEN_TERMINATION)) {
-			if (allVaultsAllowTermination) {
-				Desktop.getDesktop().enableSuddenTermination();
-				LOG.debug("sudden termination enabled");
-			} else {
-				Desktop.getDesktop().disableSuddenTermination();
-				LOG.debug("sudden termination disabled");
-			}
-		}
 	}
 
 	private void rebuildMenu() {
@@ -112,6 +68,11 @@ class TrayMenuController {
 		}
 		menu.addSeparator();
 
+		MenuItem lockAllItem = new MenuItem(resourceBundle.getString("traymenu.lockAllVaults"));
+		lockAllItem.addActionListener(this::lockAllVaults);
+		lockAllItem.setEnabled(!vaults.filtered(Vault::isUnlocked).isEmpty());
+		menu.add(lockAllItem);
+
 		MenuItem quitApplicationItem = new MenuItem(resourceBundle.getString("traymenu.quitApplication"));
 		quitApplicationItem.addActionListener(this::quitApplication);
 		menu.add(quitApplicationItem);
@@ -126,11 +87,11 @@ class TrayMenuController {
 			submenu.add(unlockItem);
 		} else if (vault.isUnlocked()) {
 			MenuItem lockItem = new MenuItem(resourceBundle.getString("traymenu.vault.lock"));
-			lockItem.setEnabled(false); // TODO add action listener
+			lockItem.addActionListener(createActionListenerForVault(vault, this::lockVault));
 			submenu.add(lockItem);
 
 			MenuItem revealItem = new MenuItem(resourceBundle.getString("traymenu.vault.reveal"));
-			revealItem.setEnabled(false); // TODO add action listener
+			revealItem.addActionListener(createActionListenerForVault(vault, this::revealVault));
 			submenu.add(revealItem);
 		}
 
@@ -145,33 +106,28 @@ class TrayMenuController {
 		fxApplicationStarter.get(true).thenAccept(app -> app.showUnlockWindow(vault));
 	}
 
+	private void lockVault(Vault vault) {
+		fxApplicationStarter.get(true).thenAccept(app -> app.getVaultService().lock(vault, false));
+	}
+
+	private void lockAllVaults(ActionEvent actionEvent) {
+		fxApplicationStarter.get(true).thenAccept(app -> app.getVaultService().lockAll(vaults.filtered(Vault::isUnlocked), false));
+	}
+
+	private void revealVault(Vault vault) {
+		fxApplicationStarter.get(true).thenAccept(app -> app.getVaultService().reveal(vault));
+	}
+
 	void showMainWindow(@SuppressWarnings("unused") ActionEvent actionEvent) {
 		fxApplicationStarter.get(true).thenAccept(app -> app.showMainWindow());
 	}
 
 	private void showPreferencesWindow(@SuppressWarnings("unused") EventObject actionEvent) {
-		fxApplicationStarter.get(true).thenAccept(FxApplication::showPreferencesWindow);
+		fxApplicationStarter.get(true).thenAccept(app -> app.showPreferencesWindow(SelectedPreferencesTab.ANY));
-	}
-
-	private void handleQuitRequest(EventObject e, QuitResponse response) {
-		if (allowSuddenTermination.get()) {
-			response.performQuit(); // really?
-		} else {
-			fxApplicationStarter.get(true).thenAccept(app -> app.showQuitWindow(response));
-		}
 	}
 
 	private void quitApplication(EventObject actionEvent) {
-		handleQuitRequest(actionEvent, new QuitResponse() {
+		appLifecycle.quit();
-			@Override
-			public void performQuit() {
-				shutdownLatch.countDown();
-			}
-
-			@Override
-			public void cancelQuit() {
-				// no-op
-			}
-		});
 	}
+
 }

main/ui/src/main/java/org/cryptomator/ui/unlock/UnlockController.java

@@ -1,37 +1,35 @@
 package org.cryptomator.ui.unlock;
 
 import dagger.Lazy;
-import javafx.animation.KeyFrame;
-import javafx.animation.KeyValue;
-import javafx.animation.Timeline;
 import javafx.beans.binding.Bindings;
 import javafx.beans.binding.ObjectBinding;
 import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.ObjectProperty;
 import javafx.beans.property.ReadOnlyBooleanProperty;
 import javafx.beans.property.SimpleBooleanProperty;
-import javafx.beans.value.WritableValue;
+import javafx.concurrent.Task;
 import javafx.fxml.FXML;
 import javafx.scene.Scene;
 import javafx.scene.control.CheckBox;
 import javafx.scene.control.ContentDisplay;
 import javafx.stage.Stage;
-import javafx.util.Duration;
 import org.cryptomator.common.vaults.Vault;
 import org.cryptomator.common.vaults.VaultState;
 import org.cryptomator.cryptolib.api.InvalidPassphraseException;
-import org.cryptomator.cryptolib.api.UnsupportedVaultFormatException;
 import org.cryptomator.keychain.KeychainAccess;
 import org.cryptomator.keychain.KeychainAccessException;
+import org.cryptomator.ui.common.Animations;
 import org.cryptomator.ui.common.FxController;
 import org.cryptomator.ui.common.FxmlFile;
 import org.cryptomator.ui.common.FxmlScene;
-import org.cryptomator.ui.common.Tasks;
+import org.cryptomator.ui.common.VaultService;
 import org.cryptomator.ui.controls.NiceSecurePasswordField;
 import org.cryptomator.ui.forgetPassword.ForgetPasswordComponent;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import javax.inject.Inject;
+import javax.inject.Named;
 import java.nio.file.DirectoryNotEmptyException;
 import java.nio.file.NotDirectoryException;
 import java.util.Arrays;
@@ -48,20 +46,28 @@ public class UnlockController implements FxController {
 	private final ExecutorService executor;
 	private final ObjectBinding<ContentDisplay> unlockButtonState;
 	private final Optional<KeychainAccess> keychainAccess;
+	private final VaultService vaultService;
 	private final Lazy<Scene> successScene;
+	private final Lazy<Scene> invalidMountPointScene;
+	private final Lazy<Scene> genericErrorScene;
+	private final ObjectProperty<Throwable> genericErrorCause;
 	private final ForgetPasswordComponent.Builder forgetPassword;
 	private final BooleanProperty unlockButtonDisabled;
 	public NiceSecurePasswordField passwordField;
 	public CheckBox savePassword;
 
 	@Inject
-	public UnlockController(@UnlockWindow Stage window, @UnlockWindow Vault vault, ExecutorService executor, Optional<KeychainAccess> keychainAccess, @FxmlScene(FxmlFile.UNLOCK_SUCCESS) Lazy<Scene> successScene, ForgetPasswordComponent.Builder forgetPassword) {
+	public UnlockController(@UnlockWindow Stage window, @UnlockWindow Vault vault, ExecutorService executor, Optional<KeychainAccess> keychainAccess, VaultService vaultService, @FxmlScene(FxmlFile.UNLOCK_SUCCESS) Lazy<Scene> successScene, @FxmlScene(FxmlFile.UNLOCK_INVALID_MOUNT_POINT) Lazy<Scene> invalidMountPointScene, @FxmlScene(FxmlFile.UNLOCK_GENERIC_ERROR) Lazy<Scene> genericErrorScene, @Named("genericErrorCause") ObjectProperty<Throwable> genericErrorCause, ForgetPasswordComponent.Builder forgetPassword) {
 		this.window = window;
 		this.vault = vault;
 		this.executor = executor;
 		this.unlockButtonState = Bindings.createObjectBinding(this::getUnlockButtonState, vault.stateProperty());
 		this.keychainAccess = keychainAccess;
+		this.vaultService = vaultService;
 		this.successScene = successScene;
+		this.invalidMountPointScene = invalidMountPointScene;
+		this.genericErrorScene = genericErrorScene;
+		this.genericErrorCause = genericErrorCause;
 		this.forgetPassword = forgetPassword;
 		this.unlockButtonDisabled = new SimpleBooleanProperty();
 	}
@@ -85,37 +91,36 @@ public class UnlockController implements FxController {
 	public void unlock() {
 		LOG.trace("UnlockController.unlock()");
 		CharSequence password = passwordField.getCharacters();
-		vault.setState(VaultState.PROCESSING);
+		
-		Tasks.create(() -> {
+		Task<Vault> task = vaultService.createUnlockTask(vault, password);
-			vault.unlock(password);
+		task.setOnSucceeded(event -> {
 			if (keychainAccess.isPresent() && savePassword.isSelected()) {
-				keychainAccess.get().storePassphrase(vault.getId(), password);
+				try {
+					keychainAccess.get().storePassphrase(vault.getId(), password);
+				} catch (KeychainAccessException e) {
+					LOG.error("Failed to store passphrase in system keychain.", e);
+				}
 			}
-		}).onSuccess(() -> {
-			vault.setState(VaultState.UNLOCKED);
 			passwordField.swipe();
 			LOG.info("Unlock of '{}' succeeded.", vault.getDisplayableName());
 			window.setScene(successScene.get());
-		}).onError(InvalidPassphraseException.class, e -> {
+		});
-			shakeWindow();
+		task.setOnFailed(event -> {
-			passwordField.selectAll();
+			if (task.getException() instanceof InvalidPassphraseException) {
-			passwordField.requestFocus();
+				Animations.createShakeWindowAnimation(window).play();
-		}).onError(UnsupportedVaultFormatException.class, e -> {
+				passwordField.selectAll();
-			// TODO
+				passwordField.requestFocus();
-		}).onError(NotDirectoryException.class, e -> {
+			} else if (task.getException() instanceof NotDirectoryException
-			LOG.error("Unlock failed. Mount point not a directory: {}", e.getMessage());
+				|| task.getException() instanceof DirectoryNotEmptyException) {
-			// TODO
+				LOG.error("Unlock failed. Mount point not an empty directory: {}", task.getException().getMessage());
-		}).onError(DirectoryNotEmptyException.class, e -> {
+				window.setScene(invalidMountPointScene.get());
-			LOG.error("Unlock failed. Mount point not empty: {}", e.getMessage());
+			} else {
-			// TODO
+				LOG.error("Unlock failed for technical reasons.", task.getException());
-		}).onError(Exception.class, e -> { // including RuntimeExceptions
+				genericErrorCause.set(task.getException());
-			LOG.error("Unlock failed for technical reasons.", e);
+				window.setScene(genericErrorScene.get());
-			// TODO
-		}).andFinally(() -> {
-			if (!vault.isUnlocked()) {
-				vault.setState(VaultState.LOCKED);
 			}
-		}).runOnce(executor);
+		});
+		executor.execute(task);
 	}
 
 	/* Save Password */
@@ -160,33 +165,6 @@ public class UnlockController implements FxController {
 		}
 	}
 
-	/* Animations */
-
-	private void shakeWindow() {
-		WritableValue<Double> writableWindowX = new WritableValue<>() {
-			@Override
-			public Double getValue() {
-				return window.getX();
-			}
-
-			@Override
-			public void setValue(Double value) {
-				window.setX(value);
-			}
-		};
-		Timeline timeline = new Timeline( //
-				new KeyFrame(Duration.ZERO, new KeyValue(writableWindowX, window.getX())), //
-				new KeyFrame(new Duration(100), new KeyValue(writableWindowX, window.getX() - 22.0)), //
-				new KeyFrame(new Duration(200), new KeyValue(writableWindowX, window.getX() + 18.0)), //
-				new KeyFrame(new Duration(300), new KeyValue(writableWindowX, window.getX() - 14.0)), //
-				new KeyFrame(new Duration(400), new KeyValue(writableWindowX, window.getX() + 10.0)), //
-				new KeyFrame(new Duration(500), new KeyValue(writableWindowX, window.getX() - 6.0)), //
-				new KeyFrame(new Duration(600), new KeyValue(writableWindowX, window.getX() + 2.0)), //
-				new KeyFrame(new Duration(700), new KeyValue(writableWindowX, window.getX())) //
-		);
-		timeline.play();
-	}
-
 	/* Getter/Setter */
 
 	public Vault getVault() {

main/ui/src/main/java/org/cryptomator/ui/unlock/UnlockGenericErrorController.java

@@ -0,0 +1,29 @@
+package org.cryptomator.ui.unlock;
+
+import dagger.Lazy;
+import javafx.fxml.FXML;
+import javafx.scene.Scene;
+import javafx.stage.Stage;
+import org.cryptomator.ui.common.FxController;
+import org.cryptomator.ui.common.FxmlFile;
+import org.cryptomator.ui.common.FxmlScene;
+
+import javax.inject.Inject;
+
+@UnlockScoped
+public class UnlockGenericErrorController implements FxController {
+
+	private final Stage window;
+	private final Lazy<Scene> unlockScene;
+
+	@Inject
+	UnlockGenericErrorController(@UnlockWindow Stage window, @FxmlScene(FxmlFile.UNLOCK) Lazy<Scene> unlockScene) {
+		this.window = window;
+		this.unlockScene = unlockScene;
+	}
+
+	@FXML
+	public void back() {
+		window.setScene(unlockScene.get());
+	}
+}

main/ui/src/main/java/org/cryptomator/ui/unlock/UnlockInvalidMountPointController.java

@@ -0,0 +1,39 @@
+package org.cryptomator.ui.unlock;
+
+import dagger.Lazy;
+import javafx.fxml.FXML;
+import javafx.scene.Scene;
+import javafx.stage.Stage;
+import org.cryptomator.common.vaults.Vault;
+import org.cryptomator.ui.common.FxController;
+import org.cryptomator.ui.common.FxmlFile;
+import org.cryptomator.ui.common.FxmlScene;
+
+import javax.inject.Inject;
+
+@UnlockScoped
+public class UnlockInvalidMountPointController implements FxController {
+
+	private final Stage window;
+	private final Lazy<Scene> unlockScene;
+	private final Vault vault;
+
+	@Inject
+	UnlockInvalidMountPointController(@UnlockWindow Stage window, @FxmlScene(FxmlFile.UNLOCK) Lazy<Scene> unlockScene, @UnlockWindow Vault vault) {
+		this.window = window;
+		this.unlockScene = unlockScene;
+		this.vault = vault;
+	}
+
+	@FXML
+	public void back() {
+		window.setScene(unlockScene.get());
+	}
+
+	/* Getter/Setter */
+
+	public String getMountPoint() {
+		return vault.getVaultSettings().getIndividualMountPath().orElse("AUTO");
+	}
+
+}

main/ui/src/main/java/org/cryptomator/ui/unlock/UnlockModule.java

@@ -4,6 +4,8 @@ import dagger.Binds;
 import dagger.Module;
 import dagger.Provides;
 import dagger.multibindings.IntoMap;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleObjectProperty;
 import javafx.scene.Scene;
 import javafx.scene.image.Image;
 import javafx.stage.Modality;
@@ -14,12 +16,13 @@ import org.cryptomator.ui.common.FxController;
 import org.cryptomator.ui.common.FxControllerKey;
 import org.cryptomator.ui.common.FxmlFile;
 import org.cryptomator.ui.common.FxmlScene;
+import org.cryptomator.ui.common.StackTraceController;
 import org.cryptomator.ui.forgetPassword.ForgetPasswordComponent;
 
 import javax.inject.Named;
 import javax.inject.Provider;
+import java.util.List;
 import java.util.Map;
-import java.util.Optional;
 import java.util.ResourceBundle;
 
 @Module(subcomponents = {ForgetPasswordComponent.class})
@@ -35,15 +38,22 @@ abstract class UnlockModule {
 	@Provides
 	@UnlockWindow
 	@UnlockScoped
-	static Stage provideStage(ResourceBundle resourceBundle, @Named("windowIcon") Optional<Image> windowIcon) {
+	static Stage provideStage(ResourceBundle resourceBundle, @Named("windowIcons") List<Image> windowIcons) {
 		Stage stage = new Stage();
 		stage.setTitle(resourceBundle.getString("unlock.title"));
 		stage.setResizable(false);
 		stage.initModality(Modality.APPLICATION_MODAL);
-		windowIcon.ifPresent(stage.getIcons()::add);
+		stage.getIcons().addAll(windowIcons);
 		return stage;
 	}
 
+	@Provides
+	@Named("genericErrorCause")
+	@UnlockScoped
+	static ObjectProperty<Throwable> provideGenericErrorCause() {
+		return new SimpleObjectProperty<>();
+	}
+
 	@Provides
 	@FxmlScene(FxmlFile.UNLOCK)
 	@UnlockScoped
@@ -58,6 +68,21 @@ abstract class UnlockModule {
 		return fxmlLoaders.createScene("/fxml/unlock_success.fxml");
 	}
 
+	@Provides
+	@FxmlScene(FxmlFile.UNLOCK_INVALID_MOUNT_POINT)
+	@UnlockScoped
+	static Scene provideInvalidMountPointScene(@UnlockWindow FXMLLoaderFactory fxmlLoaders) {
+		return fxmlLoaders.createScene("/fxml/unlock_invalid_mount_point.fxml");
+	}
+
+
+	@Provides
+	@FxmlScene(FxmlFile.UNLOCK_GENERIC_ERROR)
+	@UnlockScoped
+	static Scene provideGenericErrorScene(@UnlockWindow FXMLLoaderFactory fxmlLoaders) {
+		return fxmlLoaders.createScene("/fxml/unlock_generic_error.fxml");
+	}
+
 
 	// ------------------
 
@@ -71,5 +96,22 @@ abstract class UnlockModule {
 	@FxControllerKey(UnlockSuccessController.class)
 	abstract FxController bindUnlockSuccessController(UnlockSuccessController controller);
 
+	@Binds
+	@IntoMap
+	@FxControllerKey(UnlockInvalidMountPointController.class)
+	abstract FxController bindUnlockInvalidMountPointController(UnlockInvalidMountPointController controller);
+
+	@Binds
+	@IntoMap
+	@FxControllerKey(UnlockGenericErrorController.class)
+	abstract FxController bindUnlockGenericErrorController(UnlockGenericErrorController controller);
+
+	@Provides
+	@IntoMap
+	@FxControllerKey(StackTraceController.class)
+	static FxController provideStackTraceController(@Named("genericErrorCause") ObjectProperty<Throwable> errorCause) {
+		return new StackTraceController(errorCause.get());
+	}
+
 
 }

main/ui/src/main/java/org/cryptomator/ui/unlock/UnlockSuccessController.java

@@ -5,13 +5,13 @@ import javafx.beans.property.ObjectProperty;
 import javafx.beans.property.ReadOnlyObjectProperty;
 import javafx.beans.property.SimpleBooleanProperty;
 import javafx.beans.property.SimpleObjectProperty;
+import javafx.concurrent.Task;
 import javafx.fxml.FXML;
 import javafx.scene.control.ContentDisplay;
 import javafx.stage.Stage;
 import org.cryptomator.common.vaults.Vault;
-import org.cryptomator.cryptolib.api.InvalidPassphraseException;
 import org.cryptomator.ui.common.FxController;
-import org.cryptomator.ui.common.Tasks;
+import org.cryptomator.ui.common.VaultService;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -26,14 +26,16 @@ public class UnlockSuccessController implements FxController {
 	private final Stage window;
 	private final Vault vault;
 	private final ExecutorService executor;
+	private final VaultService vaultService;
 	private final ObjectProperty<ContentDisplay> revealButtonState;
 	private final BooleanProperty revealButtonDisabled;
 
 	@Inject
-	public UnlockSuccessController(@UnlockWindow Stage window, @UnlockWindow Vault vault, ExecutorService executor) {
+	public UnlockSuccessController(@UnlockWindow Stage window, @UnlockWindow Vault vault, ExecutorService executor, VaultService vaultService) {
 		this.window = window;
 		this.vault = vault;
 		this.executor = executor;
+		this.vaultService = vaultService;
 		this.revealButtonState = new SimpleObjectProperty<>(ContentDisplay.TEXT_ONLY);
 		this.revealButtonDisabled = new SimpleBooleanProperty();
 	}
@@ -49,17 +51,19 @@ public class UnlockSuccessController implements FxController {
 		LOG.trace("UnlockSuccessController.revealAndClose()");
 		revealButtonState.set(ContentDisplay.LEFT);
 		revealButtonDisabled.set(true);
-		Tasks.create(() -> {
+
-			vault.reveal();
+		Task<Vault> revealTask = vaultService.createRevealTask(vault);
-		}).onSuccess(() -> {
+		revealTask.setOnSucceeded(evt -> {
-			window.close();
-		}).onError(InvalidPassphraseException.class, e -> {
-			// TODO
-			LOG.warn("Reveal failed.", e);
-		}).andFinally(() -> {
 			revealButtonState.set(ContentDisplay.TEXT_ONLY);
 			revealButtonDisabled.set(false);
-		}).runOnce(executor);
+			window.close();
+		});
+		revealTask.setOnFailed(evt -> {
+			LOG.warn("Reveal failed.", revealTask.getException());
+			revealButtonState.set(ContentDisplay.TEXT_ONLY);
+			revealButtonDisabled.set(false);
+		});
+		executor.execute(revealTask);
 	}
 
 	/* Getter/Setter */

main/ui/src/main/java/org/cryptomator/ui/vaultoptions/GeneralVaultOptionsController.java

@@ -1,11 +1,9 @@
 package org.cryptomator.ui.vaultoptions;
 
 import javafx.fxml.FXML;
-import javafx.stage.Stage;
+import javafx.scene.control.CheckBox;
 import org.cryptomator.common.vaults.Vault;
-import org.cryptomator.ui.changepassword.ChangePasswordComponent;
 import org.cryptomator.ui.common.FxController;
-import org.cryptomator.ui.recoverykey.RecoveryKeyComponent;
 
 import javax.inject.Inject;
 
@@ -13,26 +11,15 @@ import javax.inject.Inject;
 public class GeneralVaultOptionsController implements FxController {
 
 	private final Vault vault;
-	private final Stage window;
+	public CheckBox unlockOnStartupCheckbox;
-	private final ChangePasswordComponent.Builder changePasswordWindow;
-	private final RecoveryKeyComponent.Builder recoveryKeyWindow;
 
 	@Inject
-	GeneralVaultOptionsController(@VaultOptionsWindow Vault vault, @VaultOptionsWindow Stage window, ChangePasswordComponent.Builder changePasswordWindow, RecoveryKeyComponent.Builder recoveryKeyWindow) {
+	GeneralVaultOptionsController(@VaultOptionsWindow Vault vault) {
 		this.vault = vault;
-		this.window = window;
-		this.changePasswordWindow = changePasswordWindow;
-		this.recoveryKeyWindow = recoveryKeyWindow;
 	}
 
 	@FXML
-	public void changePassword() {
+	public void initialize() {
-		changePasswordWindow.vault(vault).owner(window).build().showChangePasswordWindow();
+		unlockOnStartupCheckbox.selectedProperty().bindBidirectional(vault.getVaultSettings().unlockAfterStartup());
 	}
-
-	@FXML
-	public void showRecoveryKey() {
-		recoveryKeyWindow.vault(vault).owner(window).build().showRecoveryKeyCreationWindow();
-	}
-
 }

main/ui/src/main/java/org/cryptomator/ui/vaultoptions/MasterkeyOptionsController.java

@@ -0,0 +1,42 @@
+package org.cryptomator.ui.vaultoptions;
+
+import javafx.fxml.FXML;
+import javafx.stage.Stage;
+import org.cryptomator.common.vaults.Vault;
+import org.cryptomator.ui.changepassword.ChangePasswordComponent;
+import org.cryptomator.ui.common.FxController;
+import org.cryptomator.ui.recoverykey.RecoveryKeyComponent;
+
+import javax.inject.Inject;
+
+@VaultOptionsScoped
+public class MasterkeyOptionsController implements FxController {
+
+	private final Vault vault;
+	private final Stage window;
+	private final ChangePasswordComponent.Builder changePasswordWindow;
+	private final RecoveryKeyComponent.Builder recoveryKeyWindow;
+
+	@Inject
+	MasterkeyOptionsController(@VaultOptionsWindow Vault vault, @VaultOptionsWindow Stage window, ChangePasswordComponent.Builder changePasswordWindow, RecoveryKeyComponent.Builder recoveryKeyWindow) {
+		this.vault = vault;
+		this.window = window;
+		this.changePasswordWindow = changePasswordWindow;
+		this.recoveryKeyWindow = recoveryKeyWindow;
+	}
+
+	@FXML
+	public void changePassword() {
+		changePasswordWindow.vault(vault).owner(window).build().showChangePasswordWindow();
+	}
+
+	@FXML
+	public void showRecoveryKey() {
+		recoveryKeyWindow.vault(vault).owner(window).build().showRecoveryKeyCreationWindow();
+	}
+
+	@FXML
+	public void showRecoverVaultDialogue() {
+		recoveryKeyWindow.vault(vault).owner(window).build().showRecoveryKeyRecoverWindow();
+	}
+}

main/ui/src/main/java/org/cryptomator/ui/vaultoptions/MountOptionsController.java

@@ -84,12 +84,7 @@ public class MountOptionsController implements FxController {
 		driveLetterSelection.getItems().addAll(windowsDriveLetters.getAllDriveLetters());
 		driveLetterSelection.setConverter(new WinDriveLetterLabelConverter(windowsDriveLetters));
 		driveLetterSelection.setValue(vault.getVaultSettings().winDriveLetter().get());
-		vault.getVaultSettings().usesIndividualMountPath().bind(mountPoint.selectedToggleProperty().isEqualTo(mountPointCustomDir));
+
-		vault.getVaultSettings().winDriveLetter().bind( //
-				Bindings.when(mountPoint.selectedToggleProperty().isEqualTo(mountPointWinDriveLetter)) //
-						.then(driveLetterSelection.getSelectionModel().selectedItemProperty()) //
-						.otherwise((String) null) //
-		);
 		if (vault.getVaultSettings().usesIndividualMountPath().get()) {
 			mountPoint.selectToggle(mountPointCustomDir);
 		} else if (!Strings.isNullOrEmpty(vault.getVaultSettings().winDriveLetter().get())) {
@@ -97,6 +92,13 @@ public class MountOptionsController implements FxController {
 		} else {
 			mountPoint.selectToggle(mountPointAuto);
 		}
+
+		vault.getVaultSettings().usesIndividualMountPath().bind(mountPoint.selectedToggleProperty().isEqualTo(mountPointCustomDir));
+		vault.getVaultSettings().winDriveLetter().bind( //
+				Bindings.when(mountPoint.selectedToggleProperty().isEqualTo(mountPointWinDriveLetter)) //
+						.then(driveLetterSelection.getSelectionModel().selectedItemProperty()) //
+						.otherwise((String) null) //
+		);
 	}
 
 	@FXML
@@ -116,7 +118,7 @@ public class MountOptionsController implements FxController {
 	@FXML
 	private void chooseCustomMountPoint() {
 		DirectoryChooser directoryChooser = new DirectoryChooser();
-		directoryChooser.setTitle(resourceBundle.getString("vaultOptions.mount.winDirChooser"));
+		directoryChooser.setTitle(resourceBundle.getString("vaultOptions.mount.mountPoint.directoryPickerTitle"));
 		try {
 			directoryChooser.setInitialDirectory(Path.of(System.getProperty("user.home")).toFile());
 		} catch (Exception e) {