How to use ch.cyberduck.core.vault

/**
 * Wrap proxy with cryptographic feature
 *
 * @param type    Feature type
 * @param feature Proxy implementation to wrap with vault features
 * @return Feature implementation or null when not supported
 */
@SuppressWarnings("unchecked")
public <T> T getFeature(final Class<T> type, final T feature) {
  return registry.getFeature(this, type, feature);
}

@Override
public Vault find(final Session session, final Path file) throws VaultUnlockCancelException {
  return this.find(session, file, true);
}

public static Vault get(final Path directory, final String masterkey, final byte[] pepper) {
  return new VaultFactory().create(directory, masterkey, pepper);
}

@Override
public AttributedList<Path> list(final Path directory, final ListProgressListener listener) throws BackgroundException {
  try {
    final Vault vault = registry.find(session, directory);
    if(vault.contains(directory)) {
      return vault.getFeature(session, ListService.class, proxy).list(directory, listener);
    }
    if(autodetect) {
      return new VaultFinderListService(session, proxy, new VaultFinderListProgressListener(lookup)).list(directory, listener);
    }
    return proxy.list(directory, listener);
  }
  catch(VaultUnlockCancelException e) {
    log.warn(String.format("Canceled loading vault %s. %s", e.getVault(), e.getDetail()));
    throw e;
  }
}

@Override
@SuppressWarnings("unchecked")
public T lock(final Path file) throws BackgroundException {
  return (T) registry.find(session, file).getFeature(session, Lock.class, proxy).lock(file);
}

public static VaultRegistry create(final PasswordCallback callback) {
  return create(PasswordStoreFactory.get(), callback);
}

@Override
public AttributedList<Path> list(final Path directory, final ListProgressListener listener) throws BackgroundException {
  return delegate.list(vault.encrypt(session, directory),
      new DecryptingListProgressListener(session, vault, listener));
}

  public static VaultRegistry create(final HostPasswordStore keychain, final PasswordCallback callback) {
    return PreferencesFactory.get().getBoolean("cryptomator.enable") ?
        new DefaultVaultRegistry(keychain, callback) : VaultRegistry.DISABLED;
  }
}

@Override
@SuppressWarnings("unchecked")
public Output upload(final Path file, final Local local, final BandwidthThrottle throttle, final StreamListener listener, final TransferStatus status, final ConnectionCallback callback) throws BackgroundException {
  return (Output) registry.find(session, file).getFeature(session, Upload.class, proxy).upload(file, local, throttle, listener, status, callback);
}

@Override
public boolean isSupported(final Path workdir) {
  // Run through registry without looking for vaults to circumvent deadlock due to synchronized load of vault
  try {
    return registry.find(session, workdir, false).getFeature(session, Touch.class, proxy).isSupported(workdir);
  }
  catch(VaultUnlockCancelException e) {
    return proxy.isSupported(workdir);
  }
}

@Override
public boolean isRevertable(final Path file) {
  try {
    return registry.find(session, file).getFeature(session, Versioning.class, proxy).isRevertable(file);
  }
  catch(VaultUnlockCancelException e) {
    return false;
  }
}

@Override
public LifecycleConfiguration getConfiguration(final Path container) throws BackgroundException {
  return registry.find(session, container).getFeature(session, Lifecycle.class, proxy).getConfiguration(container);
}

@Override
public void setEncryption(final Path file, final Algorithm algorithm) throws BackgroundException {
  registry.find(session, file).getFeature(session, Encryption.class, proxy).setEncryption(file, algorithm);
}

@Override
public Algorithm getDefault(final Path file) throws BackgroundException {
  return registry.find(session, file).getFeature(session, Encryption.class, proxy).getDefault(file);
}

@Override
public void setPermission(final Path file, final Acl acl) throws BackgroundException {
  registry.find(session, file).getFeature(session, AclPermission.class, proxy).setPermission(file, acl);
}

@Override
public LoggingConfiguration getConfiguration(final Path container) throws BackgroundException {
  return registry.find(session, container).getFeature(session, Logging.class, proxy).getConfiguration(container);
}

@Override
public void setUnixOwner(final Path file, final String owner) throws BackgroundException {
  registry.find(session, file).getFeature(session, UnixPermission.class, proxy).setUnixOwner(file, owner);
}

@Override
public void setUnixPermission(final Path file, final Permission permission) throws BackgroundException {
  registry.find(session, file).getFeature(session, UnixPermission.class, proxy).setUnixPermission(file, permission);
}

@Override
public PathAttributes find(final Path file) throws BackgroundException {
  return registry.find(session, file).getFeature(session, AttributesFinder.class, proxy)
      .withCache(cache)
    .find(file);
}

@Override
public ChecksumCompute checksum(final Path file) {
  try {
    return registry.find(session, file).getFeature(session, Write.class, proxy).checksum(file);
  }
  catch(VaultUnlockCancelException e) {
    return proxy.checksum(file);
  }
}