From 89fef80d32708874c95742db0a7b593bcfd3b31d Mon Sep 17 00:00:00 2001 From: Jakob Unterwurzacher Date: Sun, 4 Oct 2015 14:36:20 +0200 Subject: [PATCH] Run go fmt --- cryptfs/config_file.go | 2 +- cryptfs/content_test.go | 12 ++--- cryptfs/cryptfs.go | 24 +++++----- cryptfs/cryptfs_content.go | 22 ++++----- cryptfs/cryptfs_names.go | 14 +++--- cryptfs/intrablock.go | 12 ++--- cryptfs/kdf.go | 8 ++-- cryptfs/names_test.go | 10 ++-- cryptfs/nonce.go | 8 ++-- cryptfs/openssl_aead.go | 4 +- main.go | 76 +++++++++++++++---------------- main_test.go | 4 +- openssl_benchmark/openssl_test.go | 6 +-- pathfs_frontend/file.go | 22 ++++----- pathfs_frontend/fs.go | 17 ++++--- 15 files changed, 120 insertions(+), 121 deletions(-) diff --git a/cryptfs/config_file.go b/cryptfs/config_file.go index a3f6ba3..74eb3b2 100644 --- a/cryptfs/config_file.go +++ b/cryptfs/config_file.go @@ -1,8 +1,8 @@ package cryptfs import ( - "io/ioutil" "encoding/json" + "io/ioutil" ) import "os" diff --git a/cryptfs/content_test.go b/cryptfs/content_test.go index 8f1d48b..ab48b21 100644 --- a/cryptfs/content_test.go +++ b/cryptfs/content_test.go @@ -1,8 +1,8 @@ package cryptfs import ( - "testing" "fmt" + "testing" ) type testRange struct { @@ -22,9 +22,9 @@ func TestSplitRange(t *testing.T) { key := make([]byte, 16) f := NewCryptFS(key, true) - for _, r := range(ranges) { + for _, r := range ranges { parts := f.SplitRange(r.offset, r.length) - for _, p := range(parts) { + for _, p := range parts { if p.Length > DEFAULT_PLAINBS || p.Skip >= DEFAULT_PLAINBS { fmt.Printf("Test fail: n=%d, length=%d, offset=%d\n", p.BlockNo, p.Length, p.Skip) t.Fail() @@ -45,15 +45,15 @@ func TestCiphertextRange(t *testing.T) { key := make([]byte, 16) f := NewCryptFS(key, true) - for _, r := range(ranges) { + for _, r := range ranges { alignedOffset, alignedLength, skipBytes := f.CiphertextRange(r.offset, r.length) if alignedLength < r.length { t.Fail() } - if alignedOffset % f.cipherBS != 0 { + if alignedOffset%f.cipherBS != 0 { t.Fail() } - if r.offset % f.plainBS != 0 && skipBytes == 0 { + if r.offset%f.plainBS != 0 && skipBytes == 0 { t.Fail() } } diff --git a/cryptfs/cryptfs.go b/cryptfs/cryptfs.go index 46f5b65..c58481c 100644 --- a/cryptfs/cryptfs.go +++ b/cryptfs/cryptfs.go @@ -3,23 +3,23 @@ package cryptfs // CryptFS is the crypto backend of GoCryptFS import ( - "fmt" - "crypto/cipher" "crypto/aes" + "crypto/cipher" + "fmt" ) const ( - KEY_LEN = 16 - NONCE_LEN = 12 - AUTH_TAG_LEN = 16 + KEY_LEN = 16 + NONCE_LEN = 12 + AUTH_TAG_LEN = 16 DEFAULT_PLAINBS = 4096 ) type CryptFS struct { blockCipher cipher.Block - gcm cipher.AEAD - plainBS uint64 - cipherBS uint64 + gcm cipher.AEAD + plainBS uint64 + cipherBS uint64 // Stores an all-zero block of size cipherBS allZeroBlock []byte } @@ -50,10 +50,10 @@ func NewCryptFS(key []byte, useOpenssl bool) *CryptFS { cipherBS := DEFAULT_PLAINBS + NONCE_LEN + AUTH_TAG_LEN return &CryptFS{ - blockCipher: b, - gcm: gcm, - plainBS: DEFAULT_PLAINBS, - cipherBS: uint64(cipherBS), + blockCipher: b, + gcm: gcm, + plainBS: DEFAULT_PLAINBS, + cipherBS: uint64(cipherBS), allZeroBlock: make([]byte, cipherBS), } } diff --git a/cryptfs/cryptfs_content.go b/cryptfs/cryptfs_content.go index 761fef5..6444b8b 100644 --- a/cryptfs/cryptfs_content.go +++ b/cryptfs/cryptfs_content.go @@ -4,11 +4,11 @@ package cryptfs import ( "bytes" - "os" - "errors" "crypto/cipher" "crypto/md5" "encoding/hex" + "errors" + "os" ) const ( @@ -25,7 +25,7 @@ func md5sum(buf []byte) string { type CryptFile struct { file *os.File - gcm cipher.AEAD + gcm cipher.AEAD } // DecryptBlocks - Decrypt a number of blocks @@ -113,7 +113,7 @@ func (be *CryptFS) SplitRange(offset uint64, length uint64) []intraBlock { for length > 0 { b.BlockNo = offset / be.plainBS b.Skip = offset % be.plainBS - b.Length = be.minu64(length, be.plainBS - b.Skip) + b.Length = be.minu64(length, be.plainBS-b.Skip) parts = append(parts, b) offset += b.Length length -= b.Length @@ -131,7 +131,7 @@ func (be *CryptFS) PlainSize(size uint64) uint64 { overhead := be.cipherBS - be.plainBS nBlocks := (size + be.cipherBS - 1) / be.cipherBS - if nBlocks * overhead > size { + if nBlocks*overhead > size { Warn.Printf("PlainSize: Negative size, returning 0 instead\n") return 0 } @@ -164,7 +164,7 @@ func (be *CryptFS) CiphertextRange(offset uint64, length uint64) (alignedOffset skip := offset % be.plainBS firstBlockNo := offset / be.plainBS - lastBlockNo := ( offset + length - 1 ) / be.plainBS + lastBlockNo := (offset + length - 1) / be.plainBS alignedOffset = firstBlockNo * be.cipherBS alignedLength = (lastBlockNo - firstBlockNo + 1) * be.cipherBS @@ -191,10 +191,10 @@ func (be *CryptFS) CropPlaintext(plaintext []byte, blocks []intraBlock) []byte { last := blocks[len(blocks)-1] length := (last.BlockNo - blocks[0].BlockNo + 1) * be.plainBS var cropped []byte - if offset + length > uint64(len(plaintext)) { + if offset+length > uint64(len(plaintext)) { cropped = plaintext[offset:len(plaintext)] } else { - cropped = plaintext[offset:offset+length] + cropped = plaintext[offset : offset+length] } return cropped } @@ -209,7 +209,7 @@ func (be *CryptFS) MergeBlocks(oldData []byte, newData []byte, offset int) []byt // Copy old and new data into it copy(out, oldData) l := len(newData) - copy(out[offset:offset + l], newData) + copy(out[offset:offset+l], newData) // Crop to length outLen := len(oldData) @@ -222,10 +222,10 @@ func (be *CryptFS) MergeBlocks(oldData []byte, newData []byte, offset int) []byt // Get the block number at plain-text offset func (be *CryptFS) BlockNoPlainOff(plainOffset uint64) uint64 { - return plainOffset / be.plainBS + return plainOffset / be.plainBS } // Get the block number at ciphter-text offset func (be *CryptFS) BlockNoCipherOff(cipherOffset uint64) uint64 { - return cipherOffset / be.cipherBS + return cipherOffset / be.cipherBS } diff --git a/cryptfs/cryptfs_names.go b/cryptfs/cryptfs_names.go index f694fa5..5476b17 100644 --- a/cryptfs/cryptfs_names.go +++ b/cryptfs/cryptfs_names.go @@ -3,12 +3,12 @@ package cryptfs // Filename encryption / decryption function import ( - "crypto/cipher" "crypto/aes" - "fmt" - "strings" + "crypto/cipher" "encoding/base64" "errors" + "fmt" + "strings" ) const ( @@ -30,7 +30,7 @@ func (be *CryptFS) decryptName(cipherName string) (string, error) { return "", err } - if len(bin) % aes.BlockSize != 0 { + if len(bin)%aes.BlockSize != 0 { return "", errors.New(fmt.Sprintf("Name len=%d is not a multiple of 16", len(bin))) } @@ -120,7 +120,7 @@ func (be *CryptFS) pad16(orig []byte) (padded []byte) { if oldLen == 0 { panic("Padding zero-length string makes no sense") } - padLen := aes.BlockSize - oldLen % aes.BlockSize + padLen := aes.BlockSize - oldLen%aes.BlockSize if padLen == 0 { padLen = aes.BlockSize } @@ -137,11 +137,11 @@ func (be *CryptFS) pad16(orig []byte) (padded []byte) { // unPad16 - remove padding func (be *CryptFS) unPad16(orig []byte) ([]byte, error) { oldLen := len(orig) - if oldLen % aes.BlockSize != 0 { + if oldLen%aes.BlockSize != 0 { return nil, errors.New("Unaligned size") } // The last byte is always a padding byte - padByte := orig[oldLen -1] + padByte := orig[oldLen-1] // The padding byte's value is the padding length padLen := int(padByte) // Padding must be at least 1 byte diff --git a/cryptfs/intrablock.go b/cryptfs/intrablock.go index 552cb3c..7f3a1eb 100644 --- a/cryptfs/intrablock.go +++ b/cryptfs/intrablock.go @@ -2,10 +2,10 @@ package cryptfs // intraBlock identifies a part of a file block type intraBlock struct { - BlockNo uint64 // Block number in file - Skip uint64 // Offset into block plaintext - Length uint64 // Length of data from this block - fs *CryptFS + BlockNo uint64 // Block number in file + Skip uint64 // Offset into block plaintext + Length uint64 // Length of data from this block + fs *CryptFS } // isPartial - is the block partial? This means we have to do read-modify-write. @@ -29,9 +29,9 @@ func (ib *intraBlock) PlaintextRange() (offset uint64, length uint64) { } // CropBlock - crop a potentially larger plaintext block down to the relevant part -func (ib *intraBlock) CropBlock(d []byte) []byte{ +func (ib *intraBlock) CropBlock(d []byte) []byte { lenHave := len(d) - lenWant := int(ib.Skip+ib.Length) + lenWant := int(ib.Skip + ib.Length) if lenHave < lenWant { return d[ib.Skip:lenHave] } diff --git a/cryptfs/kdf.go b/cryptfs/kdf.go index 275c72e..32870cd 100644 --- a/cryptfs/kdf.go +++ b/cryptfs/kdf.go @@ -12,10 +12,10 @@ const ( ) type scryptKdf struct { - Salt []byte - N int - R int - P int + Salt []byte + N int + R int + P int KeyLen int } diff --git a/cryptfs/names_test.go b/cryptfs/names_test.go index 7e20690..dd57242 100644 --- a/cryptfs/names_test.go +++ b/cryptfs/names_test.go @@ -1,8 +1,8 @@ package cryptfs import ( - "testing" "bytes" + "testing" ) func TestTranslatePath(t *testing.T) { @@ -14,7 +14,7 @@ func TestTranslatePath(t *testing.T) { key := make([]byte, 16) fs := NewCryptFS(key, true) - for _, n := range(s) { + for _, n := range s { c := fs.EncryptPath(n) d, err := fs.DecryptPath(c) if err != nil { @@ -36,13 +36,13 @@ func TestPad16(t *testing.T) { key := make([]byte, 16) fs := NewCryptFS(key, true) - for i := range(s) { + for i := range s { orig := s[i] padded := fs.pad16(orig) if len(padded) <= len(orig) { t.Errorf("Padded length not bigger than orig: %d", len(padded)) } - if len(padded) % 16 != 0 { + if len(padded)%16 != 0 { t.Errorf("Length is not aligend: %d", len(padded)) } unpadded, err := fs.unPad16(padded) @@ -52,7 +52,7 @@ func TestPad16(t *testing.T) { if len(unpadded) != len(orig) { t.Errorf("Size mismatch: orig=%d unpadded=%d", len(s[i]), len(unpadded)) } - if ! bytes.Equal(orig, unpadded) { + if !bytes.Equal(orig, unpadded) { t.Error("Content mismatch orig vs unpadded") } } diff --git a/cryptfs/nonce.go b/cryptfs/nonce.go index 3e464a3..80134c3 100644 --- a/cryptfs/nonce.go +++ b/cryptfs/nonce.go @@ -1,17 +1,17 @@ package cryptfs import ( + "crypto/rand" "encoding/binary" "encoding/hex" "sync" - "crypto/rand" ) type nonce96 struct { - lock sync.Mutex + lock sync.Mutex high32 uint32 - low64 uint64 - ready int + low64 uint64 + ready int } var gcmNonce nonce96 diff --git a/cryptfs/openssl_aead.go b/cryptfs/openssl_aead.go index 02f50d8..b743a3e 100644 --- a/cryptfs/openssl_aead.go +++ b/cryptfs/openssl_aead.go @@ -66,8 +66,8 @@ func (be opensslGCM) Open(dst, nonce, ciphertext, data []byte) ([]byte, error) { } l := len(ciphertext) - tag := ciphertext[l-AUTH_TAG_LEN:l] - ciphertext = ciphertext[0:l-AUTH_TAG_LEN] + tag := ciphertext[l-AUTH_TAG_LEN : l] + ciphertext = ciphertext[0 : l-AUTH_TAG_LEN] plainBuf := bytes.NewBuffer(dst) dctx, err := openssl.NewGCMDecryptionCipherCtx(128, nil, be.key[:], nonce[:]) diff --git a/main.go b/main.go index 35f83b6..5bd3cbb 100644 --- a/main.go +++ b/main.go @@ -1,18 +1,18 @@ package main import ( - "runtime/pprof" - "io/ioutil" + "encoding/hex" "flag" "fmt" + "io/ioutil" "os" "path/filepath" - "time" - "encoding/hex" "runtime" + "runtime/pprof" + "time" - "github.com/rfjakob/gocryptfs/pathfs_frontend" "github.com/rfjakob/gocryptfs/cryptfs" + "github.com/rfjakob/gocryptfs/pathfs_frontend" "golang.org/x/crypto/ssh/terminal" @@ -23,41 +23,41 @@ import ( const ( USE_CLUEFS = false // Use cluefs or pathfs FUSE frontend - USE_OPENSSL = true // 3x speed increase compared to Go's built-in GCM + USE_OPENSSL = true // 3x speed increase compared to Go's built-in GCM PATHFS_DEBUG = false PROGRAM_NAME = "gocryptfs" // Exit codes - ERREXIT_USAGE = 1 - ERREXIT_NEWFS = 2 - ERREXIT_MOUNT = 3 - ERREXIT_SERVE = 4 - ERREXIT_MOUNT2 = 5 + ERREXIT_USAGE = 1 + ERREXIT_NEWFS = 2 + ERREXIT_MOUNT = 3 + ERREXIT_SERVE = 4 + ERREXIT_MOUNT2 = 5 ERREXIT_CIPHERDIR = 6 - ERREXIT_INIT = 7 - ERREXIT_LOADCONF = 8 - ERREXIT_PASSWORD = 9 + ERREXIT_INIT = 7 + ERREXIT_LOADCONF = 8 + ERREXIT_PASSWORD = 9 ) func initDir(dirArg string) { - dir, _ := filepath.Abs(dirArg) + dir, _ := filepath.Abs(dirArg) - if dirEmpty(dir) == false { - fmt.Printf("Error: Directory \"%s\" is not empty\n", dirArg) - os.Exit(ERREXIT_INIT) - } + if dirEmpty(dir) == false { + fmt.Printf("Error: Directory \"%s\" is not empty\n", dirArg) + os.Exit(ERREXIT_INIT) + } - confName := filepath.Join(dir, cryptfs.ConfDefaultName) - fmt.Printf("Choose a password for protecting your files.\n") - password := readPasswordTwice() - err := cryptfs.CreateConfFile(confName, password) - if err != nil { - fmt.Println(err) - os.Exit(ERREXIT_INIT) - } - fmt.Printf("The filesystem is now ready for mounting.\n") - os.Exit(0) + confName := filepath.Join(dir, cryptfs.ConfDefaultName) + fmt.Printf("Choose a password for protecting your files.\n") + password := readPasswordTwice() + err := cryptfs.CreateConfFile(confName, password) + if err != nil { + fmt.Println(err) + os.Exit(ERREXIT_INIT) + } + fmt.Printf("The filesystem is now ready for mounting.\n") + os.Exit(0) } func main() { @@ -74,15 +74,15 @@ func main() { flag.Parse() if *cpuprofile != "" { - f, err := os.Create(*cpuprofile) - if err != nil { - fmt.Println(err) + f, err := os.Create(*cpuprofile) + if err != nil { + fmt.Println(err) os.Exit(ERREXIT_INIT) - } + } fmt.Printf("Writing CPU profile to %s\n", *cpuprofile) - pprof.StartCPUProfile(f) - defer pprof.StopCPUProfile() - } + pprof.StartCPUProfile(f) + defer pprof.StopCPUProfile() + } if debug { cryptfs.Debug.Enable() cryptfs.Debug.Printf("Debug output enabled\n") @@ -206,9 +206,9 @@ func pathfsFrontend(key []byte, cipherdir string, mountpoint string, debug bool) mOpts.AllowOther = false // Set values shown in "df -T" and friends // First column, "Filesystem" - mOpts.Options = append(mOpts.Options, "fsname=" + cipherdir) + mOpts.Options = append(mOpts.Options, "fsname="+cipherdir) // Second column, "Type", will be shown as "fuse." + Name - mOpts.Name="gocryptfs" + mOpts.Name = "gocryptfs" state, err := fuse.NewServer(conn.RawFS(), mountpoint, &mOpts) if err != nil { diff --git a/main_test.go b/main_test.go index dba3ef1..de433c7 100644 --- a/main_test.go +++ b/main_test.go @@ -227,12 +227,12 @@ func BenchmarkStreamRead(t *testing.B) { if t.N > mb { // Grow file so we can satisfy the test fmt.Printf("Growing file to %d MB... ", t.N) - f2, err := os.OpenFile(fn, os.O_WRONLY | os.O_APPEND, 0666) + f2, err := os.OpenFile(fn, os.O_WRONLY|os.O_APPEND, 0666) if err != nil { fmt.Println(err) t.FailNow() } - for h := 0; h < t.N - mb ; h++ { + for h := 0; h < t.N-mb; h++ { _, err = f2.Write(buf) if err != nil { fmt.Println(err) diff --git a/openssl_benchmark/openssl_test.go b/openssl_benchmark/openssl_test.go index f0b7bc5..e80410f 100644 --- a/openssl_benchmark/openssl_test.go +++ b/openssl_benchmark/openssl_test.go @@ -7,10 +7,10 @@ package benchmark import ( "bytes" - "testing" - "github.com/spacemonkeygo/openssl" "crypto/aes" "crypto/cipher" + "github.com/spacemonkeygo/openssl" + "testing" ) func BenchmarkAESGCMSeal4K(b *testing.B) { @@ -86,7 +86,7 @@ func BenchmarkOpensslGCMenc4K(b *testing.B) { func BenchmarkOpensslGCMdec4K(b *testing.B) { buf := makeOpensslCiphertext() - b.SetBytes(int64(1024*4)) + b.SetBytes(int64(1024 * 4)) tag := buf[4096:] buf = buf[0:4096] diff --git a/pathfs_frontend/file.go b/pathfs_frontend/file.go index cc8de17..43114b2 100644 --- a/pathfs_frontend/file.go +++ b/pathfs_frontend/file.go @@ -1,9 +1,9 @@ package pathfs_frontend import ( - "io" "bytes" "fmt" + "io" "os" "sync" "syscall" @@ -40,10 +40,10 @@ func NewFile(fd *os.File, writeOnly bool, cfs *cryptfs.CryptFS) nodefs.File { syscall.Fstat(int(fd.Fd()), &st) return &file{ - fd: fd, + fd: fd, writeOnly: writeOnly, - cfs: cfs, - ino: st.Ino, + cfs: cfs, + ino: st.Ino, } } @@ -101,7 +101,7 @@ func (f *file) doRead(off uint64, length uint64) ([]byte, fuse.Status) { lenHave := len(plaintext) lenWant := skip + int(length) if lenHave > lenWant { - out = plaintext[skip:skip + int(length)] + out = plaintext[skip : skip+int(length)] } else if lenHave > skip { out = plaintext[skip:lenHave] } else { @@ -139,7 +139,7 @@ func (f *file) doWrite(data []byte, off int64) (uint32, fuse.Status) { status := fuse.OK dataBuf := bytes.NewBuffer(data) blocks := f.cfs.SplitRange(uint64(off), uint64(len(data))) - for _, b := range(blocks) { + for _, b := range blocks { blockData := dataBuf.Next(int(b.Length)) @@ -180,7 +180,7 @@ func (f *file) doWrite(data []byte, off int64) (uint32, fuse.Status) { // Write - FUSE call func (f *file) Write(data []byte, off int64) (uint32, fuse.Status) { - cryptfs.Debug.Printf("ino%d: FUSE Write %s: offset=%d length=%d\n", f.ino, off, len(data)) + cryptfs.Debug.Printf("ino%d: FUSE Write: offset=%d length=%d\n", f.ino, off, len(data)) fi, err := f.fd.Stat() if err != nil { @@ -248,8 +248,8 @@ func (f *file) Truncate(newSize uint64) fuse.Status { // File grows if newSize > oldSize { - blocks := f.cfs.SplitRange(oldSize, newSize - oldSize) - for _, b := range(blocks) { + blocks := f.cfs.SplitRange(oldSize, newSize-oldSize) + for _, b := range blocks { // First and last block may be partial if b.IsPartial() { off, _ := b.PlaintextRange() @@ -261,7 +261,7 @@ func (f *file) Truncate(newSize uint64) fuse.Status { } else { off, length := b.CiphertextRange() f.lock.Lock() - err := syscall.Ftruncate(int(f.fd.Fd()), int64(off + length)) + err := syscall.Ftruncate(int(f.fd.Fd()), int64(off+length)) f.lock.Unlock() if err != nil { cryptfs.Warn.Printf("grow Ftruncate returned error: %v", err) @@ -270,7 +270,7 @@ func (f *file) Truncate(newSize uint64) fuse.Status { } } return fuse.OK - // File shrinks + // File shrinks } else { blockNo := f.cfs.BlockNoPlainOff(newSize) lastBlockOff := blockNo * f.cfs.PlainBS() diff --git a/pathfs_frontend/fs.go b/pathfs_frontend/fs.go index 247b69e..ba46309 100644 --- a/pathfs_frontend/fs.go +++ b/pathfs_frontend/fs.go @@ -1,10 +1,10 @@ package pathfs_frontend import ( + "fmt" "os" "path/filepath" "time" - "fmt" "github.com/hanwen/go-fuse/fuse" "github.com/hanwen/go-fuse/fuse/nodefs" @@ -14,17 +14,16 @@ import ( type FS struct { *cryptfs.CryptFS - pathfs.FileSystem // loopbackFileSystem - backing string // Backing directory + pathfs.FileSystem // loopbackFileSystem + backing string // Backing directory } // Encrypted FUSE overlay filesystem func NewFS(key []byte, backing string, useOpenssl bool) *FS { return &FS{ - CryptFS: cryptfs.NewCryptFS(key, useOpenssl), - FileSystem: pathfs.NewLoopbackFileSystem(backing), - backing: backing, - + CryptFS: cryptfs.NewCryptFS(key, useOpenssl), + FileSystem: pathfs.NewLoopbackFileSystem(backing), + backing: backing, } } @@ -52,7 +51,7 @@ func (fs *FS) GetAttr(name string, context *fuse.Context) (*fuse.Attr, fuse.Stat func (fs *FS) OpenDir(dirName string, context *fuse.Context) ([]fuse.DirEntry, fuse.Status) { cryptfs.Debug.Printf("OpenDir(%s)\n", dirName) - cipherEntries, status := fs.FileSystem.OpenDir(fs.EncryptPath(dirName), context); + cipherEntries, status := fs.FileSystem.OpenDir(fs.EncryptPath(dirName), context) var plain []fuse.DirEntry if cipherEntries != nil { for i := range cipherEntries { @@ -76,7 +75,7 @@ func (fs *FS) OpenDir(dirName string, context *fuse.Context) ([]fuse.DirEntry, f // We always need read access to do read-modify-write cycles func (fs *FS) mangleOpenFlags(flags uint32) (newFlags int, writeOnly bool) { newFlags = int(flags) - if newFlags & os.O_WRONLY > 0 { + if newFlags&os.O_WRONLY > 0 { writeOnly = true newFlags = newFlags ^ os.O_WRONLY | os.O_RDWR }