feat: works now

encfs/file.go

@@ -4,7 +4,6 @@ import (
 	"crypto/aes"
 	"crypto/rand"
 	"encoding/binary"
-	"encoding/hex"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -29,9 +28,14 @@ type EncFileMeta struct {
 	Iv   []byte `json:"iv"`
 }
 
-func newEncFileMeta(name string) (*EncFileMeta, error) {
+func openOrNewEncFileMeta(name string) (*EncFileMeta, error) {
+	oldEncFileMeta, err := openEncFileMeta(name)
+	if err == nil && oldEncFileMeta != nil {
+		return oldEncFileMeta, nil
+	}
+
 	iv := make([]byte, 16)
-	_, err := rand.Read(iv)
+	_, err = rand.Read(iv)
 	if err != nil {
 		return nil, err
 	}
@@ -112,7 +116,7 @@ func NewEncFile(name string, file *os.File, encFs *EncFs, isCreate bool) (*EncFi
 	var encFileMeta *EncFileMeta = nil
 	if !isDir {
 		if isCreate {
-			encFileMeta, err = newEncFileMeta(name)
+			encFileMeta, err = openOrNewEncFileMeta(name)
 		} else {
 			encFileMeta, err = openEncFileMeta(name)
 		}
@@ -168,8 +172,19 @@ func (f *EncFile) ReadAt(p []byte, off int64) (n int, err error) {
 		return 0, checkIsFileErr
 	}
 
-	// TODO decrypt
-	return f.file.ReadAt(p, off)
+	readLen, err := f.file.ReadAt(p, off)
+	if err == nil {
+		if f.encFs != nil && f.encFs.key != nil && f.encFileMeta != nil {
+			encryptedBytes, err := generateCtrEncryptBytes(f.encFs.key, f.encFileMeta.Iv, off, int64(readLen))
+			if err != nil {
+				return 0, err
+			}
+			for i := 0; i < readLen; i++ {
+				p[i] = p[i] ^ encryptedBytes[i]
+			}
+		}
+	}
+	return readLen, err
 }
 
 func (f *EncFile) Seek(offset int64, whence int) (int64, error) {
@@ -184,7 +199,7 @@ func (f *EncFile) Seek(offset int64, whence int) (int64, error) {
 	}
 
 	ret, err := f.file.Seek(offset, whence)
-	if err != nil {
+	if err == nil {
 		f.filePos = offset
 	}
 	return ret, err
@@ -236,9 +251,6 @@ func (f *EncFile) WriteAt(p []byte, off int64) (n int, err error) {
 	}
 
 	writeLen, err := f.file.WriteAt(writeBuff, off)
-	// if err == nil {
-	// 	f.filePos += int64(writeLen)
-	// }
 	return writeLen, err
 }
 
@@ -301,8 +313,7 @@ func (f *EncFile) Truncate(size int64) error {
 }
 
 func (f *EncFile) WriteString(s string) (ret int, err error) {
-	// TODO encrypt
-	return f.file.WriteString(s)
+	return f.Write([]byte(s))
 }
 
 func (f *EncFile) checkIsFile() error {
@@ -317,7 +328,8 @@ func (f *EncFile) checkIsFile() error {
 
 func generateCtrEncryptBytes(key, iv []byte, offset, len int64) ([]byte, error) {
 	endOffset := offset + len
-	encryptStartOffset := (offset / 16) * 16
+	blockOffset := offset / 16
+	encryptStartOffset := blockOffset * 16
 	encryptEndOffset := (endOffset / 16) * 16
 	if endOffset%16 > 0 {
 		encryptEndOffset += 16
@@ -330,12 +342,11 @@ func generateCtrEncryptBytes(key, iv []byte, offset, len int64) ([]byte, error)
 	}
 	encryptBytes := make([]byte, blocksCount*16)
 	for i := 0; i < blocksCount; i++ {
-		encNonce := nonceAdd(iv, uint64(i))
+		encNonce := nonceAdd(iv, uint64(i)+uint64(blockOffset))
 		cipher.Encrypt(encryptBytes[i*16:(i+1)*16], encNonce)
 	}
-	// fmt.Println("XX ", hex.EncodeToString(encryptBytes))
 	encryptedBytes := encryptBytes[offset-encryptStartOffset : offset-encryptStartOffset+len]
-	fmt.Println("XX", hex.EncodeToString(key), hex.EncodeToString(iv), offset, len, hex.EncodeToString(encryptedBytes))
+	//fmt.Println("XX", hex.EncodeToString(key), hex.EncodeToString(iv), offset, len, hex.EncodeToString(encryptedBytes))
 	return encryptedBytes, nil
 }
 

go.mod

@@ -2,7 +2,6 @@ module git.hatter.ink/hatter/go-afero-encfs
 
 go 1.23.0
 
-require (
-	github.com/spf13/afero v1.11.0 // indirect
-	golang.org/x/text v0.14.0 // indirect
-)
+require github.com/spf13/afero v1.11.0
+
+require golang.org/x/text v0.14.0 // indirect

main.go

@@ -17,8 +17,6 @@ func main() {
 	encFs := encfs.NewEncFs(key)
 	encFs2 := encfs.NewEncFs(nil)
 
-	write := false
-
 	// -----------------------------------------------------------------------------------------------------------------------------------
 	encFile1, err := encFs2.Create("test1")
 	if err != nil {
@@ -27,6 +25,8 @@ func main() {
 	}
 	encFile1.Write([]byte("hello world"))
 	encFile1.Write([]byte("XXXXXXXXXXXXXXXXXXXXXXXXXXXXX"))
+	encFile1.WriteAt([]byte("TEST"), 10)
+	encFile1.Write([]byte("------"))
 	encFile1.Close()
 
 	encFile2, err := encFs2.Create("test2")
@@ -35,36 +35,32 @@ func main() {
 		return
 	}
 	encFile2.Write([]byte("hello world"))
-	// 0 move
-	// 1, 2 append 00
-	// 3 no effect
-	seekI, err := encFile2.Seek(2, 3)
+	seekI, err := encFile2.Seek(2, 0)
 	fmt.Println(seekI, ", ", err)
 	encFile2.Write([]byte("XXXXXXXXXXXXXXXXXXXXXXXXXXXXX"))
+	encFile2.Write([]byte("------"))
 	encFile2.Close()
 
 	// -----------------------------------------------------------------------------------------------------------------------------------
 
-	if write {
+	func() {
 		encFile, err := encFs.Create("test")
 		if err != nil {
 			fmt.Println(err)
 			return
 		}
+		defer encFile.Close()
 
 		encFile.Write([]byte("hello world"))
-
-		// seekI, err := encFile.Seek(1, 1)
-		// fmt.Println(seekI, ", ", err)
-
 		encFile.Write([]byte("XXXXXXXXXXXXXXXXXXXXXXXXXXXXX"))
+		encFile.WriteAt([]byte("TEST"), 10)
+		encFile.Write([]byte("------"))
 
-		// encFile.WriteAt([]byte("YYYYYYYYYYYYYYYYYYYYYYYY"), 1)
-
-		// encFile.Write([]byte("Z"))
-		// encFile.Write([]byte("---------------------------------------"))
-		// encFile.Write([]byte("Z"))
-	} else {
+		encFile.Write([]byte("Z"))
+		encFile.Write([]byte("---------------------------------------"))
+		encFile.Write([]byte("Z"))
+	}()
+	func() {
 		encFile, err := encFs.Open("test")
 		if err != nil {
 			fmt.Println(err)
@@ -75,5 +71,13 @@ func main() {
 		fmt.Println(hex.EncodeToString(rr))
 		fmt.Println(string(rr), err)
 
-	}
+		buff := make([]byte, 5)
+		readLen, err := encFile.ReadAt(buff, 3)
+		fmt.Println(readLen, err)
+		fmt.Println(string(buff))
+
+		readLen, err = encFile.Read(buff)
+		fmt.Println(readLen, err)
+		fmt.Println(string(buff))
+	}()
 }