119 lines
3.2 KiB
Go
119 lines
3.2 KiB
Go
package fusefrontend_reverse
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
|
|
"github.com/hanwen/go-fuse/fuse"
|
|
"github.com/hanwen/go-fuse/fuse/nodefs"
|
|
|
|
"github.com/rfjakob/gocryptfs/internal/contentenc"
|
|
"github.com/rfjakob/gocryptfs/internal/tlog"
|
|
)
|
|
|
|
// File header that contains an all-zero File ID
|
|
var zeroFileHeader *contentenc.FileHeader
|
|
|
|
func init() {
|
|
zeroFileHeader = contentenc.RandomHeader()
|
|
zeroFileHeader.Id = make([]byte, contentenc.HEADER_ID_LEN)
|
|
}
|
|
|
|
type reverseFile struct {
|
|
// Embed nodefs.defaultFile for a ENOSYS implementation of all methods
|
|
nodefs.File
|
|
// Backing FD
|
|
fd *os.File
|
|
// Content encryption helper
|
|
contentEnc *contentenc.ContentEnc
|
|
}
|
|
|
|
func NewFile(fd *os.File, contentEnc *contentenc.ContentEnc) (nodefs.File, fuse.Status) {
|
|
return &reverseFile{
|
|
File: nodefs.NewDefaultFile(),
|
|
fd: fd,
|
|
contentEnc: contentEnc,
|
|
}, fuse.OK
|
|
}
|
|
|
|
// GetAttr - FUSE call
|
|
func (rf *reverseFile) GetAttr(*fuse.Attr) fuse.Status {
|
|
fmt.Printf("reverseFile.GetAttr fd=%d\n", rf.fd.Fd())
|
|
return fuse.ENOSYS
|
|
}
|
|
|
|
// readFile - read from the backing plaintext file, encrypt it, return the
|
|
// ciphertext.
|
|
// "off" ... ciphertext offset (must be >= HEADER_LEN)
|
|
// "length" ... ciphertext length
|
|
func (rf *reverseFile) readFile(off uint64, length uint64) (out []byte, err error) {
|
|
blocks := rf.contentEnc.ExplodeCipherRange(off, length)
|
|
|
|
// Read the backing plaintext in one go
|
|
alignedOffset, alignedLength := contentenc.JointPlaintextRange(blocks)
|
|
tlog.Warn.Printf("alignedOffset=%d, alignedLength=%d\n", alignedOffset, alignedLength)
|
|
plaintext := make([]byte, int(alignedLength))
|
|
n, err := rf.fd.ReadAt(plaintext, int64(alignedOffset))
|
|
if err != nil && err != io.EOF {
|
|
tlog.Warn.Printf("reverseFile.readFile: ReadAt: %s", err.Error())
|
|
return nil, err
|
|
}
|
|
// Truncate buffer down to actually read bytes
|
|
plaintext = plaintext[0:n]
|
|
|
|
// Encrypt blocks
|
|
ciphertext := rf.contentEnc.EncryptBlocks(plaintext, blocks[0].BlockNo, zeroFileHeader.Id)
|
|
|
|
// Crop down to the relevant part
|
|
lenHave := len(ciphertext)
|
|
skip := blocks[0].Skip
|
|
endWant := int(skip + length)
|
|
if lenHave > endWant {
|
|
out = ciphertext[skip:endWant]
|
|
} else if lenHave > int(skip) {
|
|
out = ciphertext[skip:lenHave]
|
|
} // else: out stays empty, file was smaller than the requested offset
|
|
|
|
return out, nil
|
|
}
|
|
|
|
// Read - FUSE call
|
|
func (rf *reverseFile) Read(buf []byte, ioff int64) (resultData fuse.ReadResult, status fuse.Status) {
|
|
length := uint64(len(buf))
|
|
off := uint64(ioff)
|
|
var out bytes.Buffer
|
|
var headerPart []byte
|
|
|
|
// Create a virtual file header
|
|
if off < contentenc.HEADER_LEN {
|
|
headerPart = zeroFileHeader.Pack()
|
|
headerPart = headerPart[off:]
|
|
if off+length < contentenc.HEADER_LEN {
|
|
headerPart = headerPart[:length]
|
|
}
|
|
}
|
|
out.Write(headerPart)
|
|
hLen := uint64(len(headerPart))
|
|
off += hLen
|
|
length -= hLen
|
|
|
|
// Read actual file data
|
|
if length > 0 {
|
|
fileData, err := rf.readFile(off, length)
|
|
if err != nil {
|
|
return nil, fuse.ToStatus(err)
|
|
}
|
|
if len(fileData) == 0 {
|
|
// If we could not read any actual data, we also don't want to
|
|
// return the file header. An empty file stays empty in encrypted
|
|
// form.
|
|
return nil, fuse.OK
|
|
}
|
|
out.Write(fileData)
|
|
}
|
|
|
|
return fuse.ReadResultData(out.Bytes()), fuse.OK
|
|
}
|