From 9e7ad45f06237665f27cf767738e21a19fcfefc2 Mon Sep 17 00:00:00 2001 From: ren yuze Date: Fri, 21 Aug 2020 10:48:02 +0800 Subject: [PATCH] v1.0.0rc1 update --- vtqe/aes.go | 1 + vtqe/aeschiper/aes.go | 90 +++++ vtqe/aeschiper/aes_test.go | 14 + vtqe/attach.go | 83 ++-- vtqe/base64.go | 59 +++ vtqe/curl.go | 211 ++++++++++ vtqe/ftp.go | 50 +++ vtqe/generate.go | 52 +++ vtqe/hash.go | 70 ++++ vtqe/http.go | 4 +- vtqe/image-basic.go | 194 +++++++++ vtqe/image.go | 82 ++++ vtqe/main.go | 11 +- vtqe/merge.go | 47 +++ vtqe/net.go | 806 +++++++++++++++++++++++++++++++++++++ vtqe/sftp.go | 172 ++++++++ vtqe/split.go | 60 +++ vtqe/tcp.go | 442 ++++++++++++++++++++ vtqe/uac.go | 33 ++ vtqe/udp.go | 126 ++++++ vtqe/vic.go | 94 +++++ 21 files changed, 2670 insertions(+), 31 deletions(-) create mode 100644 vtqe/aes.go create mode 100644 vtqe/aeschiper/aes.go create mode 100644 vtqe/aeschiper/aes_test.go create mode 100644 vtqe/base64.go create mode 100644 vtqe/curl.go create mode 100644 vtqe/ftp.go create mode 100644 vtqe/generate.go create mode 100644 vtqe/hash.go create mode 100644 vtqe/image-basic.go create mode 100644 vtqe/image.go create mode 100644 vtqe/merge.go create mode 100644 vtqe/net.go create mode 100644 vtqe/sftp.go create mode 100644 vtqe/split.go create mode 100644 vtqe/tcp.go create mode 100644 vtqe/uac.go create mode 100644 vtqe/udp.go create mode 100644 vtqe/vic.go diff --git a/vtqe/aes.go b/vtqe/aes.go new file mode 100644 index 0000000..06ab7d0 --- /dev/null +++ b/vtqe/aes.go @@ -0,0 +1 @@ +package main diff --git a/vtqe/aeschiper/aes.go b/vtqe/aeschiper/aes.go new file mode 100644 index 0000000..5b49812 --- /dev/null +++ b/vtqe/aeschiper/aes.go @@ -0,0 +1,90 @@ +package aeschiper + +import ( + "errors" + "fmt" + "io" + "os" + + "b612.me/starcrypto" + "b612.me/staros" +) + +func EncodeStr(str, key string) string { + ensdata := starcrypto.AesEncryptCFBNoBlock([]byte(str), starcrypto.Md5([]byte(key))) + return starcrypto.Base91EncodeToString(ensdata) +} + +func DecodeStr(str, key string) string { + strtmp := starcrypto.Base91DecodeString(str) + str = string(strtmp) + return string(starcrypto.AesDecryptCFBNoBlock([]byte(str), starcrypto.Md5([]byte(key)))) +} + +func EncodeFile(fpath, out, key string) error { + if !staros.Exists(fpath) { + return errors.New("SrcFile Not Exists") + } + fpsrc, err := os.Open(fpath) + if err != nil { + return err + } + defer fpsrc.Close() + fpdst, err := os.Create(out) + if err != nil { + return err + } + defer fpdst.Close() + bufsize := 1024 * 1024 //1MB + stat, _ := fpsrc.Stat() + buf := make([]byte, bufsize) + sumAll := 0 + for { + n, err := fpsrc.Read(buf) + if err != nil && err != io.EOF { + return err + } + fmt.Print("已完成：%.2f%%\r", float64(sumAll)/float64(stat.Size())*100) + encodeBytes := starcrypto.AesEncryptCFBNoBlock(buf[:n], starcrypto.Md5([]byte(key))) + fpdst.Write(encodeBytes) + if err == io.EOF { + fmt.Print("已完成：100%% \n") + break + } + } + return nil +} + +func DecodeFile(fpath, out, key string) error { + if !staros.Exists(fpath) { + return errors.New("SrcFile Not Exists") + } + fpsrc, err := os.Open(fpath) + if err != nil { + return err + } + defer fpsrc.Close() + fpdst, err := os.Create(out) + if err != nil { + return err + } + defer fpdst.Close() + bufsize := 1024 * 1024 //1MB + stat, _ := fpsrc.Stat() + buf := make([]byte, bufsize) + sumAll := 0 + for { + n, err := fpsrc.Read(buf) + if err != nil && err != io.EOF { + return err + } + fmt.Print("已完成：%.2f%%\r", float64(sumAll)/float64(stat.Size())*100) + encodeBytes := starcrypto.AesDecryptCFBNoBlock(buf[:n], starcrypto.Md5([]byte(key))) + fpdst.Write(encodeBytes) + if err == io.EOF { + fmt.Print("已完成：100%% \n") + break + } + } + return nil +} diff --git a/vtqe/aeschiper/aes_test.go b/vtqe/aeschiper/aes_test.go new file mode 100644 index 0000000..334af9f --- /dev/null +++ b/vtqe/aeschiper/aes_test.go @@ -0,0 +1,14 @@ +package aeschiper + +import ( + "fmt" + "testing" +) + +func Test_EncodeStr(t *testing.T) { + fmt.Println(EncodeStr("我喜欢你", "sakurasaiteruyogugugug")) +} + +func Test_DecodeStr(t *testing.T) { + fmt.Println(DecodeStr("Z_8aILbog@Kjm$P", "sakurasaiteruyogugugug")) +} diff --git a/vtqe/attach.go b/vtqe/attach.go index dc47e1e..b3bf8c4 100644 --- a/vtqe/attach.go +++ b/vtqe/attach.go @@ -1,45 +1,78 @@ package main import ( - "fmt" + "io" + "os" - "b612.me/starainrt" "b612.me/starlog" "github.com/spf13/cobra" ) var attachcmd = &cobra.Command{ Use: "attach", - Short: "合并两个文件", - Long: "合并两个文件", + Short: "合并多个文件", + Long: "合并多个文件", Run: func(this *cobra.Command, args []string) { - var src, dst, out string - if len(args) == 3 { - src = args[0] - dst = args[1] - out = args[2] - } else { - src, _ = this.Flags().GetString("src") - dst, _ = this.Flags().GetString("dst") - out, _ = this.Flags().GetString("out") + src, _ := this.Flags().GetStringArray("src") + out, _ := this.Flags().GetString("out") + if len(src) < 2 || out == "" { + starlog.Criticalln("请输入至少2个输入路径，一个输出路径") + os.Exit(1) } - if src == "" || dst == "" { - starlog.Criticalln("ERROR PATH") - this.Help() - return + os.Exit(runAttach(src, out)) + }, +} + +func runAttach(src []string, out string) int { + fpOut, err := os.Create(out) + if err != nil { + starlog.Errorln("Err:无法创建输出文件！", err) + return 2 + } + defer fpOut.Close() + for _, file := range src { + fpFile, err := os.OpenFile(file, os.O_RDONLY, 0644) + if err != nil { + starlog.Errorln("Err:Cannot Openfile:", err) + return 3 } - cryp := new(starainrt.StarCrypto) - err := cryp.Attach(src, dst, out) + stats, err := fpFile.Stat() if err != nil { - starlog.Criticalln(err.Error) - } else { - fmt.Println("完成") + starlog.Errorln("Err:Cannot Get File Stats:", err) + return 4 } - }, + if stats.Size() == 0 { + starlog.Warningf("文件:%s为空文件，跳过！\n", stats.Name()) + continue + } + buf := make([]byte, 65535) + sumAll := 0 + for { + n, err := fpFile.Read(buf) + if err != nil && err != io.EOF { + starlog.Errorln("Err:Error Occured While ReadFile:", err) + fpFile.Close() + return 5 + } + sumAll += n + _, errW := fpOut.Write(buf[:n]) + if errW != nil { + starlog.Errorln("Error While Write Data to OutFile", errW) + return 6 + } + starlog.StdPrintf([]starlog.Attr{starlog.FgGreen}, "文件%s，已完成：%.2f%%\r", stats.Name(), (float64(sumAll) / float64(stats.Size()) * 100.0000)) + if err == io.EOF { + starlog.StdPrintf([]starlog.Attr{starlog.FgGreen}, "文件：%v，已完成：100.00%% \n", stats.Name()) + fpFile.Close() + break + } + } + } + starlog.StdPrintln([]starlog.Attr{starlog.FgGreen}, "Ok!文件合并完成") + return 0 } func init() { - attachcmd.Flags().StringP("src", "s", "", "源文件路径") - attachcmd.Flags().StringP("dst", "d", "", "目标文件路径") + attachcmd.Flags().StringArrayP("src", "s", []string{}, "源文件路径") attachcmd.Flags().StringP("out", "o", "", "输出文件路径") } diff --git a/vtqe/base64.go b/vtqe/base64.go new file mode 100644 index 0000000..c0c0fdc --- /dev/null +++ b/vtqe/base64.go @@ -0,0 +1,59 @@ +package main + +import ( + "fmt" + + "b612.me/starcrypto" + "b612.me/starlog" + "github.com/spf13/cobra" +) + +var b64cmd = &cobra.Command{ + Use: "base64", + Short: "使用base64处理文件或字符串", + Long: "使用base64处理文件或字符串", + Run: func(this *cobra.Command, args []string) { + var err error + ok, _ := this.Flags().GetBool("file") + de, _ := this.Flags().GetBool("decode") + if len(args) != 1 { + starlog.Criticalln("参数不足，请输入文件地址或字符串") + this.Help() + return + } + shell := func(pect float64) { + if pect == 100 { + fmt.Println("已处理：100.000000%") + } else { + fmt.Printf("已处理：%f%%\r", pect) + } + } + if ok { + path, _ := this.Flags().GetString("path") + if !de { + err = starcrypto.Base64EncodeFile(args[0], path, shell) + } else { + err = starcrypto.Base64DecodeFile(args[0], path, shell) + } + } else { + if !de { + data := starcrypto.Base64Encode([]byte(args[0])) + fmt.Println(data) + } else { + var data []byte + data, err = starcrypto.Base64Decode(args[0]) + fmt.Println(string(data)) + } + } + if err != nil { + starlog.Criticalln(err) + return + } + }, +} + +func init() { + b64cmd.Flags().BoolP("file", "f", false, "base64处理文件") + b64cmd.Flags().StringP("path", "p", "./b64.encode", "指定处理地址，默认为./b64.encode") + b64cmd.Flags().BoolP("decode", "d", false, "base64解码") +} diff --git a/vtqe/curl.go b/vtqe/curl.go new file mode 100644 index 0000000..a772b1d --- /dev/null +++ b/vtqe/curl.go @@ -0,0 +1,211 @@ +package main + +import ( + "fmt" + "io/ioutil" + "net/http" + "strings" + + "b612.me/starainrt" + + "github.com/spf13/cobra" +) + +var curlcmd = &cobra.Command{ + Use: "curl", + Short: "Curl工具", + Long: "Curl小工具", + Run: func(this *cobra.Command, args []string) { + var method string + var err error + var data []byte + o, _ := this.Flags().GetString("output") + d, _ := this.Flags().GetString("data") + f, _ := this.Flags().GetString("file") + h, _ := this.Flags().GetString("header") + c, _ := this.Flags().GetString("cookie") + b, _ := this.Flags().GetString("cookie-jar") + i, _ := this.Flags().GetBool("include") + x, _ := this.Flags().GetString("proxy") + m, _ := this.Flags().GetInt("max-time") + ua, _ := this.Flags().GetString("user-agent") + connecttimeout, _ := this.Flags().GetInt("connect-timeout") + if len(args) != 1 { + this.Help() + return + } + url := args[0] + shell := func(pect float64) { + if pect == 100 { + fmt.Println("已完成：100.000000%") + } else { + fmt.Printf("已完成：%f%%\r", pect) + } + } + var postdata map[string]string + if d != "" { + postdata = make(map[string]string) + strip := strings.Split(d, "&") + for _, v := range strip { + tmp := strings.Split(v, "=") + if len(tmp) != 2 { + continue + } + postdata[tmp[0]] = tmp[1] + } + } + if len(d) == 0 { + method = "GET" + } else { + method = "POST" + } + tmp := strings.Split(f, ",") + curl := starainrt.NewStarCurl() + curl.TimeOut = m + curl.DialTimeOut = connecttimeout + curl.ReqHeader.Set("User-Agent", "Victorique - B612.ME") + if ua != "" { + curl.ReqHeader.Set("User-Agent", ua) + } + if x != "" { + curl.Proxy = x + } + if h != "" { + head := strings.Split(h, ",") + for _, v := range head { + hp := strings.Split(v, ":") + if len(hp) != 2 { + continue + } + curl.ReqHeader.Set(hp[0], hp[1]) + } + } + if c != "" { + if starainrt.Exists(c) { + ck, err := ioutil.ReadFile(c) + if err != nil { + fmt.Println(err) + return + } + h = strings.TrimSpace(string(ck)) + } + cook := strings.Split(h, ",") + for _, v := range cook { + hp := strings.Split(v, "=") + if len(hp) != 2 { + continue + } + curl.ReqCookies = append(curl.ReqCookies, &http.Cookie{Name: hp[0], Value: hp[1]}) + } + + } + if len(tmp) != 2 && f != "" { + fmt.Println("对file应使用逗号分隔区分文件名和路径") + return + } + if o != "" { + if f != "" { + _, err = curl.CurlWithFile(url, postdata, tmp[0], tmp[1], o, true, shell) + + } else { + err = curl.CurlDataToFile(url, []byte(d), method, o, shell) + + } + if err != nil { + fmt.Println(err) + } + if i { + for k, v := range curl.RespHeader { + for _, v2 := range v { + fmt.Println(k + ":" + v2) + } + } + fmt.Println("\n") + var cookiewriter string + for _, v := range curl.RespCookies { + fmt.Println(v.Name + ":" + v.Value) + if b != "" { + cookiewriter += v.Name + ":" + v.Value + "," + } + } + fmt.Println("\n\n") + if b != "" { + ioutil.WriteFile(b, []byte(cookiewriter), 0755) + } + } + } else { + if f != "" { + data, err = curl.CurlWithFile(url, postdata, tmp[0], tmp[1], "", false, shell) + + } else { + data, err = curl.Curl(url, []byte(d), method) + } + if i { + for k, v := range curl.RespHeader { + for _, v2 := range v { + fmt.Println(k + ":" + v2) + } + } + fmt.Println("\n") + var cookiewriter string + for _, v := range curl.RespCookies { + fmt.Println(v.Name + ":" + v.Value) + if b != "" { + cookiewriter += v.Name + ":" + v.Value + "," + } + } + fmt.Println("\n\n") + if b != "" { + ioutil.WriteFile(b, []byte(cookiewriter), 0755) + } + } + fmt.Println(string(data)) + if err != nil { + fmt.Println(err) + } + } + }, +} + +func init() { + curlcmd.Flags().StringP("output", "o", "", "写入文件而不是标准输出") + curlcmd.Flags().StringP("data", "d", "", "http postdata数据") + curlcmd.Flags().StringP("file", "f", "", "上传文件的地址") + curlcmd.Flags().StringP("header", "H", "", "使用的header") + curlcmd.Flags().StringP("cookie", "b", "", "使用的cookie") + curlcmd.Flags().StringP("cookie-jar", "c", "", "写入返回的cookie到文件中") + curlcmd.Flags().BoolP("include", "i", false, "显示返回的header与cookie") + curlcmd.Flags().StringP("proxy", "x", "", "使用代理") + curlcmd.Flags().IntP("max-time", "m", 0, "最大传输超时时间") + curlcmd.Flags().Int("connect-timeout", 15, "最大连接建立超时时间") + curlcmd.Flags().StringP("user-agent", "A", "", "UA设置") + curlupcmd.Flags().StringP("address", "a", "", "远端ip:端口号") + curlcmd.AddCommand(curlupcmd) +} + +var curlupcmd = &cobra.Command{ + Use: "upload", + Short: "victorique上传工具", + Long: "victorique上传工具", + Run: func(this *cobra.Command, args []string) { + if len(args) != 1 { + fmt.Println(args, "不合法啊") + return + } + a, _ := this.Flags().GetString("address") + curl := starainrt.NewStarCurl() + curl.TimeOut = 0 + shell := func(pect float64) { + if pect == 100 { + fmt.Println("已完成：100.000000%") + } else { + fmt.Printf("已完成：%f%%\r", pect) + } + } + data, err := curl.CurlWithFile("http://"+a+"/vtqeupload1127", nil, "victorique", args[0], "", false, shell) + fmt.Println(string(data)) + if err != nil { + fmt.Println(err) + } + }, +} diff --git a/vtqe/ftp.go b/vtqe/ftp.go new file mode 100644 index 0000000..fe3bcb5 --- /dev/null +++ b/vtqe/ftp.go @@ -0,0 +1,50 @@ +package main + +import ( + "log" + "path/filepath" + + filedriver "github.com/goftp/file-driver" + "github.com/goftp/server" + "github.com/spf13/cobra" +) + +var ports int +var username, pwd string +var path, ip string + +// ftpCmd represents the ftp command +var ftpcmd = &cobra.Command{ + Use: "ftp", + Short: `FTP文件服务器`, + Long: `FTP文件服务器`, + Run: func(cmd *cobra.Command, args []string) { + path, _ = filepath.Abs(path) + factory := &filedriver.FileDriverFactory{ + RootPath: path, + Perm: server.NewSimplePerm("user", "group"), + } + opts := &server.ServerOpts{ + Factory: factory, + Port: ports, + Hostname: ip, + Auth: &server.SimpleAuth{Name: username, Password: pwd}, + } + + log.Printf("Starting ftp server on %v:%v", opts.Hostname, opts.Port) + log.Printf("Username %v, Password %v", username, pwd) + server := server.NewServer(opts) + err := server.ListenAndServe() + if err != nil { + log.Fatal("Error starting server:", err) + } + }, +} + +func init() { + ftpcmd.Flags().IntVarP(&ports, "port", "p", 21, "监听端口") + ftpcmd.Flags().StringVarP(&ip, "ip", "i", "0.0.0.0", "监听地址") + ftpcmd.Flags().StringVarP(&username, "user", "u", "1", "用户名，默认为1") + ftpcmd.Flags().StringVarP(&pwd, "pwd", "k", "1", "密码，默认为1") + ftpcmd.Flags().StringVarP(&path, "folder", "f", "./", "本地文件地址") +} diff --git a/vtqe/generate.go b/vtqe/generate.go new file mode 100644 index 0000000..e6453fa --- /dev/null +++ b/vtqe/generate.go @@ -0,0 +1,52 @@ +package main + +import ( + "fmt" + "os" + "time" + + "b612.me/starainrt" + "github.com/spf13/cobra" +) + +var gencmd = &cobra.Command{ + Use: "generate", + Short: "生成随机文件", + Long: "生成指定大小的随机文件", + Run: func(this *cobra.Command, args []string) { + sum, _ := this.Flags().GetInt("sum") + num, _ := this.Flags().GetInt("num") + cap, _ := this.Flags().GetInt("cap") + if len(args) != 1 { + this.Help() + return + } + if num <= 0 { + fmt.Println("num不合法，不应该小于1！") + os.Exit(2) + } + if sum <= 0 { + fmt.Println("sum不合法，不应该小于1！") + os.Exit(2) + } + if cap <= 0 { + fmt.Println("cap不合法，不应该小于1！") + os.Exit(2) + } + err := starainrt.FillWithRandom(args[0], num, cap, sum, func(pect float64) { + fmt.Printf("文件已处理：%f%%\r", pect) + }) + if err != nil { + fmt.Println("err:" + err.Error()) + } + fmt.Println("文件已处理：100.0000000%") + time.Sleep(time.Millisecond * 10) + }, +} + +func init() { + gencmd.Flags().IntP("sum", "s", 3, "随机的种子组数") + gencmd.Flags().IntP("num", "n", 1024, "生成的文件大小") + gencmd.Flags().IntP("cap", "c", 1048576, "bufcap大小") + gencmd.MarkFlagRequired("num") +} diff --git a/vtqe/hash.go b/vtqe/hash.go new file mode 100644 index 0000000..840694a --- /dev/null +++ b/vtqe/hash.go @@ -0,0 +1,70 @@ +package main + +import ( + "fmt" + "os" + + "b612.me/starainrt" + + "b612.me/starlog" + "github.com/spf13/cobra" +) + +var hashcmd = &cobra.Command{ + Use: "hash", + Short: "多种方法哈希值校验", + Long: "进行多种方法哈希值校验", + Run: func(this *cobra.Command, args []string) { + var cumethod, method []string + var result map[string]string + var err error + crypto := new(starainrt.StarCrypto) + cumethod = []string{"md5", "crc32", "sha512", "sha384", "sha256", "sha224", "sha1"} + if ok, _ := this.Flags().GetBool("all"); ok { + method = cumethod + } else { + if len(args) == 0 { + this.Usage() + os.Exit(1) + } + + for _, v := range cumethod { + if ok, _ := this.Flags().GetBool(v); ok { + method = append(method, v) + } + } + if len(method) == 0 { + method = append(method, "md5") + } + } + if ok, _ := this.Flags().GetBool("file"); ok { + result, err = crypto.FileSumAll(args[0], method, func(pect float64) { + if pect != 100.0 { + fmt.Printf("校验已完成：%f%%\r", pect) + } else { + fmt.Printf("校验已完成：%f%%\n", pect) + } + }) + } else { + result, err = crypto.SumAll([]byte(args[0]), method) + } + if err != nil { + starlog.Criticalln("错误：" + err.Error()) + } + for _, v := range method { + fmt.Printf("%s：%s\n", v, result[v]) + } + }, +} + +func init() { + hashcmd.Flags().BoolP("all", "a", false, "使用所有的校验方法") + hashcmd.Flags().BoolP("file", "f", false, "对指定文件进行校验") + hashcmd.Flags().BoolP("md5", "m", false, "进行MD5校验（默认）") + hashcmd.Flags().BoolP("crc32", "c", false, "进行CRC32校验") + hashcmd.Flags().BoolP("sha512", "s", false, "进行SHA512校验") + hashcmd.Flags().Bool("sha384", false, "进行SHA384校验") + hashcmd.Flags().Bool("sha256", false, "进行SHA256校验") + hashcmd.Flags().Bool("sha224", false, "进行SHA224校验") + hashcmd.Flags().Bool("sha1", false, "进行SHA1校验") +} diff --git a/vtqe/http.go b/vtqe/http.go index 8b7fc65..87ecbe0 100644 --- a/vtqe/http.go +++ b/vtqe/http.go @@ -45,7 +45,7 @@ var httpcmd = &cobra.Command{ starlog.Criticalln("Daemon Error:", err) os.Exit(1) } - starlog.StdPrintf([]starlog.Attr{starlog.BgGreen}, "Success,PID=%v\n", pid) + starlog.StdPrintf([]starlog.Attr{starlog.FgGreen}, "Success,PID=%v\n", pid) return } err := run() @@ -68,7 +68,7 @@ func run() error { } defer starlog.Close() } else { - logFp, err := os.OpenFile(logPath, os.O_APPEND, 0755) + logFp, err := os.OpenFile(logPath, os.O_WRONLY|os.O_APPEND, 0755) if err != nil { starlog.Errorln("Create LogFile Failed:", err) os.Exit(2) diff --git a/vtqe/image-basic.go b/vtqe/image-basic.go new file mode 100644 index 0000000..07b30fa --- /dev/null +++ b/vtqe/image-basic.go @@ -0,0 +1,194 @@ +package main + +import ( + "errors" + "image" + "io/ioutil" + "os" + + "github.com/golang/freetype" + + "github.com/nfnt/resize" + + "image/color" + "image/draw" + _ "image/gif" + _ "image/jpeg" + "image/png" + _ "image/png" + + "b612.me/starainrt" +) + +func OpenImage(name string) (image.Image, error) { + if !starainrt.Exists(name) { + return nil, errors.New("File Not Exists") + } + fso, err := os.Open(name) + if err != nil { + return nil, err + } + img, _, err := image.Decode(fso) + if err != nil { + return nil, err + } + return img, nil +} + +func MergePhoto(big, small image.Image, bigsize, smallsize uint, x, y int) image.Image { + big = resize.Resize(bigsize, bigsize, big, resize.Lanczos3) + small = resize.Resize(smallsize, smallsize, small, resize.Lanczos3) + offset := image.Pt(x, y) + b := big.Bounds() + nimg := image.NewRGBA(b) + draw.Draw(nimg, b, big, image.ZP, draw.Src) + draw.Draw(nimg, small.Bounds(), small, offset, draw.Over) + return nimg +} + +func SavePhoto(path string, img image.Image) error { + imgf, err := os.Create(path) + if err != nil { + return err + } + defer imgf.Close() + return png.Encode(imgf, img) +} + +func SetAlpha(img image.Image, alpha uint8) image.Image { + size := img.Bounds() + nimg := image.NewRGBA(size) + for x := 0; x < size.Dx(); x++ { + for y := 0; y < size.Dy(); y++ { + r, g, b, a := img.At(x, y).RGBA() + r = r >> 8 + g = g >> 8 + b = b >> 8 + a = a >> 8 + nimg.Set(x, y, color.NRGBA{uint8(r), uint8(g), uint8(b), alpha}) + //nimg.Set(x, y, color.Alpha{alpha}) + //nimg.Set(x, y, img.At(x, y)) + } + } + return nimg +} + +func AddText(text string, img image.Image, x, y int, dpi, size float64, colors color.RGBA, ttf string) (image.Image, error) { + if !starainrt.Exists(ttf) { + return nil, errors.New("File Not Exists") + } + fontbyte, err := ioutil.ReadFile(ttf) + if err != nil { + return nil, err + } + font, err := freetype.ParseFont(fontbyte) + if err != nil { + return nil, err + } + nimg, ok := img.(draw.Image) + if !ok { + size := img.Bounds() + nimg = image.NewRGBA(img.Bounds()) + for x := 0; x < size.Dx(); x++ { + for y := 0; y < size.Dy(); y++ { + r, g, b, a := img.At(x, y).RGBA() + nimg.Set(x, y, color.NRGBA{uint8(r), uint8(g), uint8(b), uint8(a)}) + } + } + } + f := freetype.NewContext() + f.SetDPI(dpi) + f.SetFontSize(size) + f.SetFont(font) + f.SetClip(nimg.Bounds()) + f.SetDst(nimg) + f.SetSrc(image.NewUniform(colors)) + _, err = f.DrawString(text, freetype.Pt(x, y)) + if err != nil { + return nil, err + } + return nimg, nil +} + +type TextImg struct { + Text string + X int + Y int + Dpi float64 + Size float64 + Color color.NRGBA +} + +type TextList struct { + List []TextImg + TTF []byte +} + +func AddListTests(list TextList, img image.Image) (image.Image, error) { + font, err := freetype.ParseFont(list.TTF) + if err != nil { + return nil, err + } + nimg, ok := img.(draw.Image) + if !ok { + size := img.Bounds() + nimg = image.NewRGBA(img.Bounds()) + for x := 0; x < size.Dx(); x++ { + for y := 0; y < size.Dy(); y++ { + r, g, b, a := img.At(x, y).RGBA() + nimg.Set(x, y, color.NRGBA{uint8(r), uint8(g), uint8(b), uint8(a)}) + } + } + } + for _, v := range list.List { + f := freetype.NewContext() + f.SetDPI(v.Dpi) + f.SetFontSize(v.Size) + f.SetFont(font) + f.SetClip(nimg.Bounds()) + f.SetDst(nimg) + f.SetSrc(image.NewUniform(v.Color)) + _, err = f.DrawString(v.Text, freetype.Pt(v.X, v.Y)) + if err != nil { + return nil, err + } + } + return nimg, nil +} + +func AddTexts(text string, img image.Image, x, y int, dpi, size float64, colors color.NRGBA, ttf string) (image.Image, error) { + if !starainrt.Exists(ttf) { + return nil, errors.New("File Not Exists") + } + fontbyte, err := ioutil.ReadFile(ttf) + if err != nil { + return nil, err + } + font, err := freetype.ParseFont(fontbyte) + if err != nil { + return nil, err + } + nimg, ok := img.(draw.Image) + if !ok { + size := img.Bounds() + nimg = image.NewRGBA(img.Bounds()) + for x := 0; x < size.Dx(); x++ { + for y := 0; y < size.Dy(); y++ { + r, g, b, a := img.At(x, y).RGBA() + nimg.Set(x, y, color.NRGBA{uint8(r), uint8(g), uint8(b), uint8(a)}) + } + } + } + f := freetype.NewContext() + f.SetDPI(dpi) + f.SetFontSize(size) + f.SetFont(font) + f.SetClip(nimg.Bounds()) + f.SetDst(nimg) + f.SetSrc(image.NewUniform(colors)) + _, err = f.DrawString(text, freetype.Pt(x, y)) + if err != nil { + return nil, err + } + return nimg, nil +} diff --git a/vtqe/image.go b/vtqe/image.go new file mode 100644 index 0000000..bf2f1a8 --- /dev/null +++ b/vtqe/image.go @@ -0,0 +1,82 @@ +package main + +import ( + "fmt" + "image" + + "b612.me/starlog" + "github.com/spf13/cobra" +) + +func init() { + imageCmd.AddCommand(imgMirrorCmd) +} + +var imageCmd = &cobra.Command{ + Use: "image", + Short: "图像处理", + Long: "简单的图像处理工具", + Run: func(this *cobra.Command, args []string) { + this.Help() + }, +} + +var imgMirrorCmd = &cobra.Command{ + Use: "mirror", + Short: "图像镜像翻转", + Long: "图像镜像翻转<水平>", + Run: func(this *cobra.Command, args []string) { + if len(args) == 0 { + starlog.Errorln("请指定需要转换的图像！") + return + } + for _, v := range args { + img, err := OpenImage(v) + if err != nil { + starlog.Errorln(err, v) + continue + } + size := img.Bounds() + nimg := image.NewRGBA(size) + for x := 0; x < size.Dx(); x++ { + for y := 0; y < size.Dy(); y++ { + nimg.Set(size.Dx()-x, y, img.At(x, y)) + } + } + if err := SavePhoto(v, nimg); err != nil { + starlog.Errorln(err, v) + continue + } else { + fmt.Println(v, "转换已完成！") + } + } + fmt.Println("任务完成！") + }, +} + +var imgAlpha = &cobra.Command{ + Use: "alpha", + Short: "设置透明度", + Long: "设置alpha通道透明度", + Run: func(this *cobra.Command, args []string) { + if len(args) == 0 { + starlog.Errorln("请指定需要转换的图像！") + return + } + for _, v := range args { + img, err := OpenImage(v) + if err != nil { + starlog.Errorln(err, v) + continue + } + img = SetAlpha(img, 4) + if err := SavePhoto(v, img); err != nil { + starlog.Errorln(err, v) + continue + } else { + fmt.Println(v, "转换已完成！") + } + } + fmt.Println("任务完成！") + }, +} diff --git a/vtqe/main.go b/vtqe/main.go index 53cc6c1..b320713 100644 --- a/vtqe/main.go +++ b/vtqe/main.go @@ -1,20 +1,23 @@ package main import ( + "fmt" + "github.com/spf13/cobra" ) // Vtqe is my own toolbox func init() { - cmdMain.AddCommand(tcpingcmd, httpcmd, attachcmd, detachcmd) + cmdMain.AddCommand(tcpingcmd, httpcmd, attachcmd, detachcmd, b64cmd, ftpcmd, gencmd, hashcmd, imageCmd, mergecmd, netcmd, sftpcmd, splitcmd, tcpcmd, udpcmd, viccmd, curlcmd) } -const vtqe_version string = "v1.0.0NG RC1" +const vtqe_version string = "v1.0.0rc1" var cmdMain = &cobra.Command{ - Short: "Victorique Wisdom ToolBox", - Long: "中二的工具箱：未来を照らし出せ！", + Short: "Victorique's Wisdom ToolBox", + Long: fmt.Sprintf(`Victorique's Wisdom ToolBox @%v +这是一个可爱且充满智慧的工具箱@B612.ME`, vtqe_version), Version: vtqe_version, } diff --git a/vtqe/merge.go b/vtqe/merge.go new file mode 100644 index 0000000..9ddb50d --- /dev/null +++ b/vtqe/merge.go @@ -0,0 +1,47 @@ +package main + +import ( + "fmt" + + "b612.me/starainrt" + "b612.me/starlog" + + "github.com/spf13/cobra" +) + +var mergecmd = &cobra.Command{ + Use: "merge", + Short: "合并文件", + Long: "按路径自动合并分割的文件", + Run: func(this *cobra.Command, args []string) { + var src, dst string + if len(args) == 2 { + src = args[0] + dst = args[1] + } else { + src, _ = this.Flags().GetString("src") + dst, _ = this.Flags().GetString("dst") + } + if src == "" || dst == "" { + this.Help() + return + } + crypto := new(starainrt.StarCrypto) + err := crypto.MergeFile(src, dst, func(pect float64) { + if pect == 100 { + fmt.Println("文件已处理：100.000000%") + } else { + fmt.Printf("文件已处理：%f%%\r", pect) + } + }) + if err != nil { + starlog.Errorln(err.Error) + } + + }, +} + +func init() { + mergecmd.Flags().StringP("src", "s", "", "源文件地址，用*替换文件数字") + mergecmd.Flags().StringP("dst", "d", "", "目标文件地址") +} diff --git a/vtqe/net.go b/vtqe/net.go new file mode 100644 index 0000000..d849eb6 --- /dev/null +++ b/vtqe/net.go @@ -0,0 +1,806 @@ +package main + +import ( + "fmt" + "io" + "net" + "strconv" + "strings" + "time" + + "github.com/spf13/cobra" +) + +func init() { + netcmd.AddCommand(netforwardcmd, natscmd, natccmd) + netforwardcmd.Flags().BoolP("tcp", "t", false, "TCP转发") + netforwardcmd.Flags().BoolP("udp", "u", false, "UDP转发") + netforwardcmd.Flags().IntP("port", "p", 1127, "转发本地端口") + netforwardcmd.Flags().StringP("address", "a", "0.0.0.0", "监听地址") + + natscmd.Flags().BoolP("tcp", "t", false, "TCP穿透") + natscmd.Flags().BoolP("udp", "u", false, "UDP穿透") + natscmd.Flags().IntP("port", "p", 1127, "监听本地端口开始点") + natscmd.Flags().StringP("key", "k", "sakura", "认证密码") + natscmd.Flags().StringP("address", "a", "0.0.0.0", "监听本地地址") + natscmd.Flags().IntP("number", "n", 1, "监听端口数量") + + natccmd.Flags().BoolP("tcp", "t", false, "TCP穿透") + natccmd.Flags().BoolP("udp", "u", false, "UDP穿透") + natccmd.Flags().IntP("port", "p", 1127, "转发穿透端口") + natccmd.Flags().StringP("key", "k", "sakura", "认证密码") + natccmd.Flags().StringP("address", "a", "127.0.0.1", "转发穿透地址") +} + +var netcmd = &cobra.Command{ + Use: "net", + Short: "端口转发，穿透相关", + Long: "端口转发，穿透相关", +} + +var netforwardcmd = &cobra.Command{ + Use: "forward", + Short: "TCP/UDP端口转发", + Long: "TCP/UDP端口转发", + Run: func(cmd *cobra.Command, args []string) { + t, _ := cmd.Flags().GetBool("tcp") + u, _ := cmd.Flags().GetBool("udp") + p, _ := cmd.Flags().GetInt("port") + a, _ := cmd.Flags().GetString("address") + if len(args) != 1 { + cmd.Help() + return + } + ra := args[0] + if !t && !u { + fmt.Println("请指定TCP或UDP协议") + return + } + + localtcp, err := net.ResolveTCPAddr("tcp", a+":"+strconv.Itoa(p)) + if err != nil { + fmt.Println(err) + return + } + remotetcp, err := net.ResolveTCPAddr("tcp", ra) + if err != nil { + fmt.Println(err) + return + } + localudp, _ := net.ResolveUDPAddr("udp", a+":"+strconv.Itoa(p)) + remoteudp, _ := net.ResolveUDPAddr("udp", ra) + if u { + go UdpForward(localudp, remoteudp) + } + if t { + go TcpForward(localtcp, remotetcp) + } + + for { + time.Sleep(time.Second * 100) + } + }, +} + +var natscmd = &cobra.Command{ + Use: "nats", + Short: "TCP/UDP内网穿透服务端", + Long: "TCP/UDP内网穿透服务端", + Run: func(cmd *cobra.Command, args []string) { + t, _ := cmd.Flags().GetBool("tcp") + u, _ := cmd.Flags().GetBool("udp") + p, _ := cmd.Flags().GetInt("port") + k, _ := cmd.Flags().GetString("key") + a, _ := cmd.Flags().GetString("address") + n, _ := cmd.Flags().GetInt("number") + /*udplocal, err := net.ResolveUDPAddr("udp", a+":"+p) + if err != nil { + fmt.Println(err) + return + } + */ + for i := 0; i < n; i++ { + tcplocal, err := net.ResolveTCPAddr("tcp", a+":"+strconv.Itoa(p+i)) + if err != nil { + fmt.Println(err) + return + } + udplocal, _ := net.ResolveUDPAddr("udp", a+":"+strconv.Itoa(p+i)) + if !t && !u { + fmt.Println("请至少指定一种网络协议！") + return + } + if t { + go TcpNatServer(tcplocal, k) + } + if u { + go UdpNatServer(udplocal, k) + } + } + for { + time.Sleep(time.Second * 10) + } + }, +} + +var natccmd = &cobra.Command{ + Use: "natc", + Short: "TCP/UDP内网穿透客户端", + Long: "TCP/UDP内网穿透客户端", + Run: func(cmd *cobra.Command, args []string) { + t, _ := cmd.Flags().GetBool("tcp") + u, _ := cmd.Flags().GetBool("udp") + p, _ := cmd.Flags().GetInt("port") + k, _ := cmd.Flags().GetString("key") + a, _ := cmd.Flags().GetString("address") + /*udplocal, err := net.ResolveUDPAddr("udp", a+":"+p) + if err != nil { + fmt.Println(err) + return + } + */ + if len(args) != 1 { + cmd.Help() + return + } + if !t && !u { + fmt.Println("请至少指定一种网络协议！") + return + } + tcprmt, err := net.ResolveTCPAddr("tcp", args[0]) + if err != nil { + fmt.Println(err) + return + } + tcpforward, err := net.ResolveTCPAddr("tcp", a+":"+strconv.Itoa(p)) + if err != nil { + fmt.Println(err) + return + } + udprmt, _ := net.ResolveUDPAddr("udp", args[0]) + udpforward, _ := net.ResolveUDPAddr("udp", a+":"+strconv.Itoa(p)) + if t { + go TcpNatClient(tcprmt, tcpforward, k) + } + if u { + go UdpNatClient(udprmt, udpforward, k) + } + for { + time.Sleep(time.Second * 10) + } + }, +} + +type tcpnat struct { + Conn *net.TCPConn + Msg []byte + Date int64 +} + +func UdpNatClient(udpremote, udpforward *net.UDPAddr, pwd string) { + var trueconn *net.UDPConn + var err error + ismain := false + var lastcheck int64 + dialudp := func(udpaddr *net.UDPAddr) (*net.UDPConn, error) { + trueconn, err := net.DialUDP("udp", nil, udpaddr) + if err != nil { + return nil, err + } + return trueconn, nil + } + defer func() { + if err := recover(); err != nil { + fmt.Println("PANIC:", err) + } + }() + for { + trueconn, err = dialudp(udpremote) + if err != nil || trueconn == nil { + time.Sleep(5 * time.Second) + fmt.Println(err) + continue + } + fmt.Println("UDP远端服务器连接成功" + trueconn.RemoteAddr().String()) + trueconn.Write([]byte(pwd)) + go func() { + for !ismain { + time.Sleep(time.Second * 2) + if trueconn != nil { + if ismain { + return + } + _, err := trueconn.Write([]byte(pwd)) + if err != nil { + fmt.Println(err) + return + } + } + } + }() + go func() { + for { + if trueconn == nil { + break + } + var conn1, conn2 *net.UDPConn + buf := make([]byte, 7) + n, err := trueconn.Read(buf) + if n != 7 || err != nil { + fmt.Println(err) + trueconn = nil + ismain = false + fmt.Println("UDP下线01") + break + } + switch string(buf) { + case "yesyesi": + ismain = true + fmt.Println("UDP主节点认证成功") + lastcheck = time.Now().Unix() + go func() { + for { + time.Sleep(time.Second * 2) + if time.Now().Unix()-lastcheck > 4 { + ismain = false + trueconn = nil + fmt.Println("UDP下线02") + return + } + } + }() + case "vicregs": + if trueconn != nil { + trueconn.Write([]byte("vicregs")) + } + lastcheck = time.Now().Unix() + case "newconn": + if !ismain { + trueconn.Close() + break + } + for conn1, err = dialudp(udpforward); err != nil; conn1, err = dialudp(udpforward) { + time.Sleep(time.Second * 2) + } + fmt.Println("UDP已连接转发远端：" + conn1.RemoteAddr().String()) + for conn2, err = dialudp(udpremote); err != nil; conn2, err = dialudp(udpremote) { + time.Sleep(time.Second * 2) + } + conn2.Write([]byte("v%2^f&K")) + fmt.Println("UDP已连接主控远端：" + conn2.RemoteAddr().String()) + go UdpCopy(conn1, conn2) + go UdpCopy(conn2, conn1) + } + } + }() + for ismain || trueconn != nil { + time.Sleep(time.Second * 4) + } + ismain = false + } +} + +func TcpNatClient(tcpremote, tcpforward *net.TCPAddr, pwd string) { + var trueconn *net.TCPConn + var err error + ismain := false + var lastcheck int64 + dialtcp := func(tcpaddr *net.TCPAddr) (*net.TCPConn, error) { + trueconn, err := net.DialTCP("tcp", nil, tcpaddr) + if err != nil { + return nil, err + } + return trueconn, nil + } + defer func() { + if err := recover(); err != nil { + fmt.Println("PANIC:", err) + } + }() + for { + trueconn, err = dialtcp(tcpremote) + if err != nil || trueconn == nil { + fmt.Println(err) + time.Sleep(5 * time.Second) + continue + } + fmt.Println("TCP远端服务器连接成功" + trueconn.RemoteAddr().String()) + n, err := trueconn.Write([]byte(pwd)) + if err != nil || n == 0 { + fmt.Println(err) + continue + } + go func() { + for { + time.Sleep(time.Second * 2) + if !ismain { + if trueconn != nil { + _, err := trueconn.Write([]byte(pwd)) + if err != nil { + return + } + } else { + return + } + } else { + return + } + } + }() + go func() { + for { + if trueconn == nil { + break + } + var conn1, conn2 *net.TCPConn + buf := make([]byte, 7) + n, err := trueconn.Read(buf) + if n != 7 || err != nil { + fmt.Println("TCP下线01") + fmt.Println(err) + trueconn = nil + ismain = false + break + } + switch string(buf) { + case "yesyesi": + ismain = true + fmt.Println("TCP主节点认证成功") + lastcheck = time.Now().Unix() + go func() { + for { + time.Sleep(time.Second) + if time.Now().Unix()-lastcheck > 4 { + fmt.Println("TCP下线02") + ismain = false + trueconn = nil + return + } + } + }() + case "vicb612": + lastcheck = time.Now().Unix() + if trueconn != nil { + trueconn.Write([]byte("vicb612")) + } + case "newconn": + if !ismain { + trueconn.Close() + trueconn = nil + fmt.Println("TCP下线03") + break + } + for conn1, err = dialtcp(tcpforward); err != nil; conn1, err = dialtcp(tcpforward) { + time.Sleep(time.Second * 2) + } + fmt.Println("TCP已连接转发远端：" + conn1.RemoteAddr().String()) + for conn2, err = dialtcp(tcpremote); err != nil; conn2, err = dialtcp(tcpremote) { + time.Sleep(time.Second * 2) + } + conn2.Write([]byte("v%2^f&K")) + fmt.Println("TCP已连接主控远端：" + conn2.RemoteAddr().String()) + go TcpCopy(conn1, conn2) + go TcpCopy(conn2, conn1) + } + } + }() + for ismain || trueconn != nil { + time.Sleep(time.Second * 4) + } + ismain = false + + } +} + +func TcpCopy3(dst net.Conn, src *net.TCPConn) { + defer dst.Close() + defer src.Close() + io.Copy(dst, src) +} + +func TcpCopy2(dst *net.TCPConn, src net.Conn) { + defer src.Close() + defer dst.Close() + io.Copy(dst, src) +} + +func TcpCopy(dst, src *net.TCPConn) { + defer dst.Close() + defer src.Close() + io.Copy(dst, src) +} + +func UdpCopy(dst, src *net.UDPConn) { + defer dst.Close() + defer src.Close() + for { + buf := make([]byte, 131072) + n, err := src.Read(buf) + dst.Write(buf[0:n]) + if err != nil { + fmt.Println(err) + break + } + } +} + +type udpnat struct { + Conn *net.UDPAddr + Msg []byte + Married bool + LastTrans int64 +} + +func UdpNatServer(udplocal *net.UDPAddr, pwd string) { + var trueconn *net.UDPAddr + isconn := false + var lastcheck int64 + udplistener, err := net.ListenUDP("udp", udplocal) + defer udplistener.Close() + if err != nil { + fmt.Println(err) + return + } + udpconnlist := []string{} + udpool := make(map[string]*udpnat) + udpdial := make(map[string]*net.UDPAddr) + fmt.Println("UDP已建立监听：" + udplistener.LocalAddr().String()) + removeudplist := func(str string) { + var tmp []string + for _, v := range udpconnlist { + if v != str { + tmp = append(tmp, str) + } + } + udpconnlist = tmp + } + go func() { + for { + time.Sleep(time.Second * 20) + pool := []string{} + for k, v := range udpool { + if time.Now().Unix()-v.LastTrans > 30 { + pool = append(pool, k) + } + } + for _, v := range pool { + if udpool[v].Married { + delete(udpdial, udpool[v].Conn.String()) + } else { + removeudplist(v) + } + delete(udpool, v) + } + } + }() + for { + buf := make([]byte, 131072) + n, conn, errp := udplistener.ReadFromUDP(buf) + go func() { + if !isconn { + if errp != nil { + return + } + if string(buf[0:len(pwd)]) == pwd && n == len(pwd) { + isconn = true + trueconn = conn + udplistener.WriteToUDP([]byte("yesyesi"), trueconn) + fmt.Println("UDP穿透客户端已注册") + udpool = make(map[string]*udpnat) + udpdial = make(map[string]*net.UDPAddr) + udpconnlist = []string{} + lastcheck = time.Now().Unix() + go func() { + for { + time.Sleep(time.Second * 2) + go udplistener.WriteToUDP([]byte("vicregs"), trueconn) + if time.Now().Unix()-lastcheck > 6 { + fmt.Println("UDP穿透客户端已下线") + fmt.Println("UDP下线01") + isconn = false + break + } + } + }() + } + } else { + if string(buf[0:7]) == "vicregs" { + lastcheck = time.Now().Unix() + return + } + if string(buf[0:7]) == "v%2^f&K" { + fmt.Println("穿透客户端已建立新连接") + if len(udpconnlist) != 0 { + if v, ok := udpool[udpconnlist[0]]; ok { + if !v.Married { + v.Conn = conn + udplistener.WriteToUDP(v.Msg, conn) + v.Msg = []byte{} + udpaddr, _ := net.ResolveUDPAddr("udp", udpconnlist[0]) + udpdial[conn.String()] = udpaddr + v.Married = true + } + } + if len(udpconnlist) == 1 { + udpconnlist = []string{} + } else { + udpconnlist = udpconnlist[1:] + } + } + return + } else { + if v, ok := udpool[conn.String()]; ok { + if !v.Married { + for i := 0; i < n; i++ { + v.Msg = append(v.Msg, buf[i]) + } + if len(v.Msg) > 10485760 { + v.Msg = []byte{} + } + } else { + _, err := udplistener.WriteToUDP(buf[0:n], v.Conn) + v.LastTrans = time.Now().Unix() + if errp != nil || err != nil { + fmt.Println(errp, err) + udplistener.WriteToUDP(nil, v.Conn) + udplistener.WriteToUDP(nil, conn) + delete(udpool, conn.String()) + delete(udpdial, v.Conn.String()) + return + } + } + return + } + if v, ok := udpdial[conn.String()]; ok { + _, err := udplistener.WriteToUDP(buf[0:n], v) + udpool[v.String()].LastTrans = time.Now().Unix() + if errp != nil || err != nil { + fmt.Println(errp, err) + udplistener.WriteToUDP(nil, v) + udplistener.WriteToUDP(nil, conn) + delete(udpool, v.String()) + delete(udpdial, conn.String()) + return + } + return + } + fmt.Println("链接已加入等待列表") + udpool[conn.String()] = &udpnat{ + Msg: buf[0:n], + Married: false, + LastTrans: time.Now().Unix(), + } + udpconnlist = append(udpconnlist, conn.String()) + _, err := udplistener.WriteToUDP([]byte("newconn"), trueconn) + if err != nil { + fmt.Println("UDP穿透客户端已下线") + fmt.Println("UDP下线02") + isconn = false + } + } + } + }() + } + fmt.Println("执行完毕") +} + +func TcpNatServer(tcplocal *net.TCPAddr, pwd string) { + var trueconn *net.TCPConn + lastcheck := int64(0) + isconn := false + tcplistener, err := net.ListenTCP("tcp", tcplocal) + defer tcplistener.Close() + var waitconn []tcpnat + if err != nil { + fmt.Println(err) + return + } + fmt.Println("TCP已建立监听：" + tcplistener.Addr().String()) + for { + conn, err := tcplistener.AcceptTCP() + if err != nil { + return + } + go func() { + for { + now := time.Now().Unix() + if len(waitconn) != 0 { + if now-waitconn[0].Date > 8 { + waitconn[0].Conn.Close() + if len(waitconn) > 1 { + waitconn = waitconn[1:] + } else { + waitconn = []tcpnat{} + } + } + } + time.Sleep(time.Second * 2) + } + }() + go func() { + if !isconn { + buf := make([]byte, len(pwd)+1) + n, err := conn.Read(buf) + if n != len(pwd) || err != nil { + conn.Close() + return + } + if string(buf[0:len(pwd)]) == pwd { + isconn = true + trueconn = conn + conn.Write([]byte("yesyesi")) + fmt.Println("TCP穿透客户端已注册") + lastcheck = time.Now().Unix() + go func() { + for isconn && trueconn != nil { + buf := make([]byte, 7) + n, err := trueconn.Read(buf) + if n != 7 || err != nil { + isconn = false + trueconn = nil + return + } + if string(buf) == "vicb612" { + lastcheck = time.Now().Unix() + } + } + }() + go func() { + for { + time.Sleep(time.Second * 2) + if trueconn != nil { + _, err := trueconn.Write([]byte("vicb612")) + if err != nil { + trueconn.Close() + trueconn = nil + isconn = false + fmt.Println("TCP下线01") + return + } + } + if time.Now().Unix()-lastcheck > 4 { + fmt.Println("TCP下线02") + trueconn = nil + isconn = false + return + } + } + }() + } + return + } else { + isRun := false + buf := make([]byte, 7) + if strings.Split(conn.RemoteAddr().String(), ":")[0] == strings.Split(trueconn.RemoteAddr().String(), ":")[0] { + isRun = true + n, err := conn.Read(buf) + if n != 7 || err != nil { + conn.Close() + return + } + } + if string(buf) == "v%2^f&K" { + fmt.Println("穿透客户端已建立新连接") + if len(waitconn) != 0 { + if waitconn[0].Msg != nil { + conn.Write(waitconn[0].Msg) + } + waitconn[0].Msg = []byte{} + go TcpCopy(waitconn[0].Conn, conn) + go TcpCopy(conn, waitconn[0].Conn) + if len(waitconn) > 1 { + waitconn = waitconn[1:] + } else { + waitconn = []tcpnat{} + } + } else { + conn.Close() + } + } else { + fmt.Println("链接已加入等待列表") + var tcpnats tcpnat + if isRun { + tcpnats = tcpnat{Msg: buf, Conn: conn, Date: time.Now().Unix()} + } else { + tcpnats = tcpnat{Msg: nil, Conn: conn, Date: time.Now().Unix()} + } + waitconn = append(waitconn, tcpnats) + if trueconn == nil { + isconn = false + fmt.Println("TCP下线04") + return + } + _, err := trueconn.Write([]byte("newconn")) + if err != nil { + fmt.Println("穿透客户端已下线") + fmt.Println("TCP下线03") + trueconn.Close() + trueconn = nil + isconn = false + } + } + } + }() + } + +} + +func TcpForward(tcplocal, tcpforward *net.TCPAddr) { + tcplistener, err := net.ListenTCP("tcp", tcplocal) + if err != nil { + fmt.Println(err) + return + } + dialtcp := func() (*net.Conn, error) { + tcpclient, err := net.DialTimeout("tcp", tcpforward.String(), time.Second*10) + if err != nil { + return nil, err + } + return &tcpclient, nil + } + fmt.Println("TCP监听已建立：" + tcplocal.String()) + for { + conn, err := tcplistener.AcceptTCP() + if err != nil { + continue + } + fmt.Println(conn.RemoteAddr().String() + " 已连接") + tcpclient, err := dialtcp() + if err != nil { + fmt.Println(err) + conn.Write([]byte("Dial To Remote Addr Error")) + conn.Close() + continue + } + fmt.Println("成功连接到转发端口，本地端口：" + (*tcpclient).LocalAddr().String()) + go TcpCopy2(conn, *tcpclient) + go TcpCopy3(*tcpclient, conn) + } +} + +func UdpForward(udplocal, udpforward *net.UDPAddr) { + udplistener, err := net.ListenUDP("udp", udplocal) + if err != nil { + fmt.Println(err) + return + } + dialudp := func() (*net.UDPConn, error) { + udpclient, err := net.DialUDP("udp", nil, udpforward) + if err != nil { + return nil, err + } + return udpclient, nil + } + fmt.Println("UDP监听已建立：" + udplocal.String()) + udppool := make(map[string]*net.UDPConn) + for { + buf := make([]byte, 131072) + n, conn, err := udplistener.ReadFromUDP(buf) + udpclient, ok := udppool[conn.String()] + if !ok || udpclient == nil { + fmt.Println(conn.String() + " 已连接") + udpclient, err = dialudp() + if err != nil { + fmt.Println(err) + udplistener.WriteToUDP([]byte("Dial To Remote Addr Error"), conn) + continue + } + udppool[conn.String()] = udpclient + fmt.Println("成功连接到转发端口，本地端口：" + udpclient.LocalAddr().String()) + } + go udpclient.Write(buf[0:n]) + go func(conns *net.UDPAddr, udpclient *net.UDPConn) { + bufs := make([]byte, 131072) + n, err := udpclient.Read(bufs) + udplistener.WriteToUDP(bufs[0:n], conns) + if err != nil { + udpclient.Close() + udppool[conn.String()] = nil + } + }(conn, udpclient) + if err != nil { + udpclient.Close() + udppool[conn.String()] = nil + } + } +} diff --git a/vtqe/sftp.go b/vtqe/sftp.go new file mode 100644 index 0000000..b7f5970 --- /dev/null +++ b/vtqe/sftp.go @@ -0,0 +1,172 @@ +package main + +import ( + "fmt" + "io/ioutil" + "os" + "path/filepath" + "regexp" + "runtime" + "strings" + + "b612.me/starainrt" + + "b612.me/sshd" + + "github.com/spf13/cobra" +) + +var sftpcmd = &cobra.Command{ + Use: "sftp", + Short: "sftp上传下载", + Long: "sftp上传下载", + Run: func(this *cobra.Command, args []string) { + d, _ := this.Flags().GetBool("download") + s, _ := this.Flags().GetString("src") + r, _ := this.Flags().GetString("dst") + i, _ := this.Flags().GetString("identify") + k, _ := this.Flags().GetString("password") + p, _ := this.Flags().GetInt("port") + b, _ := this.Flags().GetInt("buffer") + g, _ := this.Flags().GetString("regexp") + var user, host string + var err error + if len(args) != 1 { + fmt.Println("sftp <[user@]Host> -s -d ") + this.Help() + return + } + hosts := strings.Split(args[0], "@") + if len(hosts) == 1 { + host = hosts[0] + user = "root" + } else { + user = hosts[0] + host = hosts[1] + } + fmt.Println("进行SSH连接……") + myssh := new(sshd.StarSSH) + err = myssh.Connect(user, k, host, i, p) + if err != nil { + fmt.Println(err) + return + } + defer myssh.Close() + fmt.Println("已连接上……") + sftp, err := sshd.CreateSftp(myssh.Client) + if err != nil { + fmt.Println(err) + return + } + defer sftp.Close() + fmt.Println("已建立SFTP……") + + shell := func(pect float64) { + if pect != 100.0 { + fmt.Printf("传输已完成：%f%%\r", pect) + } else { + fmt.Printf("传输已完成：%f%%\n", pect) + } + } + var UploadDir func(string, string) + UploadDir = func(fs, remote string) { + if runtime.GOOS == "windows" { + fs = strings.Replace(fs, "/", "\\", -1) + } + sftp.MkdirAll(remote) + abspath, _ := filepath.Abs(fs) + dir, err := ioutil.ReadDir(fs) + if err != nil { + fmt.Println(err) + return + } + for _, v := range dir { + if v.IsDir() { + if g != "" { + continue + } + UploadDir(abspath+string(os.PathSeparator)+v.Name(), remote+"/"+v.Name()) + } else { + if ok, _ := regexp.MatchString(g, v.Name()); !ok { + continue + } + fmt.Println("上传:" + abspath + string(os.PathSeparator) + v.Name()) + err = sshd.FtpTransferOutFunc(abspath+string(os.PathSeparator)+v.Name(), remote+"/"+v.Name(), b, shell, sftp) + if err != nil { + fmt.Println(err) + continue + } + } + } + } + + var DownloadDir func(string, string) + DownloadDir = func(fs, remote string) { + abspath, _ := filepath.Abs(remote) + os.MkdirAll(abspath, 0755) + dir, err := sftp.ReadDir(fs) + if err != nil { + fmt.Println("读取错误", err) + return + } + for _, v := range dir { + if v.IsDir() { + if g != "" { + continue + } + DownloadDir(fs+"/"+v.Name(), abspath+string(os.PathSeparator)+v.Name()) + } else { + if ok, _ := regexp.MatchString(g, v.Name()); !ok { + continue + } + fmt.Println("下载:" + fs + "/" + v.Name()) + err = sshd.FtpTransferInFunc(fs+"/"+v.Name(), abspath+string(os.PathSeparator)+v.Name(), b, shell, sftp) + if err != nil { + fmt.Println(err) + continue + } + } + } + } + if !d { + if !starainrt.Exists(s) { + fmt.Println("本地文件或文件夹：" + s + "不存在") + return + } + if starainrt.IsFile(s) { + err = sshd.FtpTransferOutFunc(s, r, b, shell, sftp) + } else { + UploadDir(s, r) + } + } else { + if !myssh.Exists(s) { + fmt.Println("远端文件或文件夹：" + s + "不存在") + return + } + stat, err := sftp.Stat(s) + if err != nil { + fmt.Println("错误:", err) + return + } + if !stat.IsDir() { + err = sshd.FtpTransferInFunc(s, r, b, shell, sftp) + } else { + DownloadDir(s, r) + } + } + if err != nil { + fmt.Println(err) + } + }, +} + +func init() { + sftpcmd.Flags().BoolP("download", "D", false, "进行下载") + sftpcmd.Flags().StringP("identify", "i", "", "RSA登录密钥") + sftpcmd.Flags().StringP("password", "k", "", "登录密码") + sftpcmd.Flags().StringP("src", "s", "", "本机路径/若为下载则相反") + sftpcmd.Flags().StringP("dst", "d", "", "远程路径/若为下载则相反") + sftpcmd.Flags().IntP("port", "p", 22, "登录端口") + sftpcmd.Flags().StringP("regexp", "r", "", "正则表达式") + sftpcmd.Flags().IntP("buffer", "b", 10240, "buffer大小") +} diff --git a/vtqe/split.go b/vtqe/split.go new file mode 100644 index 0000000..3a55fa7 --- /dev/null +++ b/vtqe/split.go @@ -0,0 +1,60 @@ +package main + +import ( + "fmt" + "strconv" + + "b612.me/starainrt" + "b612.me/starlog" + + "github.com/spf13/cobra" +) + +var splitcmd = &cobra.Command{ + Use: "split", + Short: "分割文件", + Long: "按字节或文件数分割文件", + Run: func(this *cobra.Command, args []string) { + var src, dst string + var num int + if len(args) == 3 { + src = args[0] + dst = args[1] + num, _ = strconv.Atoi(args[2]) + } else { + src, _ = this.Flags().GetString("src") + dst, _ = this.Flags().GetString("dst") + num, _ = this.Flags().GetInt("num") + } + if !starainrt.Exists(src) { + starlog.Errorln("源文件不存在") + this.Help() + return + } + if num == 0 { + starlog.Errorln("参数num不合法", "red") + this.Help() + return + } + crypto := new(starainrt.StarCrypto) + ok, _ := this.Flags().GetBool("byte") + err := crypto.SplitFile(src, dst, num, !ok, func(pect float64) { + if pect == 100 { + fmt.Println("文件已处理：100.000000%") + } else { + fmt.Printf("文件已处理：%f%%\r", pect) + } + }) + if err != nil { + starlog.Errorln(err.Error) + } + + }, +} + +func init() { + splitcmd.Flags().StringP("src", "s", "", "源文件地址") + splitcmd.Flags().StringP("dst", "d", "./split*.vicque", "目标文件地址，用*替换文件数字") + splitcmd.Flags().BoolP("byte", "b", false, "按byte分割") + splitcmd.Flags().IntP("num", "n", 0, "分割数/byte数") +} diff --git a/vtqe/tcp.go b/vtqe/tcp.go new file mode 100644 index 0000000..0a002aa --- /dev/null +++ b/vtqe/tcp.go @@ -0,0 +1,442 @@ +package main + +import ( + "fmt" + "io" + "io/ioutil" + "net" + "os" + "path/filepath" + "regexp" + "runtime" + "strconv" + "strings" + "time" + + "b612.me/starainrt" + "b612.me/starlog" + + "github.com/spf13/cobra" +) + +var tcpcmd = &cobra.Command{ + Use: "tcp", + Short: "发送并监听tcp数据包", + Long: "发送并监听tcp数据包", + Run: func(this *cobra.Command, args []string) { + r, _ := this.Flags().GetBool("recvonly") + if len(args) != 1 && !r { + fmt.Println("请指定远程tcp地址") + return + } + l, _ := this.Flags().GetString("port") + a, _ := this.Flags().GetString("addr") + s, _ := this.Flags().GetBool("local") + b, _ := this.Flags().GetBool("byte") + laddr, err := net.ResolveTCPAddr("tcp", a+":"+l) + if err != nil { + fmt.Println(err) + return + } + if s { + tcplisten, err := net.ListenTCP("tcp", laddr) + if err != nil { + fmt.Println(err) + return + } + fmt.Println("监听已建立") + defer tcplisten.Close() + go func() { + for { + conn, err := tcplisten.AcceptTCP() + if err != nil { + fmt.Printf("Error Connect From %s : %s\n", conn.RemoteAddr(), err.Error()) + continue + } + starlog.Infof("Accept Connect From %s\n", conn.RemoteAddr()) + go func(conns *net.TCPConn) { + for { + buf := make([]byte, 204800) + n, err := conns.Read(buf) + if err != nil { + starlog.Infof("Error from %s Where Message=%s\n", conns.RemoteAddr(), err.Error()) + conn.Close() + return + } + starlog.Infof("Receive Msg From %s : %s\n", conns.RemoteAddr(), string(buf[0:n])) + if b { + starlog.Infof("%#v", buf[0:n]) + } + } + + }(conn) + } + }() + } + if !r { + mytcp, err := net.DialTimeout("tcp", args[0], time.Second*15) + if err != nil { + fmt.Println(err) + if s { + for { + time.Sleep(time.Second * 10) + } + } + return + } + defer mytcp.Close() + fmt.Println("TCP连接已建立") + go func() { + var err error + for { + txt := starainrt.MessageBox("", "") + if txt == "" { + continue + } + if !b { + _, err = mytcp.Write([]byte(txt)) + } else { + var sendbyte []byte + bytes := strings.Split(txt, ",") + for _, v := range bytes { + ints, _ := strconv.Atoi(v) + if ints < 0 || ints > 255 { + continue + } + sendbyte = append(sendbyte, byte(ints)) + } + _, err = mytcp.Write(sendbyte) + } + if err != nil { + starlog.Errorf("Error from %s Where Message=%s\n", mytcp.RemoteAddr().String(), err.Error()) + return + } + } + }() + for { + buf := make([]byte, 204800) + n, err := mytcp.Read(buf) + if err != nil { + starlog.Errorf("Error from %s Where Message=%s\n", mytcp.RemoteAddr().String(), err.Error()) + return + } + + starlog.Infof("Receive Msg From %s : %s\n", mytcp.RemoteAddr().String(), string(buf[0:n])) + if b { + starlog.Infof("%#v", buf[0:n]) + } + } + } else { + for { + time.Sleep(time.Second) + } + } + }, +} + +/* + + */ + +func init() { + tcpcmd.Flags().BoolP("byte", "b", false, "发送二进制数据") + tcpcmd.Flags().StringP("port", "p", "1127", "本地监听端口") + tcpcmd.Flags().StringP("addr", "a", "0.0.0.0", "本地监听ip") + tcpcmd.Flags().BoolP("local", "s", false, "启动本地监听") + tcpsendcmd.Flags().StringP("port", "p", "1127", "远程连接端口") + tcpsendcmd.Flags().StringP("addr", "a", "0.0.0.0", "远程监听ip") + tcpsendcmd.Flags().StringP("regexp", "r", "", "正则匹配字符串") + tcprecvcmd.Flags().StringP("port", "p", "1127", "本地监听端口") + tcprecvcmd.Flags().StringP("addr", "a", "0.0.0.0", "本地监听ip") + tcpcmd.Flags().BoolP("recvonly", "r", false, "仅接收udp包") + tcpcmd.AddCommand(tcpsendcmd, tcprecvcmd) +} + +var cansend, backsck, foldercreate bool = false, false, false +var tcpsendcmd = &cobra.Command{ + Use: "send", + Short: "通过tcp发送文件", + Long: "通过tcp接受文件", + Run: func(this *cobra.Command, args []string) { + stop := false + p, _ := this.Flags().GetString("port") + a, _ := this.Flags().GetString("addr") + r, _ := this.Flags().GetString("regexp") + if len(args) != 1 { + this.Help() + return + } + mytcp, err := net.DialTimeout("tcp", a+":"+p, time.Second*15) + if err != nil { + fmt.Println(err) + return + } + fmt.Println("TCP连接已建立") + defer mytcp.Close() + go func() { + for { + buf := make([]byte, 1048576) + n, err := mytcp.Read(buf) + if err != nil { + if !stop { + fmt.Println(err) + os.Exit(1) + } + continue + } + data := string(buf[0:n]) + if data == "oksend!" { + cansend = true + } else if data == "backsck" { + backsck = true + } else if data == "folderok" { + foldercreate = true + } else { + fmt.Println(data) + os.Exit(1) + } + } + }() + file := args[0] + if file[len(file)-1:] == "\\" || file[len(file)-1:] == "/" { + file = file[0 : len(file)-1] + } + file, _ = filepath.Abs(file) + Scan(file, "", mytcp, r) + stop = true + mytcp.Write([]byte("jane&0&0")) + return + }, +} + +func tcpupload(file, prefix string, mytcp net.Conn) error { + if runtime.GOOS == "windows" { + file = strings.Replace(file, "/", "\\", -1) + prefix = strings.Replace(prefix, "/", "\\", -1) + } + fmt.Println(file) + fpsrc, err := os.Open(file) + if err != nil { + fmt.Println(err) + return err + } + stat, _ := os.Stat(file) + filebig := float64(stat.Size()) + _, err = mytcp.Write([]byte("victorique&" + stat.Name() + "&" + prefix)) + if err != nil { + fmt.Println(err) + return err + } + var sakura int = 0 + for !cansend { + time.Sleep(time.Millisecond * 100) + sakura++ + if sakura > 50 { + mytcp.Write([]byte{1, 9, 9, 6, 1, 1, 2, 7}) + time.Sleep(time.Millisecond * 100) + mytcp.Write([]byte("victorique&" + stat.Name() + "&" + prefix)) + } + } + cansend = false + sum := 0 + for { + buf := make([]byte, 524288) + n, err := fpsrc.Read(buf) + if err != nil { + if err == io.EOF { + err = nil + mytcp.Write([]byte{1, 9, 9, 6, 1, 1, 2, 7}) + for !backsck { + time.Sleep(time.Millisecond * 150) + } + backsck = false + break + } + fmt.Println(err) + return err + } + _, err = mytcp.Write(buf[0:n]) + if err != nil { + fmt.Println(err) + return err + } + sum += n + fmt.Printf("当前已传输：%f\r", float64(sum)/filebig*100) + } + fmt.Printf("当前已传输：%f\n\n", 100.000000) + fpsrc.Close() + return nil +} + +func Scan(path, prefix string, mytcp net.Conn, reg string) { + var err error + var regp *regexp.Regexp + if prefix != "" { + prefix += "/" + } + if reg != "" { + regp, err = regexp.Compile(reg) + if err != nil { + fmt.Println(err) + return + } + } + if runtime.GOOS == "windows" { + path = strings.Replace(path, "/", "\\", -1) + prefix = strings.Replace(prefix, "/", "\\", -1) + } + if starainrt.IsFile(path) { + if reg != "" { + if regp.MatchString(path) { + tcpupload(path, prefix, mytcp) + } + } else { + tcpupload(path, prefix, mytcp) + } + } else if starainrt.IsFolder(path) { + dir, err := ioutil.ReadDir(path) + if err != nil { + fmt.Println(err) + return + } + for _, v := range dir { + if v.IsDir() && (v.Name() != "." || v.Name() != "..") { + mytcp.Write([]byte("b612&" + prefix + v.Name() + "&0")) + count := 0 + for !foldercreate { + time.Sleep(time.Millisecond * 100) + count++ + if count%30 == 0 { + mytcp.Write([]byte("b612&" + prefix + v.Name() + "&0")) + } + } + foldercreate = false + Scan(path+"/"+v.Name(), prefix+v.Name(), mytcp, reg) + } else { + if reg != "" { + if regp.MatchString(path + "/" + v.Name()) { + err = tcpupload(path+"/"+v.Name(), prefix, mytcp) + } + } else { + err = tcpupload(path+"/"+v.Name(), prefix, mytcp) + } + if err != nil { + fmt.Println(err) + return + } + } + } + } + +} + +var tcprecvcmd = &cobra.Command{ + Use: "recv", + Short: "通过tcp接收文件", + Long: "通过tcp接收文件", + Run: func(this *cobra.Command, args []string) { + p, _ := this.Flags().GetString("port") + a, _ := this.Flags().GetString("addr") + laddr, err := net.ResolveTCPAddr("tcp", a+":"+p) + if err != nil { + fmt.Println(err) + return + } + tcplisten, err := net.ListenTCP("tcp", laddr) + if err != nil { + fmt.Println(err) + return + } + fmt.Println("TCP监听已建立") + defer tcplisten.Close() + for { + conn, err := tcplisten.AcceptTCP() + if err != nil { + fmt.Printf("Error Connect From %s : %s\n", conn.RemoteAddr(), err.Error()) + continue + } + fmt.Printf("Accept Connect From %s\n", conn.RemoteAddr()) + go func(conns *net.TCPConn) { + canrecv := false + name := "" + var fpdst *os.File + defer conns.Close() + var sum int64 + for { + buf := make([]byte, 393216) + n, err := conns.Read(buf) + + if !canrecv { + if err != nil { + fmt.Println(err) + return + } + data := string(buf[0:n]) + str := strings.Split(data, "&") + if len(str) != 3 { + continue + } + if str[0] == "victorique" { + canrecv = true + name = str[1] + prefix := str[2] + if runtime.GOOS != "windows" { + prefix = strings.Replace(prefix, "\\", "/", -1) + } + if prefix == "" { + fpdst, err = os.Create("./" + name) + } else { + fpdst, err = os.Create(prefix + name) + } + if err != nil { + fmt.Println(err) + conns.Write([]byte(err.Error())) + return + } + conns.Write([]byte("oksend!")) + } else if str[0] == "b612" { + str[1] = ".\\" + str[1] + if runtime.GOOS != "windows" { + str[1] = strings.Replace(str[1], "\\", "/", -1) + } + fmt.Println("进入文件夹：" + str[1] + "\n") + os.MkdirAll(str[1], 0644) + time.Sleep(time.Millisecond * 50) + conns.Write([]byte("folderok")) + } else if str[0] == "jane" { + return + } + } else { + if buf[n-1] == byte(7) && buf[n-2] == byte(2) && buf[n-3] == byte(1) { + ok := func() bool { + for k, v := range []byte{1, 9, 9, 6, 1, 1, 2, 7} { + if buf[n-8+k] != v { + return false + } + } + return true + }() + if ok { + if n > 8 { + fpdst.Write(buf[0 : n-8]) + sum += int64(n - 8) + } + fmt.Printf("已写入:%d 字节\n", sum) + fmt.Println(name + "接收成功\n") + fpdst.Close() + canrecv = false + sum = 0 + conns.Write([]byte("backsck")) + continue + } + } + fpdst.Write(buf[0:n]) + sum += int64(n) + fmt.Printf("已写入:%d 字节\r", sum) + } + } + }(conn) + } + + }, +} diff --git a/vtqe/uac.go b/vtqe/uac.go new file mode 100644 index 0000000..86a4ef9 --- /dev/null +++ b/vtqe/uac.go @@ -0,0 +1,33 @@ +// +build windows + +package main + +import ( + "os" + + "b612.me/wincmd" + "github.com/spf13/cobra" +) + +var uaccmd = &cobra.Command{ + Use: "uac", + Short: "Windows 使用uac权限打开文件", + Long: "Windows 使用uac权限打开文件", + Run: func(this *cobra.Command, args []string) { + if len(args) == 0 { + return + } + cmdLine := "" + if len(args) > 1 { + for _, v := range args[1:] { + cmdLine += v + " " + } + } + pwd, _ := os.Getwd() + wincmd.StartProcess(args[0], cmdLine, pwd, true, 1) + }, +} + +func init() { + cmdMain.AddCommand(uaccmd) +} diff --git a/vtqe/udp.go b/vtqe/udp.go new file mode 100644 index 0000000..40fef4b --- /dev/null +++ b/vtqe/udp.go @@ -0,0 +1,126 @@ +package main + +import ( + "fmt" + "net" + "strconv" + "strings" + "time" + + "b612.me/starainrt" + "b612.me/starlog" + + "github.com/spf13/cobra" +) + +var udpcmd = &cobra.Command{ + Use: "udp", + Short: "发送并监听udp数据包", + Long: "发送并监听udp数据包", + Run: func(this *cobra.Command, args []string) { + var raddr *net.UDPAddr + r, _ := this.Flags().GetBool("recvonly") + if len(args) != 1 && !r { + fmt.Println("请指定远程udp地址") + return + } + l, _ := this.Flags().GetString("port") + a, _ := this.Flags().GetString("addr") + s, _ := this.Flags().GetBool("local") + b, _ := this.Flags().GetBool("byte") + laddr, err := net.ResolveUDPAddr("udp", a+":"+l) + if !r { + raddr, err = net.ResolveUDPAddr("udp", args[0]) + } + if err != nil { + fmt.Println(err) + return + } + if s { + udplisten, err := net.ListenUDP("udp", laddr) + if err != nil { + fmt.Println(err) + return + } + fmt.Println("监听已建立") + go func() { + for { + buf := make([]byte, 204800) + n, addr, err := udplisten.ReadFromUDP(buf) + if err != nil { + starlog.Errorln("Error from %s Where Message=%s\n", addr.String(), err.Error()) + continue + } + starlog.Infof("Receive Msg From %s : %s\n", addr.String(), string(buf[0:n])) + if b { + starlog.Infof("%#v\n", buf[0:n]) + } + } + }() + } + if !r { + myudp, err := net.DialUDP("udp", nil, raddr) + if err != nil { + fmt.Println(err) + return + } + fmt.Println("UDP虚拟连接已建立") + go func() { + var err error + for { + txt := starainrt.MessageBox("", "") + if txt == "" { + continue + } + if !b { + _, err = myudp.Write([]byte(txt)) + } else { + var sendbyte []byte + bytes := strings.Split(txt, ",") + for _, v := range bytes { + ints, _ := strconv.Atoi(v) + if ints < 0 || ints > 255 { + continue + } + sendbyte = append(sendbyte, byte(ints)) + } + _, err = myudp.Write(sendbyte) + } + if err != nil { + fmt.Printf("Error from %s Where Message=%s\n", myudp.RemoteAddr().String(), err.Error()) + return + } + } + }() + for { + buf := make([]byte, 204800) + n, err := myudp.Read(buf) + if err != nil { + starlog.Infof("Error from %s Where Message=%s\n", myudp.RemoteAddr().String(), err.Error()) + return + } + + starlog.Infof("Receive Msg From %s : %s\n", myudp.RemoteAddr().String(), string(buf[0:n])) + if b { + starlog.Infof("%#v", buf[0:n]) + } + } + } else { + for { + time.Sleep(time.Second) + } + } + }, +} + +/* + + */ + +func init() { + udpcmd.Flags().BoolP("byte", "b", false, "发送二进制数据") + udpcmd.Flags().StringP("port", "p", "1127", "本地监听端口") + udpcmd.Flags().StringP("addr", "a", "0.0.0.0", "本地监听ip") + udpcmd.Flags().BoolP("local", "s", false, "启动本地监听") + udpcmd.Flags().BoolP("recvonly", "r", false, "仅接收udp包") +} diff --git a/vtqe/vic.go b/vtqe/vic.go new file mode 100644 index 0000000..70999f2 --- /dev/null +++ b/vtqe/vic.go @@ -0,0 +1,94 @@ +package main + +import ( + "fmt" + "os" + "regexp" + + "b612.me/starainrt" + "b612.me/starlog" + "github.com/spf13/cobra" +) + +var viccmd = &cobra.Command{ + Use: "vicque", + Short: "嵐を乗り越えて", + Long: "あの子の未来を照らし出せ", + Run: func(this *cobra.Command, args []string) { + var err error + ok, _ := this.Flags().GetBool("file") + de, _ := this.Flags().GetBool("decode") + pwd, _ := this.Flags().GetString("key") + rep, _ := this.Flags().GetBool("replace") + ext, _ := this.Flags().GetBool("extension") + if len(args) != 2 || args[1] != "sakura" { + starlog.Errorln("ヴィクトリカだけが使えるよ") + return + } + shell := func(pect float64) { + if pect == 100 { + fmt.Println("已处理：100.000000%") + } else { + fmt.Printf("已处理：%f%%\r", pect) + } + } + cry := new(starainrt.StarCrypto) + if ok { + path, _ := this.Flags().GetString("path") + if !de { + err = cry.VicqueEncodeV1File(args[0], path, pwd, shell) + if err == nil { + if rep { + os.Remove(args[0]) + os.Rename(path, args[0]) + path = args[0] + } + if ext { + os.Rename(path, path+".victorique") + } + } + } else { + err = cry.VicqueDecodeV1File(args[0], path, pwd, shell) + if err == nil { + if rep { + os.Remove(args[0]) + os.Rename(path, args[0]) + path = args[0] + } + if ext { + reg := regexp.MustCompile(`(.*?)\.victorique$`) + if reg.MatchString(path) { + paths := reg.FindStringSubmatch(path) + os.Rename(path, paths[1]) + } + } + } + } + } else { + if !de { + data := cry.VicqueEncodeV1([]byte(args[0]), pwd) + fmt.Println(data) + fmt.Println(cry.Base64Encode(data)) + } else { + var data []byte + src, _ := cry.Base64Decode(args[0]) + data = cry.VicqueDecodeV1(src, pwd) + fmt.Println(string(data)) + } + } + if err != nil { + starlog.Errorln(err) + return + } + }, +} + +func init() { + viccmd.Flags().BoolP("file", "f", false, "VICQUE处理文件") + viccmd.Flags().StringP("path", "p", "./v64.encode", "指定处理地址，默认为./v64.encode") + viccmd.Flags().BoolP("decode", "d", false, "VICQUE解码") + viccmd.Flags().StringP("key", "k", "", "密钥") + viccmd.Flags().BoolP("replace", "r", false, "覆盖原文件") + viccmd.Flags().BoolP("extension", "e", false, "添加/取消.victorique后缀") + viccmd.MarkFlagRequired("key") +}