1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
|
package matrix
import (
"os"
"path/filepath"
"strconv"
"strings"
"testing"
"time"
"golang.org/x/sys/unix"
"github.com/rfjakob/gocryptfs/v2/ctlsock"
"github.com/rfjakob/gocryptfs/v2/tests/test_helpers"
)
const testStatxMask = unix.STATX_BASIC_STATS | unix.STATX_BTIME
func statxAt(t *testing.T, dirfd int, path string, flags int) unix.Statx_t {
t.Helper()
var st unix.Statx_t
if err := unix.Statx(dirfd, path, flags, testStatxMask, &st); err != nil {
t.Fatal(err)
}
return st
}
func encryptedPath(t *testing.T, plainPath string) string {
t.Helper()
resp := test_helpers.QueryCtlSock(t, ctlsockPath, ctlsock.RequestStruct{
EncryptPath: plainPath,
})
if resp.Result == "" {
t.Fatal(resp)
}
return filepath.Join(test_helpers.DefaultCipherDir, resp.Result)
}
func requireFuseStatx(t *testing.T) {
t.Helper()
data, err := os.ReadFile("/proc/sys/kernel/osrelease")
if err != nil {
t.Fatal(err)
}
parts := strings.SplitN(strings.TrimSpace(string(data)), ".", 3)
if len(parts) < 2 {
t.Skipf("cannot parse kernel release %q", data)
}
major, err := strconv.Atoi(parts[0])
if err != nil {
t.Skipf("cannot parse kernel release %q: %v", data, err)
}
minorString := parts[1]
if i := strings.IndexFunc(minorString, func(r rune) bool {
return r < '0' || r > '9'
}); i >= 0 {
minorString = minorString[:i]
}
minor, err := strconv.Atoi(minorString)
if err != nil {
t.Skipf("cannot parse kernel release %q: %v", data, err)
}
if major < 6 || major == 6 && minor < 6 {
t.Skip("FUSE_STATX requires Linux 6.6 or newer")
}
}
func checkBtime(t *testing.T, plainPath string, cipherPath string, flags int) unix.Statx_t {
t.Helper()
cipherSt := statxAt(t, unix.AT_FDCWD, cipherPath, flags)
if cipherSt.Mask&unix.STATX_BTIME == 0 {
t.Skip("backing filesystem does not report STATX_BTIME")
}
plainSt := statxAt(t, unix.AT_FDCWD, plainPath, flags)
if plainSt.Mask&unix.STATX_BTIME == 0 {
t.Fatalf("mounted filesystem did not report STATX_BTIME: mask=%#x", plainSt.Mask)
}
if plainSt.Btime.Sec != cipherSt.Btime.Sec || plainSt.Btime.Nsec != cipherSt.Btime.Nsec {
t.Errorf("birth time mismatch: plain=%d.%09d cipher=%d.%09d",
plainSt.Btime.Sec, plainSt.Btime.Nsec,
cipherSt.Btime.Sec, cipherSt.Btime.Nsec)
}
return plainSt
}
func TestStatxBtime(t *testing.T) {
requireFuseStatx(t)
t.Run("root", func(t *testing.T) {
checkBtime(t, test_helpers.DefaultPlainDir, test_helpers.DefaultCipherDir, unix.AT_SYMLINK_NOFOLLOW)
})
t.Run("regular", func(t *testing.T) {
const content = "statx birth time"
relPath := strings.ReplaceAll(t.Name(), "/", "_")
plainPath := filepath.Join(test_helpers.DefaultPlainDir, relPath)
if err := os.WriteFile(plainPath, []byte(content), 0600); err != nil {
t.Fatal(err)
}
cipherPath := encryptedPath(t, relPath)
before := checkBtime(t, plainPath, cipherPath, unix.AT_SYMLINK_NOFOLLOW)
if before.Size != uint64(len(content)) {
t.Errorf("wrong plaintext size: have=%d want=%d", before.Size, len(content))
}
// Check user-visible AT_EMPTY_PATH behavior. Current Linux kernels do
// not send the file handle in FUSE_STATX, so this still reaches
// Node.Statx rather than File.Statx.
f, err := os.Open(plainPath)
if err != nil {
t.Fatal(err)
}
defer f.Close()
fdSt := statxAt(t, int(f.Fd()), "", unix.AT_EMPTY_PATH)
if fdSt.Mask&unix.STATX_BTIME == 0 {
t.Fatalf("statx on open file did not report STATX_BTIME: mask=%#x", fdSt.Mask)
}
if fdSt.Btime.Sec != before.Btime.Sec || fdSt.Btime.Nsec != before.Btime.Nsec {
t.Errorf("statx on open file returned different birth time: path=%d.%09d fd=%d.%09d",
before.Btime.Sec, before.Btime.Nsec, fdSt.Btime.Sec, fdSt.Btime.Nsec)
}
now := time.Now().Add(-time.Hour)
if err := os.Chtimes(plainPath, now, now); err != nil {
t.Fatal(err)
}
after := checkBtime(t, plainPath, cipherPath, unix.AT_SYMLINK_NOFOLLOW)
if after.Btime.Sec != before.Btime.Sec || after.Btime.Nsec != before.Btime.Nsec {
t.Errorf("birth time changed with mtime: before=%d.%09d after=%d.%09d",
before.Btime.Sec, before.Btime.Nsec, after.Btime.Sec, after.Btime.Nsec)
}
})
t.Run("directory", func(t *testing.T) {
relPath := strings.ReplaceAll(t.Name(), "/", "_")
plainPath := filepath.Join(test_helpers.DefaultPlainDir, relPath)
if err := os.Mkdir(plainPath, 0700); err != nil {
t.Fatal(err)
}
checkBtime(t, plainPath, encryptedPath(t, relPath), unix.AT_SYMLINK_NOFOLLOW)
})
t.Run("symlink", func(t *testing.T) {
const target = "/target/does/not/exist"
relPath := strings.ReplaceAll(t.Name(), "/", "_")
plainPath := filepath.Join(test_helpers.DefaultPlainDir, relPath)
if err := os.Symlink(target, plainPath); err != nil {
t.Fatal(err)
}
st := checkBtime(t, plainPath, encryptedPath(t, relPath), unix.AT_SYMLINK_NOFOLLOW)
if st.Size != uint64(len(target)) {
t.Errorf("wrong symlink size: have=%d want=%d", st.Size, len(target))
}
})
}
|
