2024-06-24 05:52:42 +00:00
|
|
|
package service
|
|
|
|
|
|
|
|
import (
|
|
|
|
"bufio"
|
|
|
|
"fmt"
|
|
|
|
"os"
|
|
|
|
"os/exec"
|
|
|
|
"path"
|
|
|
|
"path/filepath"
|
|
|
|
"sort"
|
|
|
|
"strings"
|
|
|
|
"time"
|
|
|
|
|
|
|
|
"github.com/1Panel-dev/1Panel/backend/app/dto"
|
|
|
|
"github.com/1Panel-dev/1Panel/backend/buserr"
|
|
|
|
"github.com/1Panel-dev/1Panel/backend/constant"
|
|
|
|
"github.com/1Panel-dev/1Panel/backend/global"
|
|
|
|
"github.com/1Panel-dev/1Panel/backend/utils/cmd"
|
|
|
|
"github.com/1Panel-dev/1Panel/backend/utils/common"
|
|
|
|
"github.com/1Panel-dev/1Panel/backend/utils/systemctl"
|
|
|
|
"github.com/jinzhu/copier"
|
|
|
|
|
|
|
|
"github.com/pkg/errors"
|
|
|
|
)
|
|
|
|
|
|
|
|
const (
|
|
|
|
clamServiceNameCentOs = "clamd@scan.service"
|
|
|
|
clamServiceNameUbuntu = "clamav-daemon.service"
|
2024-07-02 09:25:25 +00:00
|
|
|
resultDir = "clamav"
|
2024-06-24 05:52:42 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
type ClamService struct {
|
|
|
|
serviceName string
|
|
|
|
}
|
|
|
|
|
|
|
|
type IClamService interface {
|
|
|
|
LoadBaseInfo() (dto.ClamBaseInfo, error)
|
|
|
|
Operate(operate string) error
|
|
|
|
SearchWithPage(search dto.SearchWithPage) (int64, interface{}, error)
|
|
|
|
Create(req dto.ClamCreate) error
|
|
|
|
Update(req dto.ClamUpdate) error
|
2024-07-02 09:25:25 +00:00
|
|
|
Delete(req dto.ClamDelete) error
|
2024-06-24 05:52:42 +00:00
|
|
|
HandleOnce(req dto.OperateByID) error
|
|
|
|
LoadFile(req dto.OperationWithName) (string, error)
|
|
|
|
UpdateFile(req dto.UpdateByNameAndFile) error
|
|
|
|
LoadRecords(req dto.ClamLogSearch) (int64, interface{}, error)
|
|
|
|
CleanRecord(req dto.OperateByID) error
|
2024-07-04 08:00:32 +00:00
|
|
|
|
|
|
|
LoadRecordLog(req dto.ClamLogReq) (string, error)
|
2024-06-24 05:52:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func NewIClamService() IClamService {
|
|
|
|
return &ClamService{}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (f *ClamService) LoadBaseInfo() (dto.ClamBaseInfo, error) {
|
|
|
|
var baseInfo dto.ClamBaseInfo
|
|
|
|
baseInfo.Version = "-"
|
|
|
|
exist1, _ := systemctl.IsExist(clamServiceNameCentOs)
|
|
|
|
if exist1 {
|
|
|
|
f.serviceName = clamServiceNameCentOs
|
|
|
|
baseInfo.IsExist = true
|
|
|
|
baseInfo.IsActive, _ = systemctl.IsActive(clamServiceNameCentOs)
|
|
|
|
}
|
2024-06-26 14:40:52 +00:00
|
|
|
exist2, _ := systemctl.IsExist(clamServiceNameUbuntu)
|
2024-06-24 05:52:42 +00:00
|
|
|
if exist2 {
|
2024-06-26 14:40:52 +00:00
|
|
|
f.serviceName = clamServiceNameUbuntu
|
2024-06-24 05:52:42 +00:00
|
|
|
baseInfo.IsExist = true
|
2024-06-26 14:40:52 +00:00
|
|
|
baseInfo.IsActive, _ = systemctl.IsActive(clamServiceNameUbuntu)
|
2024-06-24 05:52:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if baseInfo.IsActive {
|
|
|
|
version, err := cmd.Exec("clamdscan --version")
|
|
|
|
if err != nil {
|
|
|
|
return baseInfo, nil
|
|
|
|
}
|
|
|
|
if strings.Contains(version, "/") {
|
|
|
|
baseInfo.Version = strings.TrimPrefix(strings.Split(version, "/")[0], "ClamAV ")
|
|
|
|
} else {
|
|
|
|
baseInfo.Version = strings.TrimPrefix(version, "ClamAV ")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return baseInfo, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (f *ClamService) Operate(operate string) error {
|
|
|
|
switch operate {
|
|
|
|
case "start", "restart", "stop":
|
|
|
|
stdout, err := cmd.Execf("systemctl %s %s", operate, f.serviceName)
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("%s the %s failed, err: %s", operate, f.serviceName, stdout)
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
default:
|
|
|
|
return fmt.Errorf("not support such operation: %v", operate)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (f *ClamService) SearchWithPage(req dto.SearchWithPage) (int64, interface{}, error) {
|
|
|
|
total, commands, err := clamRepo.Page(req.Page, req.PageSize, commonRepo.WithLikeName(req.Info))
|
|
|
|
if err != nil {
|
|
|
|
return 0, nil, err
|
|
|
|
}
|
|
|
|
var datas []dto.ClamInfo
|
|
|
|
for _, command := range commands {
|
|
|
|
var item dto.ClamInfo
|
|
|
|
if err := copier.Copy(&item, &command); err != nil {
|
|
|
|
return 0, nil, errors.WithMessage(constant.ErrStructTransform, err.Error())
|
|
|
|
}
|
|
|
|
item.LastHandleDate = "-"
|
|
|
|
datas = append(datas, item)
|
|
|
|
}
|
|
|
|
nyc, _ := time.LoadLocation(common.LoadTimeZone())
|
|
|
|
for i := 0; i < len(datas); i++ {
|
|
|
|
logPaths := loadFileByName(datas[i].Name)
|
|
|
|
sort.Slice(logPaths, func(i, j int) bool {
|
|
|
|
return logPaths[i] > logPaths[j]
|
|
|
|
})
|
|
|
|
if len(logPaths) != 0 {
|
2024-06-28 06:04:08 +00:00
|
|
|
t1, err := time.ParseInLocation(constant.DateTimeSlimLayout, logPaths[0], nyc)
|
2024-06-24 05:52:42 +00:00
|
|
|
if err != nil {
|
|
|
|
continue
|
|
|
|
}
|
2024-06-28 06:04:08 +00:00
|
|
|
datas[i].LastHandleDate = t1.Format(constant.DateTimeLayout)
|
2024-06-24 05:52:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return total, datas, err
|
|
|
|
}
|
|
|
|
|
|
|
|
func (f *ClamService) Create(req dto.ClamCreate) error {
|
|
|
|
clam, _ := clamRepo.Get(commonRepo.WithByName(req.Name))
|
|
|
|
if clam.ID != 0 {
|
|
|
|
return constant.ErrRecordExist
|
|
|
|
}
|
|
|
|
if err := copier.Copy(&clam, &req); err != nil {
|
|
|
|
return errors.WithMessage(constant.ErrStructTransform, err.Error())
|
|
|
|
}
|
|
|
|
if err := clamRepo.Create(&clam); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (f *ClamService) Update(req dto.ClamUpdate) error {
|
|
|
|
clam, _ := clamRepo.Get(commonRepo.WithByName(req.Name))
|
|
|
|
if clam.ID == 0 {
|
|
|
|
return constant.ErrRecordNotFound
|
|
|
|
}
|
|
|
|
upMap := map[string]interface{}{}
|
|
|
|
upMap["name"] = req.Name
|
|
|
|
upMap["path"] = req.Path
|
|
|
|
upMap["description"] = req.Description
|
|
|
|
if err := clamRepo.Update(req.ID, upMap); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2024-07-02 09:25:25 +00:00
|
|
|
func (u *ClamService) Delete(req dto.ClamDelete) error {
|
|
|
|
for _, id := range req.Ids {
|
|
|
|
clam, _ := clamRepo.Get(commonRepo.WithByID(id))
|
2024-06-24 05:52:42 +00:00
|
|
|
if clam.ID == 0 {
|
2024-07-02 09:25:25 +00:00
|
|
|
continue
|
|
|
|
}
|
2024-07-04 08:00:32 +00:00
|
|
|
if req.RemoveRecord {
|
2024-07-02 09:25:25 +00:00
|
|
|
_ = os.RemoveAll(path.Join(global.CONF.System.DataDir, resultDir, clam.Name))
|
2024-06-24 05:52:42 +00:00
|
|
|
}
|
2024-07-02 09:25:25 +00:00
|
|
|
if req.RemoveInfected {
|
|
|
|
_ = os.RemoveAll(path.Join(clam.InfectedDir, "1panel-infected", clam.Name))
|
|
|
|
}
|
2024-07-05 08:52:39 +00:00
|
|
|
if err := clamRepo.Delete(commonRepo.WithByID(id)); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2024-06-24 05:52:42 +00:00
|
|
|
}
|
2024-07-02 09:25:25 +00:00
|
|
|
return nil
|
2024-06-24 05:52:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func (u *ClamService) HandleOnce(req dto.OperateByID) error {
|
|
|
|
clam, _ := clamRepo.Get(commonRepo.WithByID(req.ID))
|
|
|
|
if clam.ID == 0 {
|
|
|
|
return constant.ErrRecordNotFound
|
|
|
|
}
|
|
|
|
if cmd.CheckIllegal(clam.Path) {
|
|
|
|
return buserr.New(constant.ErrCmdIllegal)
|
|
|
|
}
|
2024-07-02 09:25:25 +00:00
|
|
|
timeNow := time.Now().Format(constant.DateTimeSlimLayout)
|
|
|
|
logFile := path.Join(global.CONF.System.DataDir, resultDir, clam.Name, timeNow)
|
2024-06-24 05:52:42 +00:00
|
|
|
if _, err := os.Stat(path.Dir(logFile)); err != nil {
|
|
|
|
_ = os.MkdirAll(path.Dir(logFile), os.ModePerm)
|
|
|
|
}
|
|
|
|
go func() {
|
2024-07-02 09:25:25 +00:00
|
|
|
strategy := ""
|
|
|
|
switch clam.InfectedStrategy {
|
|
|
|
case "remove":
|
|
|
|
strategy = "--remove"
|
|
|
|
case "move":
|
|
|
|
dir := path.Join(clam.InfectedDir, "1panel-infected", clam.Name, timeNow)
|
|
|
|
strategy = "--move=" + dir
|
|
|
|
if _, err := os.Stat(dir); err != nil {
|
|
|
|
_ = os.MkdirAll(dir, os.ModePerm)
|
|
|
|
}
|
|
|
|
case "copy":
|
|
|
|
dir := path.Join(clam.InfectedDir, "1panel-infected", clam.Name, timeNow)
|
|
|
|
strategy = "--copy=" + dir
|
|
|
|
if _, err := os.Stat(dir); err != nil {
|
|
|
|
_ = os.MkdirAll(dir, os.ModePerm)
|
|
|
|
}
|
|
|
|
}
|
2024-07-05 08:52:39 +00:00
|
|
|
global.LOG.Debugf("clamdscan --fdpass %s %s -l %s", strategy, clam.Path, logFile)
|
|
|
|
stdout, err := cmd.Execf("clamdscan --fdpass %s %s -l %s", strategy, clam.Path, logFile)
|
|
|
|
if err != nil {
|
|
|
|
global.LOG.Errorf("clamdscan failed, stdout: %v, err: %v", string(stdout), err)
|
|
|
|
}
|
2024-06-24 05:52:42 +00:00
|
|
|
}()
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (u *ClamService) LoadRecords(req dto.ClamLogSearch) (int64, interface{}, error) {
|
|
|
|
clam, _ := clamRepo.Get(commonRepo.WithByID(req.ClamID))
|
|
|
|
if clam.ID == 0 {
|
|
|
|
return 0, nil, constant.ErrRecordNotFound
|
|
|
|
}
|
|
|
|
logPaths := loadFileByName(clam.Name)
|
|
|
|
if len(logPaths) == 0 {
|
|
|
|
return 0, nil, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
var filterFiles []string
|
|
|
|
nyc, _ := time.LoadLocation(common.LoadTimeZone())
|
|
|
|
for _, item := range logPaths {
|
2024-06-28 06:04:08 +00:00
|
|
|
t1, err := time.ParseInLocation(constant.DateTimeSlimLayout, item, nyc)
|
2024-06-24 05:52:42 +00:00
|
|
|
if err != nil {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
if t1.After(req.StartTime) && t1.Before(req.EndTime) {
|
|
|
|
filterFiles = append(filterFiles, item)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if len(filterFiles) == 0 {
|
|
|
|
return 0, nil, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
sort.Slice(filterFiles, func(i, j int) bool {
|
|
|
|
return filterFiles[i] > filterFiles[j]
|
|
|
|
})
|
|
|
|
|
|
|
|
var records []string
|
|
|
|
total, start, end := len(filterFiles), (req.Page-1)*req.PageSize, req.Page*req.PageSize
|
|
|
|
if start > total {
|
|
|
|
records = make([]string, 0)
|
|
|
|
} else {
|
|
|
|
if end >= total {
|
|
|
|
end = total
|
|
|
|
}
|
|
|
|
records = filterFiles[start:end]
|
|
|
|
}
|
|
|
|
|
|
|
|
var datas []dto.ClamLog
|
|
|
|
for i := 0; i < len(records); i++ {
|
2024-07-02 09:25:25 +00:00
|
|
|
item := loadResultFromLog(path.Join(global.CONF.System.DataDir, resultDir, clam.Name, records[i]))
|
2024-06-24 05:52:42 +00:00
|
|
|
datas = append(datas, item)
|
|
|
|
}
|
|
|
|
return int64(total), datas, nil
|
|
|
|
}
|
2024-07-04 08:00:32 +00:00
|
|
|
func (u *ClamService) LoadRecordLog(req dto.ClamLogReq) (string, error) {
|
|
|
|
logPath := path.Join(global.CONF.System.DataDir, resultDir, req.ClamName, req.RecordName)
|
|
|
|
var tail string
|
|
|
|
if req.Tail != "0" {
|
|
|
|
tail = req.Tail
|
|
|
|
} else {
|
|
|
|
tail = "+1"
|
|
|
|
}
|
|
|
|
cmd := exec.Command("tail", "-n", tail, logPath)
|
|
|
|
stdout, err := cmd.CombinedOutput()
|
|
|
|
if err != nil {
|
|
|
|
return "", fmt.Errorf("tail -n %v failed, err: %v", req.Tail, err)
|
|
|
|
}
|
|
|
|
return string(stdout), nil
|
|
|
|
}
|
2024-06-24 05:52:42 +00:00
|
|
|
|
|
|
|
func (u *ClamService) CleanRecord(req dto.OperateByID) error {
|
|
|
|
clam, _ := clamRepo.Get(commonRepo.WithByID(req.ID))
|
|
|
|
if clam.ID == 0 {
|
|
|
|
return constant.ErrRecordNotFound
|
|
|
|
}
|
2024-07-02 09:25:25 +00:00
|
|
|
pathItem := path.Join(global.CONF.System.DataDir, resultDir, clam.Name)
|
2024-06-24 05:52:42 +00:00
|
|
|
_ = os.RemoveAll(pathItem)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (u *ClamService) LoadFile(req dto.OperationWithName) (string, error) {
|
|
|
|
filePath := ""
|
|
|
|
switch req.Name {
|
|
|
|
case "clamd":
|
2024-06-26 14:40:52 +00:00
|
|
|
if u.serviceName == clamServiceNameUbuntu {
|
2024-06-24 05:52:42 +00:00
|
|
|
filePath = "/etc/clamav/clamd.conf"
|
|
|
|
} else {
|
|
|
|
filePath = "/etc/clamd.d/scan.conf"
|
|
|
|
}
|
|
|
|
case "clamd-log":
|
2024-06-26 14:40:52 +00:00
|
|
|
if u.serviceName == clamServiceNameUbuntu {
|
2024-06-24 05:52:42 +00:00
|
|
|
filePath = "/var/log/clamav/clamav.log"
|
|
|
|
} else {
|
|
|
|
filePath = "/var/log/clamd.scan"
|
|
|
|
}
|
|
|
|
case "freshclam":
|
2024-06-26 14:40:52 +00:00
|
|
|
if u.serviceName == clamServiceNameUbuntu {
|
2024-06-24 05:52:42 +00:00
|
|
|
filePath = "/etc/clamav/freshclam.conf"
|
|
|
|
} else {
|
|
|
|
filePath = "/etc/freshclam.conf"
|
|
|
|
}
|
|
|
|
case "freshclam-log":
|
2024-06-26 14:40:52 +00:00
|
|
|
if u.serviceName == clamServiceNameUbuntu {
|
2024-06-24 05:52:42 +00:00
|
|
|
filePath = "/var/log/clamav/freshclam.log"
|
|
|
|
} else {
|
2024-07-05 08:52:39 +00:00
|
|
|
filePath = "/var/log/freshclam.log"
|
2024-06-24 05:52:42 +00:00
|
|
|
}
|
|
|
|
default:
|
|
|
|
return "", fmt.Errorf("not support such type")
|
|
|
|
}
|
|
|
|
if _, err := os.Stat(filePath); err != nil {
|
|
|
|
return "", buserr.New("ErrHttpReqNotFound")
|
|
|
|
}
|
|
|
|
content, err := os.ReadFile(filePath)
|
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
return string(content), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (u *ClamService) UpdateFile(req dto.UpdateByNameAndFile) error {
|
|
|
|
filePath := ""
|
|
|
|
service := ""
|
|
|
|
switch req.Name {
|
|
|
|
case "clamd":
|
2024-06-26 14:40:52 +00:00
|
|
|
if u.serviceName == clamServiceNameUbuntu {
|
|
|
|
service = clamServiceNameUbuntu
|
2024-06-24 05:52:42 +00:00
|
|
|
filePath = "/etc/clamav/clamd.conf"
|
|
|
|
} else {
|
|
|
|
service = clamServiceNameCentOs
|
|
|
|
filePath = "/etc/clamd.d/scan.conf"
|
|
|
|
}
|
|
|
|
case "freshclam":
|
2024-06-26 14:40:52 +00:00
|
|
|
if u.serviceName == clamServiceNameUbuntu {
|
2024-06-24 05:52:42 +00:00
|
|
|
filePath = "/etc/clamav/freshclam.conf"
|
|
|
|
} else {
|
|
|
|
filePath = "/etc/freshclam.conf"
|
|
|
|
}
|
|
|
|
service = "clamav-freshclam.service"
|
|
|
|
default:
|
|
|
|
return fmt.Errorf("not support such type")
|
|
|
|
}
|
|
|
|
file, err := os.OpenFile(filePath, os.O_WRONLY|os.O_TRUNC, 0640)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
defer file.Close()
|
|
|
|
write := bufio.NewWriter(file)
|
|
|
|
_, _ = write.WriteString(req.File)
|
|
|
|
write.Flush()
|
|
|
|
|
|
|
|
_ = systemctl.Restart(service)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func loadFileByName(name string) []string {
|
|
|
|
var logPaths []string
|
2024-07-02 09:25:25 +00:00
|
|
|
pathItem := path.Join(global.CONF.System.DataDir, resultDir, name)
|
2024-06-24 05:52:42 +00:00
|
|
|
_ = filepath.Walk(pathItem, func(path string, info os.FileInfo, err error) error {
|
|
|
|
if err != nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
if info.IsDir() || info.Name() == name {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
logPaths = append(logPaths, info.Name())
|
|
|
|
return nil
|
|
|
|
})
|
|
|
|
return logPaths
|
|
|
|
}
|
|
|
|
func loadResultFromLog(pathItem string) dto.ClamLog {
|
|
|
|
var data dto.ClamLog
|
|
|
|
data.Name = path.Base(pathItem)
|
|
|
|
data.Status = constant.StatusWaiting
|
|
|
|
file, err := os.ReadFile(pathItem)
|
|
|
|
if err != nil {
|
|
|
|
return data
|
|
|
|
}
|
|
|
|
lines := strings.Split(string(file), "\n")
|
|
|
|
for _, line := range lines {
|
|
|
|
if strings.Contains(line, "- SCAN SUMMARY -") {
|
|
|
|
data.Status = constant.StatusDone
|
|
|
|
}
|
|
|
|
if data.Status != constant.StatusDone {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
switch {
|
|
|
|
case strings.HasPrefix(line, "Infected files:"):
|
|
|
|
data.InfectedFiles = strings.TrimPrefix(line, "Infected files:")
|
2024-07-04 08:00:32 +00:00
|
|
|
case strings.HasPrefix(line, "Total errors:"):
|
|
|
|
data.TotalError = strings.TrimPrefix(line, "Total errors:")
|
2024-06-24 05:52:42 +00:00
|
|
|
case strings.HasPrefix(line, "Time:"):
|
|
|
|
if strings.Contains(line, "(") {
|
|
|
|
data.ScanTime = strings.ReplaceAll(strings.Split(line, "(")[1], ")", "")
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
data.ScanTime = strings.TrimPrefix(line, "Time:")
|
|
|
|
case strings.HasPrefix(line, "Start Date:"):
|
|
|
|
data.ScanDate = strings.TrimPrefix(line, "Start Date:")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return data
|
|
|
|
}
|