2016-10-08 18:27:31 +02:00
|
|
|
package main
|
|
|
|
|
|
|
|
import (
|
2019-12-28 20:44:12 +01:00
|
|
|
"bytes"
|
2016-10-08 18:27:31 +02:00
|
|
|
"encoding/json"
|
2017-10-21 18:06:55 +02:00
|
|
|
"fmt"
|
2018-02-17 16:26:35 +01:00
|
|
|
"log"
|
2016-10-08 18:27:31 +02:00
|
|
|
"log/syslog"
|
2018-10-06 21:49:33 +02:00
|
|
|
"math"
|
2016-12-10 14:54:06 +01:00
|
|
|
"net"
|
2016-10-08 18:27:31 +02:00
|
|
|
"os"
|
|
|
|
"os/exec"
|
|
|
|
"os/signal"
|
2017-03-26 21:09:54 +02:00
|
|
|
"path"
|
2016-10-08 18:27:31 +02:00
|
|
|
"path/filepath"
|
2017-02-15 23:20:41 +01:00
|
|
|
"runtime"
|
2017-07-29 17:12:32 +02:00
|
|
|
"runtime/debug"
|
2016-10-08 18:27:31 +02:00
|
|
|
"strings"
|
2018-10-06 21:49:33 +02:00
|
|
|
"sync/atomic"
|
2016-10-08 18:27:31 +02:00
|
|
|
"syscall"
|
|
|
|
"time"
|
|
|
|
|
2019-08-04 13:45:10 +02:00
|
|
|
"golang.org/x/sys/unix"
|
|
|
|
|
2020-06-11 22:20:15 +02:00
|
|
|
"github.com/hanwen/go-fuse/v2/fs"
|
2020-05-17 14:18:23 +02:00
|
|
|
"github.com/hanwen/go-fuse/v2/fuse"
|
2016-10-08 18:27:31 +02:00
|
|
|
|
|
|
|
"github.com/rfjakob/gocryptfs/internal/configfile"
|
2018-02-17 16:26:35 +01:00
|
|
|
"github.com/rfjakob/gocryptfs/internal/contentenc"
|
2016-10-08 18:27:31 +02:00
|
|
|
"github.com/rfjakob/gocryptfs/internal/cryptocore"
|
2020-05-09 17:36:41 +02:00
|
|
|
"github.com/rfjakob/gocryptfs/internal/ctlsocksrv"
|
2017-02-26 19:25:23 +01:00
|
|
|
"github.com/rfjakob/gocryptfs/internal/exitcodes"
|
2016-10-08 18:27:31 +02:00
|
|
|
"github.com/rfjakob/gocryptfs/internal/fusefrontend"
|
|
|
|
"github.com/rfjakob/gocryptfs/internal/fusefrontend_reverse"
|
2018-02-17 16:26:35 +01:00
|
|
|
"github.com/rfjakob/gocryptfs/internal/nametransform"
|
2018-10-06 21:49:33 +02:00
|
|
|
"github.com/rfjakob/gocryptfs/internal/openfiletable"
|
2016-10-08 18:27:31 +02:00
|
|
|
"github.com/rfjakob/gocryptfs/internal/tlog"
|
|
|
|
)
|
|
|
|
|
|
|
|
// doMount mounts an encrypted directory.
|
|
|
|
// Called from main.
|
2018-02-18 12:55:20 +01:00
|
|
|
func doMount(args *argContainer) {
|
2016-10-08 18:27:31 +02:00
|
|
|
// Check mountpoint
|
|
|
|
var err error
|
|
|
|
args.mountpoint, err = filepath.Abs(flagSet.Arg(1))
|
|
|
|
if err != nil {
|
|
|
|
tlog.Fatal.Printf("Invalid mountpoint: %v", err)
|
2017-05-07 22:15:01 +02:00
|
|
|
os.Exit(exitcodes.MountPoint)
|
2016-10-08 18:27:31 +02:00
|
|
|
}
|
2016-10-08 18:39:21 +02:00
|
|
|
// We cannot mount "/home/user/.cipher" at "/home/user" because the mount
|
|
|
|
// will hide ".cipher" also for us.
|
2016-10-08 23:50:19 +02:00
|
|
|
if args.cipherdir == args.mountpoint || strings.HasPrefix(args.cipherdir, args.mountpoint+"/") {
|
2016-10-08 18:39:21 +02:00
|
|
|
tlog.Fatal.Printf("Mountpoint %q would shadow cipherdir %q, this is not supported",
|
|
|
|
args.mountpoint, args.cipherdir)
|
2017-05-07 22:15:01 +02:00
|
|
|
os.Exit(exitcodes.MountPoint)
|
2016-10-08 18:39:21 +02:00
|
|
|
}
|
2017-10-31 19:44:54 +01:00
|
|
|
// Reverse-mounting "/foo" at "/foo/mnt" means we would be recursively
|
|
|
|
// encrypting ourselves.
|
|
|
|
if strings.HasPrefix(args.mountpoint, args.cipherdir+"/") {
|
|
|
|
tlog.Fatal.Printf("Mountpoint %q is contained in cipherdir %q, this is not supported",
|
|
|
|
args.mountpoint, args.cipherdir)
|
|
|
|
os.Exit(exitcodes.MountPoint)
|
|
|
|
}
|
2016-10-08 18:27:31 +02:00
|
|
|
if args.nonempty {
|
2018-04-01 12:31:44 +02:00
|
|
|
err = isDir(args.mountpoint)
|
2016-10-08 18:27:31 +02:00
|
|
|
} else {
|
2019-08-04 14:13:00 +02:00
|
|
|
err = isEmptyDir(args.mountpoint)
|
2018-01-20 13:42:29 +01:00
|
|
|
// OSXFuse will create the mountpoint for us ( https://github.com/rfjakob/gocryptfs/issues/194 )
|
|
|
|
if runtime.GOOS == "darwin" && os.IsNotExist(err) {
|
2018-01-16 22:59:43 +01:00
|
|
|
tlog.Info.Printf("Mountpoint %q does not exist, but should be created by OSXFuse",
|
|
|
|
args.mountpoint)
|
|
|
|
err = nil
|
|
|
|
}
|
2016-10-08 18:27:31 +02:00
|
|
|
}
|
|
|
|
if err != nil {
|
|
|
|
tlog.Fatal.Printf("Invalid mountpoint: %v", err)
|
2017-05-07 22:15:01 +02:00
|
|
|
os.Exit(exitcodes.MountPoint)
|
2016-10-08 18:27:31 +02:00
|
|
|
}
|
2016-12-10 14:54:06 +01:00
|
|
|
// Open control socket early so we can error out before asking the user
|
|
|
|
// for the password
|
|
|
|
if args.ctlsock != "" {
|
|
|
|
// We must use an absolute path because we cd to / when daemonizing.
|
|
|
|
// This messes up the delete-on-close logic in the unix socket object.
|
|
|
|
args.ctlsock, _ = filepath.Abs(args.ctlsock)
|
|
|
|
var sock net.Listener
|
|
|
|
sock, err = net.Listen("unix", args.ctlsock)
|
|
|
|
if err != nil {
|
|
|
|
tlog.Fatal.Printf("ctlsock: %v", err)
|
2017-05-14 13:51:13 +02:00
|
|
|
os.Exit(exitcodes.CtlSock)
|
2016-12-10 14:54:06 +01:00
|
|
|
}
|
|
|
|
args._ctlsockFd = sock
|
|
|
|
// Close also deletes the socket file
|
|
|
|
defer func() {
|
|
|
|
err = sock.Close()
|
|
|
|
if err != nil {
|
2018-02-28 09:02:18 +01:00
|
|
|
tlog.Warn.Printf("ctlsock close: %v", err)
|
2016-12-10 14:54:06 +01:00
|
|
|
}
|
|
|
|
}()
|
|
|
|
}
|
2019-08-04 13:45:10 +02:00
|
|
|
// Preallocation on Btrfs is broken ( https://github.com/rfjakob/gocryptfs/issues/395 )
|
|
|
|
// and slow ( https://github.com/rfjakob/gocryptfs/issues/63 ).
|
|
|
|
if !args.noprealloc {
|
2019-08-04 19:43:07 +02:00
|
|
|
// darwin does not have unix.BTRFS_SUPER_MAGIC, so we define it here
|
|
|
|
const BTRFS_SUPER_MAGIC = 0x9123683e
|
2019-08-04 13:45:10 +02:00
|
|
|
var st unix.Statfs_t
|
|
|
|
err = unix.Statfs(args.cipherdir, &st)
|
2019-08-04 19:43:07 +02:00
|
|
|
// Cast to uint32 avoids compile error on arm: "constant 2435016766 overflows int32"
|
|
|
|
if err == nil && uint32(st.Type) == BTRFS_SUPER_MAGIC {
|
2019-08-04 13:45:10 +02:00
|
|
|
tlog.Info.Printf(tlog.ColorYellow +
|
|
|
|
"Btrfs detected, forcing -noprealloc. See https://github.com/rfjakob/gocryptfs/issues/395 for why." +
|
|
|
|
tlog.ColorReset)
|
|
|
|
args.noprealloc = true
|
|
|
|
}
|
|
|
|
}
|
2018-04-01 15:47:35 +02:00
|
|
|
// We cannot use JSON for pretty-printing as the fields are unexported
|
|
|
|
tlog.Debug.Printf("cli args: %#v", args)
|
2018-09-08 13:04:33 +02:00
|
|
|
// Initialize gocryptfs (read config file, ask for password, ...)
|
2018-04-01 15:47:35 +02:00
|
|
|
fs, wipeKeys := initFuseFrontend(args)
|
|
|
|
// Initialize go-fuse FUSE server
|
|
|
|
srv := initGoFuse(fs, args)
|
2018-10-06 21:49:33 +02:00
|
|
|
// Try to wipe secret keys from memory after unmount
|
2018-04-01 15:47:35 +02:00
|
|
|
defer wipeKeys()
|
|
|
|
|
2016-10-08 18:27:31 +02:00
|
|
|
tlog.Info.Println(tlog.ColorGreen + "Filesystem mounted and ready." + tlog.ColorReset)
|
|
|
|
// We have been forked into the background, as evidenced by the set
|
|
|
|
// "notifypid".
|
|
|
|
if args.notifypid > 0 {
|
|
|
|
// Chdir to the root directory so we don't block unmounting the CWD
|
|
|
|
os.Chdir("/")
|
|
|
|
// Switch to syslog
|
|
|
|
if !args.nosyslog {
|
2016-10-26 11:19:14 +02:00
|
|
|
// Switch all of our logs and the generic logger to syslog
|
2016-10-08 18:27:31 +02:00
|
|
|
tlog.Info.SwitchToSyslog(syslog.LOG_USER | syslog.LOG_INFO)
|
|
|
|
tlog.Debug.SwitchToSyslog(syslog.LOG_USER | syslog.LOG_DEBUG)
|
|
|
|
tlog.Warn.SwitchToSyslog(syslog.LOG_USER | syslog.LOG_WARNING)
|
2018-10-17 22:01:37 +02:00
|
|
|
tlog.Fatal.SwitchToSyslog(syslog.LOG_USER | syslog.LOG_CRIT)
|
2016-10-08 18:27:31 +02:00
|
|
|
tlog.SwitchLoggerToSyslog(syslog.LOG_USER | syslog.LOG_WARNING)
|
2017-05-24 19:57:45 +02:00
|
|
|
// Daemons should redirect stdin, stdout and stderr
|
|
|
|
redirectStdFds()
|
2016-10-08 18:27:31 +02:00
|
|
|
}
|
2017-01-02 23:29:52 +01:00
|
|
|
// Disconnect from the controlling terminal by creating a new session.
|
|
|
|
// This prevents us from getting SIGINT when the user presses Ctrl-C
|
|
|
|
// to exit a running script that has called gocryptfs.
|
|
|
|
_, err = syscall.Setsid()
|
|
|
|
if err != nil {
|
|
|
|
tlog.Warn.Printf("Setsid: %v", err)
|
|
|
|
}
|
2016-10-08 18:27:31 +02:00
|
|
|
// Send SIGUSR1 to our parent
|
|
|
|
sendUsr1(args.notifypid)
|
|
|
|
}
|
2017-05-03 08:59:21 +02:00
|
|
|
// Increase the open file limit to 4096. This is not essential, so do it after
|
|
|
|
// we have switched to syslog and don't bother the user with warnings.
|
|
|
|
setOpenFileLimit()
|
2016-10-08 18:27:31 +02:00
|
|
|
// Wait for SIGINT in the background and unmount ourselves if we get it.
|
|
|
|
// This prevents a dangling "Transport endpoint is not connected"
|
|
|
|
// mountpoint if the user hits CTRL-C.
|
|
|
|
handleSigint(srv, args.mountpoint)
|
2017-07-29 17:12:32 +02:00
|
|
|
// Return memory that was allocated for scrypt (64M by default!) and other
|
|
|
|
// stuff that is no longer needed to the OS
|
|
|
|
debug.FreeOSMemory()
|
2018-10-06 21:49:33 +02:00
|
|
|
// Set up autounmount, if requested.
|
|
|
|
if args.idle > 0 && !args.reverse {
|
|
|
|
// Not being in reverse mode means we always have a forward file system.
|
2020-06-11 22:20:15 +02:00
|
|
|
fwdFs := fs.(*fusefrontend.RootNode)
|
2018-10-06 21:49:33 +02:00
|
|
|
go idleMonitor(args.idle, fwdFs, srv, args.mountpoint)
|
|
|
|
}
|
2020-07-08 22:21:27 +02:00
|
|
|
// Wait for unmount.
|
|
|
|
srv.Wait()
|
2016-10-08 18:27:31 +02:00
|
|
|
}
|
|
|
|
|
2018-10-06 21:49:33 +02:00
|
|
|
// Based on the EncFS idle monitor:
|
|
|
|
// https://github.com/vgough/encfs/blob/1974b417af189a41ffae4c6feb011d2a0498e437/encfs/main.cpp#L851
|
|
|
|
// idleMonitor is a function to be run as a thread that checks for
|
|
|
|
// filesystem idleness and unmounts if we've been idle for long enough.
|
|
|
|
const checksDuringTimeoutPeriod = 4
|
|
|
|
|
2020-06-11 22:20:15 +02:00
|
|
|
func idleMonitor(idleTimeout time.Duration, fs *fusefrontend.RootNode, srv *fuse.Server, mountpoint string) {
|
2021-01-02 18:11:18 +01:00
|
|
|
// sleepNs is the sleep time between checks, in nanoseconds.
|
|
|
|
sleepNs := contentenc.MinUint64(
|
2018-10-06 21:49:33 +02:00
|
|
|
uint64(idleTimeout/checksDuringTimeoutPeriod),
|
|
|
|
uint64(2*time.Minute))
|
2021-01-02 18:11:18 +01:00
|
|
|
timeoutCycles := int(math.Ceil(float64(idleTimeout) / float64(sleepNs)))
|
2018-10-06 21:49:33 +02:00
|
|
|
idleCount := 0
|
2021-01-02 18:11:18 +01:00
|
|
|
idleTime := func() time.Duration {
|
|
|
|
return time.Duration(sleepNs * uint64(idleCount))
|
|
|
|
}
|
2018-10-06 21:49:33 +02:00
|
|
|
for {
|
2019-09-08 16:29:20 +02:00
|
|
|
// Atomically check whether the flag is 0 and reset it to 1 if so.
|
|
|
|
isIdle := !atomic.CompareAndSwapUint32(&fs.IsIdle, 0, 1)
|
2018-10-06 21:49:33 +02:00
|
|
|
// Any form of current or recent access resets the idle counter.
|
|
|
|
openFileCount := openfiletable.CountOpenFiles()
|
2019-09-08 16:29:20 +02:00
|
|
|
if !isIdle || openFileCount > 0 {
|
2018-10-06 21:49:33 +02:00
|
|
|
idleCount = 0
|
|
|
|
} else {
|
|
|
|
idleCount++
|
|
|
|
}
|
|
|
|
tlog.Debug.Printf(
|
2021-01-02 18:11:18 +01:00
|
|
|
"idleMonitor: idle for %v (idleCount = %d, isIdle = %t, open = %d)",
|
|
|
|
idleTime(), idleCount, isIdle, openFileCount)
|
2018-10-06 21:49:33 +02:00
|
|
|
if idleCount > 0 && idleCount%timeoutCycles == 0 {
|
2021-01-02 18:11:18 +01:00
|
|
|
tlog.Info.Printf("idleMonitor: filesystem idle; unmounting: %s", mountpoint)
|
|
|
|
err := srv.Unmount()
|
|
|
|
if err != nil {
|
|
|
|
// We get "Device or resource busy" when a process has its
|
|
|
|
// working directory on the mount. Log the event at Info level
|
|
|
|
// so the user finds out why their filesystem does not get
|
|
|
|
// unmounted.
|
|
|
|
tlog.Info.Printf("idleMonitor: unmount failed: %v. Resetting idle time.", err)
|
|
|
|
idleCount = 0
|
|
|
|
}
|
2018-10-06 21:49:33 +02:00
|
|
|
}
|
2021-01-02 18:11:18 +01:00
|
|
|
time.Sleep(time.Duration(sleepNs))
|
2018-10-06 21:49:33 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-05-03 08:59:21 +02:00
|
|
|
// setOpenFileLimit tries to increase the open file limit to 4096 (the default hard
|
|
|
|
// limit on Linux).
|
|
|
|
func setOpenFileLimit() {
|
|
|
|
var lim syscall.Rlimit
|
|
|
|
err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &lim)
|
|
|
|
if err != nil {
|
|
|
|
tlog.Warn.Printf("Getting RLIMIT_NOFILE failed: %v", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if lim.Cur >= 4096 {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
lim.Cur = 4096
|
|
|
|
err = syscall.Setrlimit(syscall.RLIMIT_NOFILE, &lim)
|
|
|
|
if err != nil {
|
|
|
|
tlog.Warn.Printf("Setting RLIMIT_NOFILE to %+v failed: %v", lim, err)
|
|
|
|
// %+v output: "{Cur:4097 Max:4096}" ^
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-07-19 23:03:47 +02:00
|
|
|
// initFuseFrontend - initialize gocryptfs/internal/fusefrontend
|
2016-10-08 18:27:31 +02:00
|
|
|
// Calls os.Exit on errors
|
2020-06-11 22:20:15 +02:00
|
|
|
func initFuseFrontend(args *argContainer) (rootNode fs.InodeEmbedder, wipeKeys func()) {
|
2020-05-09 16:32:11 +02:00
|
|
|
var err error
|
|
|
|
var confFile *configfile.ConfFile
|
|
|
|
// Get the masterkey from the command line if it was specified
|
|
|
|
masterkey := handleArgsMasterkey(args)
|
|
|
|
// Otherwise, load masterkey from config file (normal operation).
|
|
|
|
// Prompts the user for the password.
|
|
|
|
if masterkey == nil {
|
|
|
|
masterkey, confFile, err = loadConfig(args)
|
|
|
|
if err != nil {
|
|
|
|
if args._ctlsockFd != nil {
|
|
|
|
// Close the socket file (which also deletes it)
|
|
|
|
args._ctlsockFd.Close()
|
|
|
|
}
|
|
|
|
exitcodes.Exit(err)
|
|
|
|
}
|
|
|
|
}
|
2016-10-08 18:27:31 +02:00
|
|
|
// Reconciliate CLI and config file arguments into a fusefrontend.Args struct
|
|
|
|
// that is passed to the filesystem implementation
|
|
|
|
cryptoBackend := cryptocore.BackendGoGCM
|
|
|
|
if args.openssl {
|
|
|
|
cryptoBackend = cryptocore.BackendOpenSSL
|
|
|
|
}
|
|
|
|
if args.aessiv {
|
|
|
|
cryptoBackend = cryptocore.BackendAESSIV
|
|
|
|
}
|
2017-05-30 23:01:06 +02:00
|
|
|
// forceOwner implies allow_other, as documented.
|
|
|
|
// Set this early, so args.allow_other can be relied on below this point.
|
|
|
|
if args._forceOwner != nil {
|
|
|
|
args.allow_other = true
|
|
|
|
}
|
2016-10-08 18:27:31 +02:00
|
|
|
frontendArgs := fusefrontend.Args{
|
2019-02-16 21:55:54 +01:00
|
|
|
Cipherdir: args.cipherdir,
|
|
|
|
PlaintextNames: args.plaintextnames,
|
|
|
|
LongNames: args.longnames,
|
|
|
|
ConfigCustom: args._configCustom,
|
|
|
|
NoPrealloc: args.noprealloc,
|
|
|
|
SerializeReads: args.serialize_reads,
|
|
|
|
ForceDecode: args.forcedecode,
|
|
|
|
ForceOwner: args._forceOwner,
|
|
|
|
Exclude: args.exclude,
|
|
|
|
ExcludeWildcard: args.excludeWildcard,
|
|
|
|
ExcludeFrom: args.excludeFrom,
|
2020-10-18 21:05:44 +02:00
|
|
|
Suid: args.suid,
|
2020-12-08 08:27:23 +01:00
|
|
|
KernelCache: args.kernel_cache,
|
2021-03-07 17:22:29 +01:00
|
|
|
SharedStorage: args.sharedstorage,
|
2016-10-08 18:27:31 +02:00
|
|
|
}
|
|
|
|
// confFile is nil when "-zerokey" or "-masterkey" was used
|
|
|
|
if confFile != nil {
|
|
|
|
// Settings from the config file override command line args
|
|
|
|
frontendArgs.PlaintextNames = confFile.IsFeatureFlagSet(configfile.FlagPlaintextNames)
|
2018-02-17 16:26:35 +01:00
|
|
|
args.raw64 = confFile.IsFeatureFlagSet(configfile.FlagRaw64)
|
|
|
|
args.hkdf = confFile.IsFeatureFlagSet(configfile.FlagHKDF)
|
2016-10-08 18:27:31 +02:00
|
|
|
if confFile.IsFeatureFlagSet(configfile.FlagAESSIV) {
|
2018-02-17 16:26:35 +01:00
|
|
|
cryptoBackend = cryptocore.BackendAESSIV
|
2016-10-08 18:27:31 +02:00
|
|
|
} else if args.reverse {
|
|
|
|
tlog.Fatal.Printf("AES-SIV is required by reverse mode, but not enabled in the config file")
|
2017-05-07 22:15:01 +02:00
|
|
|
os.Exit(exitcodes.Usage)
|
2016-10-08 18:27:31 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
// If allow_other is set and we run as root, try to give newly created files to
|
|
|
|
// the right user.
|
|
|
|
if args.allow_other && os.Getuid() == 0 {
|
|
|
|
frontendArgs.PreserveOwner = true
|
|
|
|
}
|
|
|
|
jsonBytes, _ := json.MarshalIndent(frontendArgs, "", "\t")
|
|
|
|
tlog.Debug.Printf("frontendArgs: %s", string(jsonBytes))
|
2018-04-01 15:47:35 +02:00
|
|
|
|
2018-02-17 16:26:35 +01:00
|
|
|
// Init crypto backend
|
|
|
|
cCore := cryptocore.New(masterkey, cryptoBackend, contentenc.DefaultIVBits, args.hkdf, args.forcedecode)
|
|
|
|
cEnc := contentenc.New(cCore, contentenc.DefaultBS, args.forcedecode)
|
|
|
|
nameTransform := nametransform.New(cCore.EMECipher, frontendArgs.LongNames, args.raw64)
|
2019-09-14 18:32:54 +02:00
|
|
|
// Init badname patterns
|
|
|
|
nameTransform.BadnamePatterns = make([]string, 0)
|
|
|
|
for _, pattern := range args.badname {
|
|
|
|
_, err := filepath.Match(pattern, "") // Make sure pattern is valid
|
|
|
|
if err != nil {
|
|
|
|
tlog.Fatal.Printf("-badname: invalid pattern %q supplied", pattern)
|
|
|
|
os.Exit(exitcodes.Usage)
|
|
|
|
} else {
|
|
|
|
nameTransform.BadnamePatterns = append(nameTransform.BadnamePatterns, pattern)
|
|
|
|
}
|
|
|
|
}
|
2018-04-01 15:47:35 +02:00
|
|
|
// After the crypto backend is initialized,
|
|
|
|
// we can purge the master key from memory.
|
|
|
|
for i := range masterkey {
|
|
|
|
masterkey[i] = 0
|
|
|
|
}
|
|
|
|
masterkey = nil
|
2018-02-17 16:26:35 +01:00
|
|
|
// Spawn fusefrontend
|
2016-10-08 18:27:31 +02:00
|
|
|
if args.reverse {
|
2018-02-17 16:26:35 +01:00
|
|
|
if cryptoBackend != cryptocore.BackendAESSIV {
|
|
|
|
log.Panic("reverse mode must use AES-SIV, everything else is insecure")
|
|
|
|
}
|
2020-06-11 22:20:15 +02:00
|
|
|
rootNode = fusefrontend_reverse.NewRootNode(frontendArgs, cEnc, nameTransform)
|
2016-10-08 18:27:31 +02:00
|
|
|
} else {
|
2020-06-11 22:20:15 +02:00
|
|
|
rootNode = fusefrontend.NewRootNode(frontendArgs, cEnc, nameTransform)
|
2016-11-10 00:27:08 +01:00
|
|
|
}
|
2016-12-10 14:54:06 +01:00
|
|
|
// We have opened the socket early so that we cannot fail here after
|
|
|
|
// asking the user for the password
|
|
|
|
if args._ctlsockFd != nil {
|
2020-06-11 22:20:15 +02:00
|
|
|
go ctlsocksrv.Serve(args._ctlsockFd, rootNode.(ctlsocksrv.Interface))
|
2016-10-08 18:27:31 +02:00
|
|
|
}
|
2020-06-11 22:20:15 +02:00
|
|
|
return rootNode, func() { cCore.Wipe() }
|
2018-04-01 15:47:35 +02:00
|
|
|
}
|
|
|
|
|
2020-07-19 23:03:47 +02:00
|
|
|
// initGoFuse calls into go-fuse to mount `rootNode` on `args.mountpoint`.
|
|
|
|
// The mountpoint is ready to use when the functions returns.
|
|
|
|
// On error, it calls os.Exit and does not return.
|
2020-06-11 22:20:15 +02:00
|
|
|
func initGoFuse(rootNode fs.InodeEmbedder, args *argContainer) *fuse.Server {
|
|
|
|
var fuseOpts *fs.Options
|
|
|
|
sec := time.Second
|
2017-11-12 20:06:13 +01:00
|
|
|
if args.sharedstorage {
|
|
|
|
// sharedstorage mode sets all cache timeouts to zero so changes to the
|
|
|
|
// backing shared storage show up immediately.
|
2021-03-07 17:22:29 +01:00
|
|
|
// Hard links are disabled by using automatically incrementing
|
|
|
|
// inode numbers provided by go-fuse.
|
|
|
|
fuseOpts = &fs.Options{
|
|
|
|
FirstAutomaticIno: 1000,
|
|
|
|
}
|
2017-11-12 20:06:13 +01:00
|
|
|
} else {
|
2020-06-11 22:20:15 +02:00
|
|
|
fuseOpts = &fs.Options{
|
2017-11-12 20:06:13 +01:00
|
|
|
// These options are to be compatible with libfuse defaults,
|
|
|
|
// making benchmarking easier.
|
2020-06-11 22:20:15 +02:00
|
|
|
NegativeTimeout: &sec,
|
|
|
|
AttrTimeout: &sec,
|
|
|
|
EntryTimeout: &sec,
|
2017-11-12 20:06:13 +01:00
|
|
|
}
|
2016-10-08 18:27:31 +02:00
|
|
|
}
|
2020-07-12 20:39:19 +02:00
|
|
|
fuseOpts.NullPermissions = true
|
2020-07-19 12:48:29 +02:00
|
|
|
// Enable go-fuse warnings
|
2020-10-14 15:33:37 +02:00
|
|
|
fuseOpts.Logger = log.New(os.Stderr, "go-fuse: ", log.Lmicroseconds)
|
2020-06-11 22:20:15 +02:00
|
|
|
fuseOpts.MountOptions = fuse.MountOptions{
|
2017-10-21 18:06:55 +02:00
|
|
|
// Writes and reads are usually capped at 128kiB on Linux through
|
|
|
|
// the FUSE_MAX_PAGES_PER_REQ kernel constant in fuse_i.h. Our
|
|
|
|
// sync.Pool buffer pools are sized acc. to the default. Users may set
|
|
|
|
// the kernel constant higher, and Synology NAS kernels are known to
|
|
|
|
// have it >128kiB. We cannot handle more than 128kiB, so we tell
|
2018-04-08 20:24:29 +02:00
|
|
|
// the kernel to limit the size explicitly.
|
2017-07-01 11:32:17 +02:00
|
|
|
MaxWrite: fuse.MAX_KERNEL_WRITE,
|
2017-10-21 18:06:55 +02:00
|
|
|
Options: []string{fmt.Sprintf("max_read=%d", fuse.MAX_KERNEL_WRITE)},
|
2020-07-27 23:31:57 +02:00
|
|
|
Debug: args.fusedebug,
|
2017-06-01 18:43:23 +02:00
|
|
|
}
|
2020-07-19 12:48:29 +02:00
|
|
|
|
2020-06-11 22:20:15 +02:00
|
|
|
mOpts := &fuseOpts.MountOptions
|
2016-10-08 18:27:31 +02:00
|
|
|
if args.allow_other {
|
|
|
|
tlog.Info.Printf(tlog.ColorYellow + "The option \"-allow_other\" is set. Make sure the file " +
|
|
|
|
"permissions protect your data from unwanted access." + tlog.ColorReset)
|
|
|
|
mOpts.AllowOther = true
|
|
|
|
// Make the kernel check the file permissions for us
|
|
|
|
mOpts.Options = append(mOpts.Options, "default_permissions")
|
|
|
|
}
|
2017-04-24 00:25:02 +02:00
|
|
|
if args.forcedecode {
|
|
|
|
tlog.Info.Printf(tlog.ColorYellow + "THE OPTION \"-forcedecode\" IS ACTIVE. GOCRYPTFS WILL RETURN CORRUPT DATA!" +
|
|
|
|
tlog.ColorReset)
|
|
|
|
}
|
2019-12-28 20:44:12 +01:00
|
|
|
// fusermount from libfuse 3.x removed the "nonempty" option and exits
|
|
|
|
// with an error if it sees it. Only add it to the options on libfuse 2.x.
|
|
|
|
if args.nonempty && haveFusermount2() {
|
2016-10-08 18:27:31 +02:00
|
|
|
mOpts.Options = append(mOpts.Options, "nonempty")
|
|
|
|
}
|
|
|
|
// Set values shown in "df -T" and friends
|
|
|
|
// First column, "Filesystem"
|
2017-01-26 22:13:57 +01:00
|
|
|
fsname := args.cipherdir
|
|
|
|
if args.fsname != "" {
|
|
|
|
fsname = args.fsname
|
|
|
|
}
|
2018-09-18 19:35:31 +02:00
|
|
|
fsname2 := strings.Replace(fsname, ",", "_", -1)
|
|
|
|
if fsname2 != fsname {
|
|
|
|
tlog.Warn.Printf("Warning: %q will be displayed as %q in \"df -T\"", fsname, fsname2)
|
|
|
|
fsname = fsname2
|
|
|
|
}
|
2017-01-26 22:13:57 +01:00
|
|
|
mOpts.Options = append(mOpts.Options, "fsname="+fsname)
|
2016-10-08 18:27:31 +02:00
|
|
|
// Second column, "Type", will be shown as "fuse." + Name
|
|
|
|
mOpts.Name = "gocryptfs"
|
|
|
|
if args.reverse {
|
|
|
|
mOpts.Name += "-reverse"
|
|
|
|
}
|
2017-03-26 21:09:54 +02:00
|
|
|
// Add a volume name if running osxfuse. Otherwise the Finder will show it as
|
|
|
|
// something like "osxfuse Volume 0 (gocryptfs)".
|
|
|
|
if runtime.GOOS == "darwin" {
|
2019-01-15 19:37:02 +01:00
|
|
|
volname := strings.Replace(path.Base(args.mountpoint), ",", "_", -1)
|
|
|
|
mOpts.Options = append(mOpts.Options, "volname="+volname)
|
2017-03-26 21:09:54 +02:00
|
|
|
}
|
2016-10-08 18:27:31 +02:00
|
|
|
// The kernel enforces read-only operation, we just have to pass "ro".
|
2016-11-10 00:27:08 +01:00
|
|
|
// Reverse mounts are always read-only.
|
2016-10-08 18:27:31 +02:00
|
|
|
if args.ro || args.reverse {
|
|
|
|
mOpts.Options = append(mOpts.Options, "ro")
|
2018-06-07 22:50:30 +02:00
|
|
|
} else if args.rw {
|
|
|
|
mOpts.Options = append(mOpts.Options, "rw")
|
|
|
|
}
|
2021-03-07 17:22:29 +01:00
|
|
|
// If both "nosuid" & "suid", "nodev" & "dev", etc were passed, the safer
|
|
|
|
// option wins.
|
2018-06-07 22:50:30 +02:00
|
|
|
if args.nosuid {
|
|
|
|
mOpts.Options = append(mOpts.Options, "nosuid")
|
|
|
|
} else if args.suid {
|
|
|
|
mOpts.Options = append(mOpts.Options, "suid")
|
|
|
|
}
|
|
|
|
if args.nodev {
|
|
|
|
mOpts.Options = append(mOpts.Options, "nodev")
|
|
|
|
} else if args.dev {
|
|
|
|
mOpts.Options = append(mOpts.Options, "dev")
|
|
|
|
}
|
|
|
|
if args.noexec {
|
|
|
|
mOpts.Options = append(mOpts.Options, "noexec")
|
|
|
|
} else if args.exec {
|
|
|
|
mOpts.Options = append(mOpts.Options, "exec")
|
2016-10-08 18:27:31 +02:00
|
|
|
}
|
|
|
|
// Add additional mount options (if any) after the stock ones, so the user has
|
|
|
|
// a chance to override them.
|
2016-10-09 19:32:55 +02:00
|
|
|
if args.ko != "" {
|
|
|
|
parts := strings.Split(args.ko, ",")
|
|
|
|
tlog.Debug.Printf("Adding -ko mount options: %v", parts)
|
2016-10-08 18:27:31 +02:00
|
|
|
mOpts.Options = append(mOpts.Options, parts...)
|
|
|
|
}
|
2020-06-11 22:20:15 +02:00
|
|
|
srv, err := fs.Mount(args.mountpoint, rootNode, fuseOpts)
|
2016-10-08 18:27:31 +02:00
|
|
|
if err != nil {
|
2020-06-11 22:20:15 +02:00
|
|
|
tlog.Fatal.Printf("fs.Mount failed: %s", strings.TrimSpace(err.Error()))
|
2017-07-10 23:33:41 +02:00
|
|
|
if runtime.GOOS == "darwin" {
|
|
|
|
tlog.Info.Printf("Maybe you should run: /Library/Filesystems/osxfuse.fs/Contents/Resources/load_osxfuse")
|
|
|
|
}
|
2017-05-14 13:51:13 +02:00
|
|
|
os.Exit(exitcodes.FuseNewServer)
|
2016-10-08 18:27:31 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// All FUSE file and directory create calls carry explicit permission
|
|
|
|
// information. We need an unrestricted umask to create the files and
|
|
|
|
// directories with the requested permissions.
|
|
|
|
syscall.Umask(0000)
|
|
|
|
|
2018-04-01 15:47:35 +02:00
|
|
|
return srv
|
2016-10-08 18:27:31 +02:00
|
|
|
}
|
|
|
|
|
2019-12-28 20:44:12 +01:00
|
|
|
// haveFusermount2 finds out if the "fusermount" binary is from libfuse 2.x.
|
|
|
|
func haveFusermount2() bool {
|
2020-01-14 23:12:56 +01:00
|
|
|
path, err := exec.LookPath("fusermount")
|
|
|
|
if err != nil {
|
|
|
|
path = "/bin/fusermount"
|
|
|
|
}
|
|
|
|
cmd := exec.Command(path, "-V")
|
2019-12-28 20:44:12 +01:00
|
|
|
var out bytes.Buffer
|
|
|
|
cmd.Stdout = &out
|
2020-01-14 23:12:56 +01:00
|
|
|
err = cmd.Run()
|
2019-12-28 20:44:12 +01:00
|
|
|
if err != nil {
|
|
|
|
tlog.Warn.Printf("warning: haveFusermount2: %v", err)
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
// libfuse 2: fusermount version: 2.9.9
|
|
|
|
// libfuse 3: fusermount3 version: 3.9.0
|
|
|
|
v := out.String()
|
|
|
|
if strings.HasPrefix(v, "fusermount version") {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2016-10-08 18:27:31 +02:00
|
|
|
func handleSigint(srv *fuse.Server, mountpoint string) {
|
|
|
|
ch := make(chan os.Signal, 1)
|
|
|
|
signal.Notify(ch, os.Interrupt)
|
|
|
|
signal.Notify(ch, syscall.SIGTERM)
|
|
|
|
go func() {
|
|
|
|
<-ch
|
2018-10-06 21:49:33 +02:00
|
|
|
unmount(srv, mountpoint)
|
2017-05-07 22:15:01 +02:00
|
|
|
os.Exit(exitcodes.SigInt)
|
2016-10-08 18:27:31 +02:00
|
|
|
}()
|
|
|
|
}
|
2018-10-06 21:49:33 +02:00
|
|
|
|
2021-01-02 18:11:18 +01:00
|
|
|
// unmount() calls srv.Unmount(), and if that fails, calls "fusermount -u -z"
|
|
|
|
// (lazy unmount).
|
2018-10-06 21:49:33 +02:00
|
|
|
func unmount(srv *fuse.Server, mountpoint string) {
|
|
|
|
err := srv.Unmount()
|
|
|
|
if err != nil {
|
|
|
|
tlog.Warn.Printf("unmount: srv.Unmount returned %v", err)
|
|
|
|
if runtime.GOOS == "linux" {
|
|
|
|
// MacOSX does not support lazy unmount
|
|
|
|
tlog.Info.Printf("Trying lazy unmount")
|
|
|
|
cmd := exec.Command("fusermount", "-u", "-z", mountpoint)
|
|
|
|
cmd.Stdout = os.Stdout
|
|
|
|
cmd.Stderr = os.Stderr
|
|
|
|
cmd.Run()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|