libgocryptfs/tests/test_helpers/helpers.go

383 lines
9.2 KiB
Go
Raw Normal View History

package test_helpers
import (
"bytes"
"crypto/md5"
"encoding/hex"
2015-11-14 17:16:17 +01:00
"fmt"
"io/ioutil"
"log"
2015-11-14 17:16:17 +01:00
"os"
"os/exec"
"path/filepath"
2015-12-13 20:10:52 +01:00
"syscall"
"testing"
"github.com/rfjakob/gocryptfs/ctlsock"
Major refactoring: Split up "cryptfs" into several internal packages "git status" for reference: deleted: cryptfs/cryptfs.go deleted: cryptfs/names_core.go modified: integration_tests/cli_test.go modified: integration_tests/helpers.go renamed: cryptfs/config_file.go -> internal/configfile/config_file.go renamed: cryptfs/config_test.go -> internal/configfile/config_test.go renamed: cryptfs/config_test/.gitignore -> internal/configfile/config_test/.gitignore renamed: cryptfs/config_test/PlaintextNames.conf -> internal/configfile/config_test/PlaintextNames.conf renamed: cryptfs/config_test/StrangeFeature.conf -> internal/configfile/config_test/StrangeFeature.conf renamed: cryptfs/config_test/v1.conf -> internal/configfile/config_test/v1.conf renamed: cryptfs/config_test/v2.conf -> internal/configfile/config_test/v2.conf renamed: cryptfs/kdf.go -> internal/configfile/kdf.go renamed: cryptfs/kdf_test.go -> internal/configfile/kdf_test.go renamed: cryptfs/cryptfs_content.go -> internal/contentenc/content.go new file: internal/contentenc/content_api.go renamed: cryptfs/content_test.go -> internal/contentenc/content_test.go renamed: cryptfs/file_header.go -> internal/contentenc/file_header.go renamed: cryptfs/intrablock.go -> internal/contentenc/intrablock.go renamed: cryptfs/address_translation.go -> internal/contentenc/offsets.go new file: internal/cryptocore/crypto_api.go renamed: cryptfs/gcm_go1.4.go -> internal/cryptocore/gcm_go1.4.go renamed: cryptfs/gcm_go1.5.go -> internal/cryptocore/gcm_go1.5.go renamed: cryptfs/nonce.go -> internal/cryptocore/nonce.go renamed: cryptfs/openssl_aead.go -> internal/cryptocore/openssl_aead.go renamed: cryptfs/openssl_benchmark.bash -> internal/cryptocore/openssl_benchmark.bash renamed: cryptfs/openssl_test.go -> internal/cryptocore/openssl_test.go new file: internal/nametransform/name_api.go new file: internal/nametransform/names_core.go renamed: cryptfs/names_diriv.go -> internal/nametransform/names_diriv.go renamed: cryptfs/names_noiv.go -> internal/nametransform/names_noiv.go renamed: cryptfs/names_test.go -> internal/nametransform/names_test.go new file: internal/nametransform/pad16.go renamed: cryptfs/log.go -> internal/toggledlog/log.go renamed: cryptfs/log_go1.4.go -> internal/toggledlog/log_go1.4.go renamed: cryptfs/log_go1.5.go -> internal/toggledlog/log_go1.5.go modified: main.go modified: masterkey.go modified: pathfs_frontend/file.go modified: pathfs_frontend/file_holes.go modified: pathfs_frontend/fs.go modified: pathfs_frontend/fs_dir.go modified: pathfs_frontend/names.go modified: test.bash
2016-02-06 19:20:54 +01:00
"github.com/rfjakob/gocryptfs/internal/nametransform"
"github.com/rfjakob/gocryptfs/internal/syscallcompat"
)
// TmpDir will be created inside this directory, set in init() to
// $TMPDIR/gocryptfs-test-parent .
var testParentDir = ""
2016-10-02 06:14:18 +02:00
// GocryptfsBinary is the assumed path to the gocryptfs build.
const GocryptfsBinary = "../../gocryptfs"
// UnmountScript is the fusermount/umount compatibility wrapper script
const UnmountScript = "../../tests/fuse-unmount.bash"
// X255 contains 255 uppercase "X". This can be used as a maximum-length filename.
var X255 string
2016-10-02 06:14:18 +02:00
// TmpDir is a unique temporary directory. "go test" runs package tests in parallel. We create a
// unique TmpDir in init() so the tests do not interfere.
var TmpDir string
2016-09-24 22:45:25 +02:00
2016-10-02 06:14:18 +02:00
// DefaultPlainDir is TmpDir + "/default-plain"
var DefaultPlainDir string
2016-09-24 22:45:25 +02:00
2016-10-02 06:14:18 +02:00
// DefaultCipherDir is TmpDir + "/default-cipher"
var DefaultCipherDir string
func init() {
doInit()
}
func doInit() {
X255 = string(bytes.Repeat([]byte("X"), 255))
MountInfo = make(map[string]mountInfo)
// Something like /tmp/gocryptfs-test-parent-1234
testParentDir := fmt.Sprintf("%s/gocryptfs-test-parent-%d", os.TempDir(), os.Getuid())
os.MkdirAll(testParentDir, 0755)
var err error
TmpDir, err = ioutil.TempDir(testParentDir, "")
if err != nil {
panic(err)
}
// Open permissions for the allow_other tests
os.Chmod(TmpDir, 0755)
DefaultPlainDir = TmpDir + "/default-plain"
DefaultCipherDir = TmpDir + "/default-cipher"
}
2016-10-02 06:14:18 +02:00
// ResetTmpDir deletes TmpDir, create new dir tree:
2016-06-16 21:06:03 +02:00
//
// TmpDir
// |-- DefaultPlainDir
// *-- DefaultCipherDir
// *-- gocryptfs.diriv
func ResetTmpDir(createDirIV bool) {
// Try to unmount and delete everything
entries, err := ioutil.ReadDir(TmpDir)
if err == nil {
for _, e := range entries {
d := filepath.Join(TmpDir, e.Name())
err = os.Remove(d)
if err != nil {
pe := err.(*os.PathError)
if pe.Err == syscall.EBUSY {
if testing.Verbose() {
fmt.Printf("Remove failed: %v. Maybe still mounted?\n", pe)
}
err = UnmountErr(d)
if err != nil {
panic(err)
}
} else if pe.Err != syscall.ENOTEMPTY {
panic("Unhandled error: " + pe.Err.Error())
}
err = os.RemoveAll(d)
if err != nil {
panic(err)
}
}
}
}
err = os.Mkdir(DefaultPlainDir, 0755)
if err != nil {
panic(err)
}
err = os.Mkdir(DefaultCipherDir, 0755)
if err != nil {
panic(err)
}
if createDirIV {
// Open cipherdir (following symlinks)
dirfd, err := syscall.Open(DefaultCipherDir, syscall.O_DIRECTORY|syscallcompat.O_PATH, 0)
if err == nil {
err = nametransform.WriteDirIVAt(dirfd)
syscall.Close(dirfd)
}
if err != nil {
panic(err)
}
}
}
// InitFS creates a new empty cipherdir and calls
//
// gocryptfs -q -init -extpass "echo test" -scryptn=10 $extraArgs $cipherdir
//
// It returns cipherdir without a trailing slash.
2016-06-16 21:06:03 +02:00
func InitFS(t *testing.T, extraArgs ...string) string {
prefix := "x."
if t != nil {
prefix = t.Name() + "."
}
dir, err := ioutil.TempDir(TmpDir, prefix)
2016-06-16 21:06:03 +02:00
if err != nil {
if t != nil {
t.Fatal(err)
} else {
log.Panic(err)
}
2016-06-16 21:06:03 +02:00
}
args := []string{"-q", "-init", "-extpass", "echo test", "-scryptn=10"}
args = append(args, extraArgs...)
args = append(args, dir)
cmd := exec.Command(GocryptfsBinary, args...)
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
err = cmd.Run()
if err != nil {
if t != nil {
t.Fatalf("InitFS with args %q failed: %v", args, err)
} else {
log.Panic(err)
}
2016-06-16 21:06:03 +02:00
}
return dir
}
2016-10-02 06:14:18 +02:00
// Md5fn returns an md5 string for file "filename"
func Md5fn(filename string) string {
buf, err := ioutil.ReadFile(filename)
if err != nil {
fmt.Printf("ReadFile: %v\n", err)
return ""
}
return Md5hex(buf)
}
2016-10-02 06:14:18 +02:00
// Md5hex returns an md5 string for "buf"
func Md5hex(buf []byte) string {
rawHash := md5.Sum(buf)
hash := hex.EncodeToString(rawHash[:])
return hash
}
2016-10-02 06:14:18 +02:00
// VerifySize checks that the file size equals "want". This checks:
// 1) Number of bytes returned when reading the whole file
// 2) Size reported by Stat()
// 3) Size reported by Fstat()
func VerifySize(t *testing.T, path string, want int) {
// Read whole file
buf, err := ioutil.ReadFile(path)
if err != nil {
t.Errorf("ReadFile failed: %v", err)
} else if len(buf) != want {
t.Errorf("wrong read size: got=%d want=%d", len(buf), want)
}
// Stat()
var st syscall.Stat_t
err = syscall.Stat(path, &st)
if err != nil {
t.Errorf("Stat failed: %v", err)
} else if st.Size != int64(want) {
t.Errorf("wrong stat file size, got=%d want=%d", st.Size, want)
}
// Fstat()
fd, err := os.Open(path)
if err != nil {
t.Fatal(err)
}
defer fd.Close()
var st2 syscall.Stat_t
err = syscall.Fstat(int(fd.Fd()), &st2)
if err != nil {
t.Fatal(err)
}
if st2.Size != int64(want) {
t.Errorf("wrong fstat file size, got=%d want=%d", st2.Size, want)
}
if st != st2 {
t.Errorf("Stat vs Fstat mismatch:\nst= %v\nst2=%v", st, st2)
}
}
2016-10-02 06:14:18 +02:00
// TestMkdirRmdir creates and deletes a directory
func TestMkdirRmdir(t *testing.T, plainDir string) {
dir := plainDir + "/dir1"
err := os.Mkdir(dir, 0777)
if err != nil {
t.Error(err)
return
}
err = syscall.Rmdir(dir)
if err != nil {
t.Error(err)
return
}
// Create a directory and put a file in it
// Trying to rmdir it should fail with ENOTEMPTY
err = os.Mkdir(dir, 0777)
if err != nil {
t.Error(err)
return
}
f, err := os.Create(dir + "/file")
if err != nil {
t.Error(err)
return
}
f.Close()
err = syscall.Rmdir(dir)
errno := err.(syscall.Errno)
if errno != syscall.ENOTEMPTY {
t.Errorf("Should have gotten ENOTEMPTY, got %v", errno)
}
err = syscall.Unlink(dir + "/file")
if err != nil {
var st syscall.Stat_t
syscall.Stat(dir, &st)
t.Errorf("err=%v mode=%0o", err, st.Mode)
return
}
err = syscall.Rmdir(dir)
if err != nil {
t.Error(err)
return
}
// We should also be able to remove a directory we do not have permissions to
// read or write
err = os.Mkdir(dir, 0000)
if err != nil {
t.Error(err)
return
}
err = syscall.Rmdir(dir)
if err != nil {
// Make sure the directory can cleaned up by the next test run
os.Chmod(dir, 0700)
t.Error(err)
return
}
}
2016-10-02 06:14:18 +02:00
// TestRename creates and renames a file
func TestRename(t *testing.T, plainDir string) {
file1 := plainDir + "/rename1"
file2 := plainDir + "/rename2"
err := ioutil.WriteFile(file1, []byte("content"), 0777)
if err != nil {
t.Error(err)
return
}
err = syscall.Rename(file1, file2)
if err != nil {
t.Errorf("Rename: %v", err)
return
}
syscall.Unlink(file2)
}
2016-10-02 06:14:18 +02:00
// VerifyExistence checks in 3 ways that "path" exists:
// stat, open, readdir. Returns true if the path exists, false otherwise.
// Panics if the result is inconsistent.
func VerifyExistence(path string) bool {
// Check if file can be stat()ed
stat := true
fi, err := os.Stat(path)
if err != nil {
stat = false
}
// Check if file can be opened
open := true
fd, err := os.Open(path)
if err != nil {
open = false
}
fd.Close()
// Check if file shows up in directory listing
readdir := false
dir := filepath.Dir(path)
name := filepath.Base(path)
d, err := os.Open(dir)
if err != nil && open == true {
log.Panicf("we can open the file but not the parent dir!? err=%v", err)
} else if err == nil {
defer d.Close()
listing, err := d.Readdirnames(0)
if stat && fi.IsDir() && err != nil {
log.Panicf("It's a directory, but readdirnames failed: %v", err)
}
for _, entry := range listing {
if entry == name {
readdir = true
}
}
}
// If the result is consistent, return it.
if stat == open && open == readdir {
return stat
}
log.Panicf("inconsistent result on %q: stat=%v open=%v readdir=%v, path=%q", name, stat, open, readdir, path)
return false
}
// Du returns the disk usage of the file "fd" points to, in bytes.
// Same as "du --block-size=1".
func Du(t *testing.T, fd int) (nBytes int64) {
var st syscall.Stat_t
err := syscall.Fstat(fd, &st)
if err != nil {
t.Fatal(err)
}
// st.Blocks = number of 512-byte blocks
return st.Blocks * 512
}
// QueryCtlSock sends a request to the control socket at "socketPath" and
// returns the response.
func QueryCtlSock(t *testing.T, socketPath string, req ctlsock.RequestStruct) ctlsock.ResponseStruct {
c, err := ctlsock.New(socketPath)
if err != nil {
// Connecting to the socket failed already. This is fatal.
t.Fatal(err)
}
defer c.Close()
resp, err := c.Query(&req)
if err != nil {
// If we got a response, try to extract it. This is not fatal here
// as the tests may expect error responses.
if resp2, ok := err.(*ctlsock.ResponseStruct); ok {
return *resp2
}
// Another error means that we did not even get a response. This is fatal.
t.Fatal(err)
}
return *resp
}
// ExtractCmdExitCode extracts the exit code from an error value that was
// returned from exec / cmd.Run()
func ExtractCmdExitCode(err error) int {
if err == nil {
return 0
}
// OMG this is convoluted
if err2, ok := err.(*exec.ExitError); ok {
return err2.Sys().(syscall.WaitStatus).ExitStatus()
}
if err2, ok := err.(*os.PathError); ok {
return int(err2.Err.(syscall.Errno))
}
log.Panicf("could not decode error %#v", err)
return 0
}