Browse Source

add:文件加密

master
刘子旺 6 months ago
parent
commit
70fb1255d4
  1. 10
      go.mod
  2. 12
      go.sum
  3. 2
      godo/cmd/main.go
  4. 2
      godo/cmd/serve.go
  5. 120
      godo/files/fs.go
  6. 74
      godo/files/os.go
  7. 219
      godo/files/pwdfile.go
  8. 61
      godo/files/pwdfile_test.go

10
go.mod

@ -1,6 +1,8 @@
module godoos
go 1.22.5
go 1.23
toolchain go1.23.2
require github.com/wailsapp/wails/v2 v2.9.1
@ -40,11 +42,11 @@ require (
github.com/wailsapp/go-webview2 v1.0.10 // indirect
github.com/wailsapp/mimetype v1.4.1 // indirect
godo v0.0.1
golang.org/x/crypto v0.23.0 // indirect
golang.org/x/crypto v0.29.0 // indirect
golang.org/x/exp v0.0.0-20230522175609-2e198f4a06a1 // indirect
golang.org/x/net v0.25.0 // indirect
golang.org/x/sys v0.22.0 // indirect
golang.org/x/text v0.15.0 // indirect
golang.org/x/sys v0.27.0 // indirect
golang.org/x/text v0.20.0 // indirect
)
replace godo v0.0.1 => ./godo

12
go.sum

@ -84,8 +84,8 @@ github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQ
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
golang.org/x/crypto v0.0.0-20211209193657-4570a0811e8b/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
golang.org/x/crypto v0.23.0 h1:dIJU/v2J8Mdglj/8rJ6UUOM3Zc9zLZxVZwwxMooUSAI=
golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
golang.org/x/crypto v0.29.0 h1:L5SG1JTTXupVV3n6sUqMTeWbjAyfPwoda2DLX8J8FrQ=
golang.org/x/crypto v0.29.0/go.mod h1:+F4F4N5hv6v38hfeYwTdx20oUvLLc+QfrE9Ax9HtgRg=
golang.org/x/exp v0.0.0-20230522175609-2e198f4a06a1 h1:k/i9J1pBpvlfR+9QsetwPyERsqu1GIbi967PQMq3Ivc=
golang.org/x/exp v0.0.0-20230522175609-2e198f4a06a1/go.mod h1:V1LtkGg67GoY2N1AnLN78QLrzxkLyJw7RJb1gzOOz9w=
golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
@ -107,14 +107,14 @@ golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBc
golang.org/x/sys v0.0.0-20211103235746-7861aae1554b/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.22.0 h1:RI27ohtqKCnwULzJLqkv897zojh5/DwS/ENaMzUOaWI=
golang.org/x/sys v0.22.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/sys v0.27.0 h1:wBqf8DvsY9Y/2P8gAfPDEYNuS30J4lPHJxXSb/nJZ+s=
golang.org/x/sys v0.27.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.15.0 h1:h1V/4gjBv8v9cjcR6+AR5+/cIYK5N/WAgiv4xlsEtAk=
golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
golang.org/x/text v0.20.0 h1:gK/Kv2otX8gz+wn7Rmb3vT96ZwuoxnQlY+HlJVj7Qug=
golang.org/x/text v0.20.0/go.mod h1:D4IsuqiFMhST5bX19pQ9ikHC2GsaKyk/oF+pn3ducp4=
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

2
godo/cmd/main.go

@ -98,8 +98,6 @@ func OsStart() {
fileRouter.HandleFunc("/unzip", files.HandleUnZip).Methods(http.MethodGet)
fileRouter.HandleFunc("/watch", files.WatchHandler).Methods(http.MethodGet)
fileRouter.HandleFunc("/setfilepwd", files.HandleSetFilePwd).Methods(http.MethodGet)
fileRouter.HandleFunc("/changefilepwd", files.HandleChangeFilePwd).Methods(http.MethodGet)
fileRouter.HandleFunc("/changeispwd", files.HandleSetIsPwd).Methods(http.MethodGet)
localchatRouter := router.PathPrefix("/localchat").Subrouter()
localchatRouter.HandleFunc("/message", localchat.HandleMessage).Methods(http.MethodPost)

2
godo/cmd/serve.go

@ -81,7 +81,7 @@ func (l loggingMiddleware) Middleware(next http.Handler) http.Handler {
// CORS 中间件
func corsMiddleware() mux.MiddlewareFunc {
allowHeaders := "Content-Type, Accept, Authorization, Origin,Pwd,Salt"
allowHeaders := "Content-Type, Accept, Authorization, Origin,Pwd"
allowMethods := "GET, POST, PUT, DELETE, OPTIONS"
return func(next http.Handler) http.Handler {

120
godo/files/fs.go

@ -82,8 +82,8 @@ func HandleReadDir(w http.ResponseWriter, r *http.Request) {
libs.HTTPError(w, http.StatusInternalServerError, fmt.Sprintf("Failed to read file content: %v", err))
return
}
osFileInfo.IsPwd = IsPwdFile(content)
osFileInfo.Content = string(content)
osFileInfo.IsPwd = IsHaveHiddenFile(basePath, osFileInfo.Path)
// 检查文件内容是否以"link::"开头
if strings.HasPrefix(osFileInfo.Content, "link::") {
osFileInfo.IsSymlink = true
@ -124,7 +124,29 @@ func HandleStat(w http.ResponseWriter, r *http.Request) {
libs.HTTPError(w, http.StatusNotFound, err.Error())
return
}
osFileInfo.IsPwd = IsHaveHiddenFile(basePath, osFileInfo.Path)
// 是否为加密文件
file, err := os.Open(filepath.Join(basePath, path))
if err != nil {
libs.HTTPError(w, http.StatusInternalServerError, err.Error())
return
}
buffer := make([]byte, 34)
_, err = file.Read(buffer)
if err != nil {
if err == io.EOF {
// EOF说明文件大小小于34字节
osFileInfo.IsPwd = false
res := libs.APIResponse{
Message: "File information retrieved successfully.",
Data: osFileInfo,
}
json.NewEncoder(w).Encode(res)
return
}
libs.HTTPError(w, http.StatusInternalServerError, err.Error())
return
}
osFileInfo.IsPwd = IsPwdFile(buffer)
res := libs.APIResponse{
Message: "File information retrieved successfully.",
Data: osFileInfo,
@ -231,15 +253,6 @@ func HandleRename(w http.ResponseWriter, r *http.Request) {
libs.HTTPError(w, http.StatusConflict, err.Error())
return
}
// 如果是一个加密文件,则隐藏文件的名字也要改
if IsHaveHiddenFile(basePath, oldPath) {
oldHiddenFilePath := filepath.Join(basePath, filepath.Dir(oldPath), "."+filepath.Base(oldPath))
newHiddenFilePath := filepath.Join(basePath, filepath.Dir(newPath), "."+filepath.Base(newPath))
err = os.Rename(oldHiddenFilePath, newHiddenFilePath)
if err != nil {
log.Printf("Error renaming hidden file: %s", err.Error())
}
}
err = CheckAddDesktop(newPath)
if err != nil {
log.Printf("Error adding file to desktop: %s", err.Error())
@ -320,95 +333,10 @@ func HandleCopyFile(w http.ResponseWriter, r *http.Request) {
if err != nil {
log.Printf("Error adding file to desktop: %s", err.Error())
}
// 如果是一个复制的加密文件,则隐藏的文件也要复制过去
if IsHaveHiddenFile(basePath, srcPath) {
hiddenSrcPath := filepath.Join(basePath, filepath.Dir(srcPath), "."+filepath.Base(srcPath))
hiddenDstPath := filepath.Join(basePath, filepath.Dir(dstPath), "."+filepath.Base(dstPath))
if err := CopyFile(hiddenSrcPath, hiddenDstPath); err != nil {
libs.HTTPError(w, http.StatusInternalServerError, err.Error())
return
}
}
res := libs.APIResponse{Message: fmt.Sprintf("File '%s' successfully copied to '%s'.", srcPath, dstPath)}
json.NewEncoder(w).Encode(res)
}
// 带加密写
func HandleWriteFile(w http.ResponseWriter, r *http.Request) {
filePath := r.URL.Query().Get("path")
basePath, err := libs.GetOsDir()
if err != nil {
libs.HTTPError(w, http.StatusInternalServerError, err.Error())
return
}
// 获取文件内容
fileContent, _, err := r.FormFile("content")
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
defer fileContent.Close()
filedata, err := io.ReadAll(fileContent)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
// 创建文件
file, err := os.Create(filepath.Join(basePath, filePath))
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
defer file.Close()
// 内容为空直接返回
if len(filedata) == 0 {
CheckAddDesktop(filePath)
libs.SuccessMsg(w, "", "success")
return
}
// 判读是否加密
ispwd, err := GetPwdFlag()
if err != nil {
libs.HTTPError(w, http.StatusInternalServerError, err.Error())
return
}
// 没有加密写入明文
if !ispwd {
if _, err := file.Write(filedata); err != nil {
libs.HTTPError(w, http.StatusInternalServerError, err.Error())
return
}
CheckAddDesktop(filePath)
libs.SuccessMsg(w, "", "success")
return
}
// 加密
data, err := libs.EncryptData(filedata, libs.EncryptionKey)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
_, err = file.Write(data)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
// 加密文件在同级目录下创建一个同名隐藏文件
hiddenFilePath := filepath.Join(basePath, filepath.Dir(filePath), "."+filepath.Base(filePath))
_, err = os.Create(hiddenFilePath)
if err != nil {
libs.ErrorMsg(w, "创建隐藏文件失败")
}
// 判断下是否添加到桌面上
CheckAddDesktop(filePath)
libs.SuccessMsg(w, "", "success")
}
// HandleAppendFile appends content to a file
func HandleAppendFile(w http.ResponseWriter, r *http.Request) {
filePath := r.URL.Query().Get("filePath")

74
godo/files/os.go

@ -23,8 +23,6 @@ import (
"godo/libs"
"io"
"io/fs"
"log/slog"
"net/http"
"os"
"path/filepath"
"strings"
@ -332,75 +330,11 @@ func CheckDeleteDesktop(filePath string) error {
}
return nil
}
// 校验文件密码
func CheckFilePwd(fpwd, salt string) bool {
// 1. 对输入的密码进行哈希
pwd := libs.HashPassword(fpwd, salt)
// 2. 获取存储的密码哈希
oldPwd, isHas := libs.GetConfig("filePwd")
if !isHas {
slog.Error("文件密码获取失败")
func IsPwdFile(fileData []byte) bool {
if len(fileData) < 34 {
return false
}
// 3. 比对密码哈希
return oldPwd == pwd
}
func IsHavePwd(pwd string) bool {
if len(pwd) > 0 {
return true
} else {
} else if fileData[0] != '@' || fileData[33] != '@' {
return false
}
}
// salt值优先从server端获取,如果没有则从header获取
func GetSalt(r *http.Request) (string, error) {
data, ishas := libs.GetConfig("salt")
if ishas {
// 断言成功则返回
if salt, ok := data.(string); ok {
return salt, nil
}
return "", fmt.Errorf("类型断言失败,期望类型为 string")
}
salt := r.Header.Get("salt")
if salt != "" {
return salt, nil
}
return "", fmt.Errorf("无法获取salt")
}
// 该函数用于获取文件是否加密的标志
func GetPwdFlag() (bool, error) {
// 从配置中获取加密标志
isPwd, has := libs.GetConfig("isPwd")
if !has {
// 如果没有设置加密标志,默认设置为不加密
err := libs.SetConfigByName("isPwd", false)
if err != nil {
return false, err // 返回错误信息
}
return false, nil // 返回默认值和无错误
}
// 尝试将获取的值转换为布尔类型
if pwdFlag, ok := isPwd.(bool); ok {
return pwdFlag, nil // 返回加密标志和无错误
}
// 如果类型断言失败,返回默认值和错误信息
return false, fmt.Errorf("类型断言失败,期望类型为 bool")
}
// 检查文件是否加密
func IsHaveHiddenFile(basePath, filePath string) bool {
// 通过查找同名隐藏文件判断
// 获取文件名和目录
dir := filepath.Dir(filePath)
fileName := filepath.Base(filePath)
hiddenFilePath := filepath.Join(basePath, dir, "."+fileName)
_, err := os.Stat(hiddenFilePath)
return err == nil
return true
}

219
godo/files/pwdfile.go

@ -3,139 +3,188 @@ package files
import (
"encoding/base64"
"encoding/json"
"fmt"
"godo/libs"
"io"
"log"
"net/http"
"strconv"
"os"
"path/filepath"
"strings"
)
func HandleReadFile(w http.ResponseWriter, r *http.Request) {
// 初始值
func HandleWriteFile(w http.ResponseWriter, r *http.Request) {
path := r.URL.Query().Get("path")
if err := validateFilePath(path); err != nil {
libs.HTTPError(w, http.StatusBadRequest, err.Error())
return
}
basePath, err := libs.GetOsDir()
if err != nil {
libs.HTTPError(w, http.StatusInternalServerError, err.Error())
return
}
// 非加密文件直接返回base64编码
isHide := IsHaveHiddenFile(basePath, path)
//Liuziwang888!@#
if !isHide {
fileContent, err := ReadFile(basePath, path)
if err != nil {
libs.HTTPError(w, http.StatusNotFound, err.Error())
return
}
data := string(fileContent)
if !strings.HasPrefix(data, "link::") {
data = base64.StdEncoding.EncodeToString(fileContent)
}
resp := libs.APIResponse{Message: "success", Data: data}
json.NewEncoder(w).Encode(resp)
fullFilePath := filepath.Join(basePath, path)
newFile, err := os.Create(fullFilePath)
if err != nil {
libs.HTTPError(w, http.StatusInternalServerError, err.Error())
return
}
// 有隐藏文件说明这是一个加密过的文件,需要验证密码
fPwd := r.Header.Get("pwd")
if fPwd == "" {
libs.HTTPError(w, http.StatusBadRequest, "密码不能为空")
defer newFile.Close()
// 获取文件内容
fileContent, _, err := r.FormFile("content")
if err != nil {
libs.HTTPError(w, http.StatusBadRequest, err.Error())
return
}
salt, err := GetSalt(r)
defer fileContent.Close()
fileData, err := io.ReadAll(fileContent)
fmt.Println("表单数据为:", string(fileData))
if err != nil {
libs.HTTPError(w, http.StatusInternalServerError, err.Error())
return
}
if !CheckFilePwd(fPwd, salt) {
libs.HTTPError(w, http.StatusBadRequest, "密码错误")
configPwd, ishas := libs.GetConfig("filePwd")
configPwdStr, ok := configPwd.(string)
if !ok {
libs.HTTPError(w, http.StatusInternalServerError, "配置文件密码格式错误")
return
}
// 密码正确则读取内容并解密
fileContent, err := ReadFile(basePath, path)
if !ishas {
// 没开启加密,直接明文写入
_, err := newFile.Write(fileData)
if err != nil {
libs.HTTPError(w, http.StatusInternalServerError, "数据写入失败")
return
}
err = CheckAddDesktop(path)
if err != nil {
log.Printf("Error adding file to desktop: %s", err.Error())
}
libs.SuccessMsg(w, "", "文件写入成功")
return
}
// 开启加密后,写入加密数据
_, err = newFile.WriteString(fmt.Sprintf("@%s@", configPwdStr))
if err != nil {
libs.HTTPError(w, http.StatusNotFound, err.Error())
libs.HTTPError(w, http.StatusInternalServerError, "密码写入失败")
return
}
// 解密
fileContent, err = libs.DecryptData(fileContent, libs.EncryptionKey)
entryData, err := libs.EncryptData(fileData, []byte(configPwdStr))
if err != nil {
libs.HTTPError(w, http.StatusInternalServerError, err.Error())
libs.HTTPError(w, http.StatusInternalServerError, "文件加密失败")
return
}
data := string(fileContent)
if !strings.HasPrefix(data, "link::") {
data = base64.StdEncoding.EncodeToString(fileContent)
_, err = newFile.Write(entryData)
if err != nil {
libs.HTTPError(w, http.StatusInternalServerError, "文件写入失败")
return
}
err = CheckAddDesktop(path)
if err != nil {
log.Printf("Error adding file to desktop: %s", err.Error())
}
resp := libs.APIResponse{Message: "success", Data: data}
json.NewEncoder(w).Encode(resp)
libs.SuccessMsg(w, "", "文件写入成功")
}
// 设置文件密码
func HandleSetFilePwd(w http.ResponseWriter, r *http.Request) {
fPwd := r.Header.Get("Pwd")
salt, err := GetSalt(r) // 获取盐值
// 处理获取盐值时的错误
if err != nil || fPwd == "" {
libs.HTTPError(w, http.StatusInternalServerError, err.Error())
func HandleReadFile(w http.ResponseWriter, r *http.Request) {
path := r.URL.Query().Get("path")
if path == "" {
libs.ErrorMsg(w, "文件路径不能为空")
return
}
// 服务端再hash加密
hashPwd := libs.HashPassword(fPwd, salt)
// 服务端存储
err = libs.SetConfigByName("filePwd", hashPwd)
basePath, err := libs.GetOsDir()
if err != nil {
libs.HTTPError(w, http.StatusInternalServerError, err.Error())
libs.ErrorMsg(w, err.Error())
return
}
// salt值存储
err = libs.SetConfigByName("salt", salt)
fullFilePath := filepath.Join(basePath, path)
file, err := os.Open(fullFilePath)
if err != nil {
libs.HTTPError(w, http.StatusInternalServerError, err.Error())
libs.ErrorMsg(w, err.Error())
return
}
res := libs.APIResponse{Message: "密码设置成功"}
json.NewEncoder(w).Encode(res)
}
// 更改文件密码
func HandleChangeFilePwd(w http.ResponseWriter, r *http.Request) {
filePwd := r.Header.Get("Pwd")
salt, err := GetSalt(r) // 获取盐值
if err != nil || filePwd == "" { // 检查错误和密码是否为空
libs.ErrorMsg(w, "参数错误")
fileData, err := io.ReadAll(file)
if err != nil {
libs.ErrorMsg(w, err.Error())
return
}
strData := string(fileData)
if strings.HasPrefix(strData, "link::") {
res := libs.APIResponse{Message: "文件读取成功", Data: strData}
json.NewEncoder(w).Encode(res)
return
}
newPwd := libs.HashPassword(filePwd, salt)
err = libs.SetConfigByName("filePwd", newPwd)
// 判断是否为加密文件
isPwd := IsPwdFile(fileData)
if !isPwd {
// 未加密文件,直接返回
content := base64.StdEncoding.EncodeToString(fileData)
res := libs.APIResponse{Message: "文件读取成功", Data: content}
json.NewEncoder(w).Encode(res)
return
}
Pwd := r.Header.Get("Pwd")
filePwd := strData[1:33]
// Pwd为空,info密码与文件密码做比对
if Pwd == "" {
configPwd, ishas := libs.GetConfig("filePwd")
if !ishas {
libs.ErrorMsg(w, "未设置密码")
return
}
configPwdStr, ok := configPwd.(string)
if !ok {
libs.ErrorMsg(w, "后端配置文件密码格式错误")
return
}
// 校验密码
if filePwd != configPwdStr {
res := libs.APIResponse{Message: "密码错误,请输入正确的密码", Code: -1, Error: "needPwd"}
json.NewEncoder(w).Encode(res)
return
}
decryptData, err := libs.DecryptData(fileData[34:], []byte(filePwd))
if err != nil {
libs.ErrorMsg(w, err.Error())
return
}
content := base64.StdEncoding.EncodeToString(decryptData)
res := libs.APIResponse{Message: "加密文件读取成功", Data: content}
json.NewEncoder(w).Encode(res)
return
}
// Pwd不为空,Pwd与文件密码做比对
if Pwd != filePwd {
res := libs.APIResponse{Message: "密码错误,请输入正确的密码", Code: -1, Error: "needPwd"}
json.NewEncoder(w).Encode(res)
return
}
decryptData, err := libs.DecryptData(fileData[34:], []byte(filePwd))
if err != nil {
libs.HTTPError(w, http.StatusInternalServerError, err.Error())
libs.ErrorMsg(w, err.Error())
return
}
libs.SuccessMsg(w, "success", "The file password change success!")
content := base64.StdEncoding.EncodeToString(decryptData)
res := libs.APIResponse{Message: "加密文件读取成功", Data: content}
json.NewEncoder(w).Encode(res)
}
// 更改加密状态
func HandleSetIsPwd(w http.ResponseWriter, r *http.Request) {
isPwd := r.URL.Query().Get("ispwd")
// 0非加密机器 1加密机器
isPwdValue, err := strconv.Atoi(isPwd)
if err != nil {
libs.HTTPError(w, http.StatusBadRequest, err.Error())
func HandleSetFilePwd(w http.ResponseWriter, r *http.Request) {
Pwd := r.Header.Get("Pwd")
if Pwd == "" {
err := libs.DeleteConfig("filePwd")
if err != nil {
libs.ErrorMsg(w, fmt.Sprintf("取消加密失败:%s", err.Error()))
return
}
libs.SuccessMsg(w, nil, "取消加密成功")
return
}
var isPwdBool bool
if isPwdValue == 0 {
isPwdBool = false
} else {
isPwdBool = true
}
err = libs.SetConfigByName("isPwd", isPwdBool)
err := libs.SetConfigByName("filePwd", Pwd)
if err != nil {
libs.HTTPError(w, http.StatusInternalServerError, err.Error())
libs.ErrorMsg(w, err.Error())
return
}
libs.SuccessMsg(w, "success", "")
libs.SuccessMsg(w, nil, "设置密码成功")
}

61
godo/files/pwdfile_test.go

@ -0,0 +1,61 @@
package files
import (
"fmt"
"godo/libs"
"io"
"os"
"testing"
)
func Test_WriteFile(t *testing.T) {
filePath := "test.txt"
content := "hello world"
configPwd := "b854f92a0bb8462ad75239152081c12b"
file, err := os.Create(filePath)
if err != nil {
t.Error(err)
}
defer file.Close()
_, err = file.WriteString(fmt.Sprintf("@%s@", configPwd))
if err != nil {
t.Error(err)
}
encryData, err := libs.EncryptData([]byte(content), []byte(configPwd))
if err != nil {
t.Error(err)
}
_, err = file.Write(encryData)
if err != nil {
t.Error(err)
}
}
func Test_ReadFile(t *testing.T) {
filePath := "test.txt"
pwd := "b854f92a0bb8462ad75239152081c12b"
file, err := os.Open(filePath)
if err != nil {
t.Error(err)
}
defer file.Close()
data, err := io.ReadAll(file)
if err != nil {
t.Error(err)
}
if pwd == "" {
fmt.Println(string(data))
return
}
realPwd := data[1:33]
if pwd != string(realPwd) {
t.Error("密码错误")
return
}
content := data[34:]
decryData, err := libs.DecryptData(content, []byte(pwd))
if err != nil {
t.Error(err)
}
fmt.Println(string(decryData))
}
Loading…
Cancel
Save