From 941d54b88640c01aee2cfa94e266d877d359c2b9 Mon Sep 17 00:00:00 2001 From: ren yuze Date: Thu, 21 Feb 2019 09:35:41 +0800 Subject: [PATCH] update kokan cmd --- starainrt.go | 1854 ++++++++++++++++++++++++++------------------------ 1 file changed, 981 insertions(+), 873 deletions(-) diff --git a/starainrt.go b/starainrt.go index d2ec483..6d1d069 100644 --- a/starainrt.go +++ b/starainrt.go @@ -1,873 +1,981 @@ -package starainrt - -import ( - "bufio" - "bytes" - "crypto/md5" - "crypto/rc4" - "crypto/sha1" - "crypto/sha256" - "crypto/sha512" - "database/sql" - "errors" - "encoding/base64" - "encoding/hex" - "fmt" - "hash/crc32" - "io" - "io/ioutil" - "net" - "net/http" - "os" - "regexp" - "strconv" - "strings" - "time" - -) - -var HttpNul, HttpNul2 map[string]string -var HttpTimeOut int64 = 15 -var DBRes *sql.DB -var DBRows *sql.Rows - -func Exists(filepath string) bool { - _, err := os.Stat(filepath) - if err != nil && os.IsNotExist(err) { - return false - } - return true -} -func IsFile(fpath string) bool { - s, err := os.Stat(fpath) - if err != nil { - return false - } - return !s.IsDir() -} -func IsFolder(fpath string) bool { - s, err := os.Stat(fpath) - if err != nil { - return false - } - return s.IsDir() -} -func ReWriteFileByKV(filepath, rem, conn, ret string, kv map[string]string) bool { - var outputstr string - var ataru bool = false - if (!Exists(filepath)) || (!IsFile(filepath)) { - return false - } - fso, err := os.Open(filepath) - if err != nil { - return false - } - rempar := regexp.MustCompile("^" + rem) - buf := bufio.NewReader(fso) - for { - bytxt, _, eof := buf.ReadLine() - if eof == io.EOF { - break - } - txt := strings.TrimSpace(string(bytxt)) - if rempar.Match([]byte(txt)) { - outputstr += txt + ret - continue - } - for k, v := range kv { - keypar := regexp.MustCompile("^" + k) - if keypar.Match([]byte(txt)) { - ataru = true - outputstr += k + conn + v + ret - delete(kv, k) - } - } - if ataru { - ataru = false - continue - } else { - outputstr += txt + ret - } - } - fso.Close() - if len(kv) != 0 { - for k, v := range kv { - outputstr += k + conn + v + ret - delete(kv, k) - } - } - err = ioutil.WriteFile(filepath, []byte(outputstr), 0755) - if err != nil { - return false - } - return true -} - -func GetINIValue(filepath, rem, conn string, kv []string) (bool, map[string]string) { - outputstr := make(map[string]string) - if (!Exists(filepath)) || (!IsFile(filepath)) { - return false, outputstr - } - fso, err := os.Open(filepath) - if err != nil { - return false, outputstr - } - rempar := regexp.MustCompile("^" + rem) - buf := bufio.NewReader(fso) - for { - bytxt, _, eof := buf.ReadLine() - if eof == io.EOF { - break - } - txt := strings.TrimSpace(string(bytxt)) - if rempar.Match([]byte(txt)) { - continue - } - var i int = 0 - var v2 string - for k, v := range kv { - if v == "" { - continue - } - v2 = "" - for _, b := range []byte(v) { - switch string(b) { - case ".": - v2 += "\\." - case "\\": - v2 += "\\" - case "-": - v2 += "\\-" - case "(": - v2 += "\\(" - case ")": - v2 += "\\)" - case "{": - v2 += "\\{" - case "}": - v2 += "\\}" - case "[": - v2 += "\\[" - case "]": - v2 += "\\]" - case "$": - v2 += "\\]$" - case "^": - v2 += "\\^" - default: - v2 += string(b) - } - } - keypar := regexp.MustCompile("^" + v2 + ".*?" + conn + "(.*)") - if keypar.Match([]byte(txt)) { - i++ - kekka := keypar.FindSubmatch([]byte(txt)) - outputstr[v] = string(kekka[1]) - kv[k] = "" - } - } - if i != len(kv) { - for _, v := range kv { - if v != "" { - outputstr[v] = "" - } - } - } - } - return true, outputstr -} - -func SmallEncodeFileByBase64(filepath, outputname string, buffer int) bool { - if !Exists(filepath) { - return false - } - rempar := regexp.MustCompile(`(.*)\*(.*)`) - if !rempar.Match([]byte(outputname)) { - return false - } - rest := rempar.FindSubmatch([]byte(outputname)) - par1 := string(rest[1]) - par2 := string(rest[2]) - bfile, _ := ioutil.ReadFile(filepath) - bitlen := len(bfile) - i := 1 - var seed int = buffer - if bitlen > seed { - for bitlen > seed { - coder := base64.StdEncoding.EncodeToString(bfile[seed*(i-1) : seed*i]) - ioutil.WriteFile(par1+strconv.Itoa(i)+par2, []byte(coder), 0755) - i++ - bitlen -= seed - } - } - coder := base64.StdEncoding.EncodeToString(bfile[seed*(i-1):]) - ioutil.WriteFile(par1+strconv.Itoa(i)+par2, []byte(coder), 0755) - return true -} - -func SmallDecodeFileByBase64(inputname, outputname string, filesum int) bool { - rempar := regexp.MustCompile(`(.*)\*(.*)`) - if !rempar.Match([]byte(inputname)) { - return false - } - rest := rempar.FindSubmatch([]byte(inputname)) - par1 := string(rest[1]) - par2 := string(rest[2]) - for i := 1; i <= filesum; i++ { - if !Exists(par1 + strconv.Itoa(i) + par2) { - return false - } - } - i := 1 - big := filesum - res := []byte{} - for i <= big { - bfile, _ := ioutil.ReadFile(par1 + strconv.Itoa(i) + par2) - coder, _ := base64.StdEncoding.DecodeString(string(bfile)) - for _, v := range coder { - res = append(res, v) - } - i++ - //time.Sleep(time.Microsecond * 560) - } - ioutil.WriteFile(outputname, res, 0755) - return true -} - -func EncodeFileByBase64(filepath, outputname string, buffer int) bool { - if !Exists(filepath) { - return false - } - rempar := regexp.MustCompile(`(.*)\*(.*)`) - if !rempar.Match([]byte(outputname)) { - return false - } - rest := rempar.FindSubmatch([]byte(outputname)) - par1 := string(rest[1]) - par2 := string(rest[2]) - ret := SlitFile(filepath, outputname, 0, int64(buffer), int64(buffer)/10) - if !ret { - return false - } - i := 1 - for { - if !Exists(par1 + strconv.Itoa(i) + par2) { - break - } else { - bfile, _ := ioutil.ReadFile(par1 + strconv.Itoa(i) + par2) - coder := base64.StdEncoding.EncodeToString(bfile) - ioutil.WriteFile(par1+strconv.Itoa(i)+par2, []byte(coder), 0755) - - } - i++ - } - return true -} - -func DecodeFileByBase64(inputname, outputname string, filesum int) bool { - rempar := regexp.MustCompile(`(.*)\*(.*)`) - if !rempar.Match([]byte(inputname)) { - return false - } - rest := rempar.FindSubmatch([]byte(inputname)) - par1 := string(rest[1]) - par2 := string(rest[2]) - if filesum != 0 { - for i := 1; i <= filesum; i++ { - if !Exists(par1 + strconv.Itoa(i) + par2) { - return false - } - } - } else { - var i int - for i = 1; ; i++ { - if !Exists(par1 + strconv.Itoa(i) + par2) { - break - } - } - filesum = i - 1 - } - i := 1 - big := filesum - fpw, _ := os.Create(outputname) - defer fpw.Close() - for i <= big { - bfile, _ := ioutil.ReadFile(par1 + strconv.Itoa(i) + par2) - coder, _ := base64.StdEncoding.DecodeString(string(bfile)) - fpw.Write(coder) - i++ - //time.Sleep(time.Microsecond * 560) - } - return true -} - -func SlitFile(filename, outputname string, num int, databig, buffer int64) bool { - rempar := regexp.MustCompile(`(.*)\*(.*)`) - if !rempar.Match([]byte(outputname)) { - return false - } - rest := rempar.FindSubmatch([]byte(outputname)) - par1 := string(rest[1]) - par2 := string(rest[2]) - if !Exists(filename) { - return false - } - fileinfo, _ := os.Stat(filename) - filesize := fileinfo.Size() - var spbyte int64 - if num != 0 { - spbyte = filesize / int64(num) - } - if databig != 0 { - spbyte = databig - num = int(filesize/spbyte + 1) - } - if buffer == 0 { - buffer = spbyte / 10 - } - if buffer > 100*1024*1024 { - buffer = 50 * 1024 * 1024 - } - fp, _ := os.Open(filename) - defer fp.Close() - data := make([]byte, buffer) - var i int64 = 0 - var k int = 1 - fpw, _ := os.Create(par1 + strconv.Itoa(k) + par2) - for { - data = data[:cap(data)] - - // read bytes to slice - n, err := fp.Read(data) - if err != nil { - if err == io.EOF { - break - } - fmt.Println(err) - break - } - i += int64(n) - data = data[:n] - fpw.Write(data) - if i > spbyte && k < num { - fpw.Close() - k++ - i = 1 - fpw, _ = os.Create(par1 + strconv.Itoa(k) + par2) - defer fpw.Close() - } - } - return true -} - -func SpliceFile(inputname, outputname string, num int, buffer int64) bool { - rempar := regexp.MustCompile(`(.*)\*(.*)`) - if !rempar.Match([]byte(inputname)) { - return false - } - rest := rempar.FindSubmatch([]byte(inputname)) - par1 := string(rest[1]) - par2 := string(rest[2]) - if num != 0 { - for i := 1; i <= num; i++ { - if !Exists(par1 + strconv.Itoa(i) + par2) { - return false - } - } - } else { - var i int - for i = 1; ; i++ { - if !Exists(par1 + strconv.Itoa(i) + par2) { - break - } - } - num = i - 1 - } - fpw, _ := os.Create(outputname) - defer fpw.Close() - fileinfo, _ := os.Stat(par1 + "1" + par2) - filesize := fileinfo.Size() - if buffer == 0 { - buffer = filesize / 5 - } - if buffer > 1024*1024*100 { - buffer = 1024 * 1024 * 100 - } - data := make([]byte, buffer) - for i := 1; i <= num; i++ { - fp, _ := os.Open(par1 + strconv.Itoa(i) + par2) - for { - data = data[:cap(data)] - // read bytes to slice - n, err := fp.Read(data) - if err != nil { - if err == io.EOF { - break - } - fmt.Println(err) - break - } - data = data[:n] - fpw.Write(data) - } - fp.Close() - } - return true -} - -func MixFile(filepath, outputname string, buffer int64, remix bool) bool { - if !Exists(filepath) || !IsFile(filepath) { - return false - } - fileinfo, _ := os.Stat(filepath) - filesize := fileinfo.Size() - if buffer == 0 { - buffer = filesize / 5 - } - if buffer > 1024*1024*100 { - buffer = 1024 * 1024 * 100 - } - var spbyte int64 - if !remix { - spbyte = filesize / 2 - } else { - spbyte = filesize - filesize/2 - } - fpw, _ := os.Create(outputname) - defer fpw.Close() - fp, _ := os.Open(filepath) - defer fp.Close() - data := make([]byte, buffer) - _, _ = fp.Seek(spbyte, 0) - for { - data = data[:cap(data)] - - // read bytes to slice - n, err := fp.Read(data) - if err != nil { - if err == io.EOF { - break - } - fmt.Println(err) - break - } - data = data[:n] - fpw.Write(data) - } - _, _ = fp.Seek(0, 0) - i := int64(0) - for { - data = data[:cap(data)] - - // read bytes to slice - n, err := fp.Read(data) - if err != nil { - if err == io.EOF { - break - } - fmt.Println(err) - break - } - i += int64(n) - if i < spbyte { - data = data[:n] - fpw.Write(data) - } else { - data = data[:(int64(n) - i + spbyte)] - fpw.Write(data) - break - } - } - return true -} - -func Md5File(filepath string) string { - f, err := os.Open(filepath) - if err != nil { - fmt.Println("Open", err) - return "" - } - defer f.Close() - md5hash := md5.New() - if _, err := io.Copy(md5hash, f); err != nil { - fmt.Println("Copy", err) - return "" - } - result := md5hash.Sum(nil) - return hex.EncodeToString(result) -} - -func Crc32File(filepath string) string { - f, err := os.Open(filepath) - if err != nil { - fmt.Println("Open", err) - return "" - } - - defer f.Close() - crchash := crc32.NewIEEE() - if _, err := io.Copy(crchash, f); err != nil { - fmt.Println("Copy", err) - return "" - } - result := crchash.Sum(nil) - return hex.EncodeToString(result) -} - -func Sha1File(filepath string) string { - f, err := os.Open(filepath) - if err != nil { - fmt.Println("Open", err) - return "" - } - - defer f.Close() - sha1hash := sha1.New() - if _, err := io.Copy(sha1hash, f); err != nil { - fmt.Println("Copy", err) - return "" - } - result := sha1hash.Sum(nil) - return hex.EncodeToString(result) -} - -func Sha256File(filepath string) string { - f, err := os.Open(filepath) - if err != nil { - fmt.Println("Open", err) - return "" - } - - defer f.Close() - sha256hash := sha256.New() - if _, err := io.Copy(sha256hash, f); err != nil { - fmt.Println("Copy", err) - return "" - } - result := sha256hash.Sum(nil) - return hex.EncodeToString(result) -} - -func Sha512File(filepath string) string { - f, err := os.Open(filepath) - if err != nil { - fmt.Println("Open", err) - return "" - } - - defer f.Close() - sha512hash := sha512.New() - if _, err := io.Copy(sha512hash, f); err != nil { - fmt.Println("Copy", err) - return "" - } - result := sha512hash.Sum(nil) - return hex.EncodeToString(result) -} - -func RC4File(filepath string, key []byte) string { - rc4obj, _ := rc4.NewCipher(key) - plain, _ := ioutil.ReadFile(filepath) - res := make([]byte, len(plain)) - rc4obj.XORKeyStream(res, plain) - return hex.EncodeToString(res) -} -func DetachFile(source, output1, output2 string, key int64) bool { - if !Exists(source) { - return false - } - fin, _ := os.Stat(source) - filesize := fin.Size() - fpw, _ := os.Create(output1) - fp, _ := os.Open(source) - defer fp.Close() - buffer := filesize / 10 - if buffer > 100*1024*1024 { - buffer = 100 * 1024 * 1024 - } - data := make([]byte, buffer) - i := int64(0) - for { - data = data[:cap(data)] - - // read bytes to slice - n, err := fp.Read(data) - if err != nil { - if err == io.EOF { - break - } - fmt.Println(err) - break - } - i += int64(n) - if i < key { - data = data[:n] - fpw.Write(data) - } else { - data = data[:(int64(n) - i + key)] - fpw.Write(data) - break - } - } - fpw.Close() - _, _ = fp.Seek(key+20, 0) - fpw, _ = os.Create(output2) - for { - data = data[:cap(data)] - - // read bytes to slice - n, err := fp.Read(data) - if err != nil { - if err == io.EOF { - break - } - fmt.Println(err) - break - } - data = data[:n] - fpw.Write(data) - } - return true -} -func AttachFile(source, target, output string) (bool, string) { - if !Exists(source) { - return false, "" - } - if !Exists(target) { - return false, "" - } - fin, _ := os.Stat(source) - filesize := fin.Size() - _ = ioutil.WriteFile(output+".ini", []byte(strconv.FormatInt(filesize, 10)), 0755) - fpw, _ := os.Create(output) - defer fpw.Close() - fp, _ := os.Open(source) - buffer := filesize / 10 - if buffer > 100*1024*1024 { - buffer = 100 * 1024 * 1024 - } - data := make([]byte, buffer) - for { - data = data[:cap(data)] - // read bytes to slice - n, err := fp.Read(data) - if err != nil { - if err == io.EOF { - break - } - fmt.Println(err) - break - } - data = data[:n] - fpw.Write(data) - } - fp.Close() - fpw.Write([]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}) - fin, _ = os.Stat(target) - filesize2 := fin.Size() - fp, _ = os.Open(target) - buffer = filesize2 / 10 - if buffer > 100*1024*1024 { - buffer = 100 * 1024 * 1024 - } - data = make([]byte, buffer) - for { - data = data[:cap(data)] - // read bytes to slice - n, err := fp.Read(data) - if err != nil { - if err == io.EOF { - break - } - fmt.Println(err) - break - } - data = data[:n] - fpw.Write(data) - } - fp.Close() - return true, strconv.FormatInt(filesize, 10) -} - -func CurlGet(url string) (error, string) { - err, _, res, _, _ := Curl(url, "", HttpNul, HttpNul2, "GET") - return err, res -} - -func CurlPost(url, postdata string) (error, string) { - err, _, res, _, _ := Curl(url, postdata, HttpNul, HttpNul2, "POST") - return err, res -} -func HttpNulReset() { - var tmp map[string]string - HttpNul, HttpNul2 = tmp, tmp -} - -func Curl(url string, postdata string, header map[string]string, cookie map[string]string, method string) (error, int, string, http.Header, []*http.Cookie) { - var req *http.Request - if method == "" { - if len(postdata) != 0 { - method = "POST" - } else { - method = "GET" - } - } - BytePostData := []byte(postdata) - if postdata == "" || len(postdata) == 0 { - req, _ = http.NewRequest(method, url, nil) - } else { - req, _ = http.NewRequest(method, url, bytes.NewBuffer(BytePostData)) - } - - if (len(header) == 0 || header == nil) && method == "POST" { - req.Header.Set("Content-Type", "application/x-www-form-urlencoded") - } - for k, v := range header { - req.Header.Set(k, v) - } - if len(cookie) != 0 { - for k, v := range cookie { - cookie1 := &http.Cookie{Name: k, Value: v, HttpOnly: true} - req.AddCookie(cookie1) - } - - } - client := &http.Client{ - Transport: &http.Transport{ - Dial: func(netw, addr string) (net.Conn, error) { - deadline := time.Now().Add(time.Duration(HttpTimeOut) * time.Second) - c, err := net.DialTimeout(netw, addr, time.Second*time.Duration(HttpTimeOut)) - if err != nil { - return nil, err - } - c.SetDeadline(deadline) - return c, nil - }, - }} - resp, err := client.Do(req) - var rte []*http.Cookie - if err != nil { - return err, 0, "", req.Header, rte - } - defer resp.Body.Close() - - statuscode := resp.StatusCode - hea := resp.Header - body, _ := ioutil.ReadAll(resp.Body) - return nil, statuscode, string(body), hea, resp.Cookies() - -} - -func FetchAll(rows *sql.Rows)(error,map[int]map[string]string){ - var ii int=0 - records := make(map[int]map[string]string) - columns, err:= rows.Columns() - if err!=nil { - return err,records - } - scanArgs := make([]interface{}, len(columns)) - values := make([]interface{}, len(columns)) - for i := range values { - scanArgs[i] = &values[i] - } - for rows.Next() { - if err := rows.Scan(scanArgs...);err!=nil{ - return err,records - } - record := make(map[string]string) - for i, col := range values { - switch vtype:=col.(type){ - case int64: - record[columns[i]] = strconv.FormatInt(vtype,10) - default: - record[columns[i]] = string(vtype.([]byte)) - } - } - records[ii]=record - ii++ - } - return nil,records -} - -func OpenDB(Method,ConnStr string)error{ - var err error - DBRes,err=sql.Open(Method,ConnStr) - return err -} -func CloseDB(){ - DBRes.Close() - DBRows.Close() -} - -func Query(args ...interface{})(error,map[int]map[string]string){ - var err error - records := make(map[int]map[string]string) - if err=DBRes.Ping();err!=nil{ - return err,records - } - if len(args)==0 { - return errors.New("no args"),records - } - if(len(args)==1){ - sql:=args[0] - if DBRows,err=DBRes.Query(sql.(string));err!=nil{ - return err,records - } - return FetchAll(DBRows) - } - sql:=args[0] - stmt,err:=DBRes.Prepare(sql.(string)) - if err!=nil{ - return err,records - } - var para []interface{} - for k,v:=range args{ - if k!=0{ - switch vtype:=v.(type){ - default: - para=append(para,vtype) - } - } - } - if DBRows,err=stmt.Query(para...);err!=nil{ - return err,records - } - return FetchAll(DBRows) - -} - -func DBExec(args ...interface{})(error){ - var err error - if err=DBRes.Ping();err!=nil{ - return err - } - if len(args)==0 { - return errors.New("no args") - } - if(len(args)==1){ - sql:=args[0] - if _,err=DBRes.Exec(sql.(string));err!=nil{ - return err - } - return nil - } - sql:=args[0] - stmt,err:=DBRes.Prepare(sql.(string)) - if err!=nil{ - return err - } - var para []interface{} - for k,v:=range args{ - if k!=0{ - switch vtype:=v.(type){ - default: - para=append(para,vtype) - } - } - } - if _,err=stmt.Exec(para...);err!=nil{ - return err - } - return nil - -} \ No newline at end of file +package starainrt + +import ( + "bufio" + "bytes" + "crypto/md5" + "crypto/rc4" + "crypto/sha1" + "crypto/sha256" + "crypto/sha512" + "database/sql" + "encoding/base64" + "encoding/hex" + "errors" + "fmt" + "hash/crc32" + "io" + "io/ioutil" + "net" + "net/http" + "os" + "os/exec" + "regexp" + "strconv" + "strings" + "time" +) + +var HttpNul, HttpNul2 map[string]string +var HttpTimeOut int64 = 15 +var DBRes *sql.DB +var DBRows *sql.Rows +var ShellRes, ShellErr string +var ShellExit bool + +func Exists(filepath string) bool { + _, err := os.Stat(filepath) + if err != nil && os.IsNotExist(err) { + return false + } + return true +} +func IsFile(fpath string) bool { + s, err := os.Stat(fpath) + if err != nil { + return false + } + return !s.IsDir() +} +func IsFolder(fpath string) bool { + s, err := os.Stat(fpath) + if err != nil { + return false + } + return s.IsDir() +} +func ReWriteFileByKV(filepath, rem, conn, ret string, kv map[string]string) bool { + var outputstr string + var ataru bool = false + if (!Exists(filepath)) || (!IsFile(filepath)) { + return false + } + fso, err := os.Open(filepath) + if err != nil { + return false + } + rempar := regexp.MustCompile("^" + rem) + buf := bufio.NewReader(fso) + for { + bytxt, _, eof := buf.ReadLine() + if eof == io.EOF { + break + } + txt := strings.TrimSpace(string(bytxt)) + if rempar.Match([]byte(txt)) { + outputstr += txt + ret + continue + } + for k, v := range kv { + keypar := regexp.MustCompile("^" + k) + if keypar.Match([]byte(txt)) { + ataru = true + outputstr += k + conn + v + ret + delete(kv, k) + } + } + if ataru { + ataru = false + continue + } else { + outputstr += txt + ret + } + } + fso.Close() + if len(kv) != 0 { + for k, v := range kv { + outputstr += k + conn + v + ret + delete(kv, k) + } + } + err = ioutil.WriteFile(filepath, []byte(outputstr), 0755) + if err != nil { + return false + } + return true +} + +func GetINIValue(filepath, rem, conn string, kv []string) (bool, map[string]string) { + outputstr := make(map[string]string) + if (!Exists(filepath)) || (!IsFile(filepath)) { + return false, outputstr + } + fso, err := os.Open(filepath) + if err != nil { + return false, outputstr + } + rempar := regexp.MustCompile("^" + rem) + buf := bufio.NewReader(fso) + for { + bytxt, _, eof := buf.ReadLine() + if eof == io.EOF { + break + } + txt := strings.TrimSpace(string(bytxt)) + if rempar.Match([]byte(txt)) { + continue + } + var i int = 0 + var v2 string + for k, v := range kv { + if v == "" { + continue + } + v2 = "" + for _, b := range []byte(v) { + switch string(b) { + case ".": + v2 += "\\." + case "\\": + v2 += "\\" + case "-": + v2 += "\\-" + case "(": + v2 += "\\(" + case ")": + v2 += "\\)" + case "{": + v2 += "\\{" + case "}": + v2 += "\\}" + case "[": + v2 += "\\[" + case "]": + v2 += "\\]" + case "$": + v2 += "\\]$" + case "^": + v2 += "\\^" + default: + v2 += string(b) + } + } + keypar := regexp.MustCompile("^" + v2 + ".*?" + conn + "(.*)") + if keypar.Match([]byte(txt)) { + i++ + kekka := keypar.FindSubmatch([]byte(txt)) + outputstr[v] = string(kekka[1]) + kv[k] = "" + } + } + if i != len(kv) { + for _, v := range kv { + if v != "" { + outputstr[v] = "" + } + } + } + } + return true, outputstr +} + +func SmallEncodeFileByBase64(filepath, outputname string, buffer int) bool { + if !Exists(filepath) { + return false + } + rempar := regexp.MustCompile(`(.*)\*(.*)`) + if !rempar.Match([]byte(outputname)) { + return false + } + rest := rempar.FindSubmatch([]byte(outputname)) + par1 := string(rest[1]) + par2 := string(rest[2]) + bfile, _ := ioutil.ReadFile(filepath) + bitlen := len(bfile) + i := 1 + var seed int = buffer + if bitlen > seed { + for bitlen > seed { + coder := base64.StdEncoding.EncodeToString(bfile[seed*(i-1) : seed*i]) + ioutil.WriteFile(par1+strconv.Itoa(i)+par2, []byte(coder), 0755) + i++ + bitlen -= seed + } + } + coder := base64.StdEncoding.EncodeToString(bfile[seed*(i-1):]) + ioutil.WriteFile(par1+strconv.Itoa(i)+par2, []byte(coder), 0755) + return true +} + +func SmallDecodeFileByBase64(inputname, outputname string, filesum int) bool { + rempar := regexp.MustCompile(`(.*)\*(.*)`) + if !rempar.Match([]byte(inputname)) { + return false + } + rest := rempar.FindSubmatch([]byte(inputname)) + par1 := string(rest[1]) + par2 := string(rest[2]) + for i := 1; i <= filesum; i++ { + if !Exists(par1 + strconv.Itoa(i) + par2) { + return false + } + } + i := 1 + big := filesum + res := []byte{} + for i <= big { + bfile, _ := ioutil.ReadFile(par1 + strconv.Itoa(i) + par2) + coder, _ := base64.StdEncoding.DecodeString(string(bfile)) + for _, v := range coder { + res = append(res, v) + } + i++ + //time.Sleep(time.Microsecond * 560) + } + ioutil.WriteFile(outputname, res, 0755) + return true +} + +func EncodeFileByBase64(filepath, outputname string, buffer int) bool { + if !Exists(filepath) { + return false + } + rempar := regexp.MustCompile(`(.*)\*(.*)`) + if !rempar.Match([]byte(outputname)) { + return false + } + rest := rempar.FindSubmatch([]byte(outputname)) + par1 := string(rest[1]) + par2 := string(rest[2]) + ret := SlitFile(filepath, outputname, 0, int64(buffer), int64(buffer)/10) + if !ret { + return false + } + i := 1 + for { + if !Exists(par1 + strconv.Itoa(i) + par2) { + break + } else { + bfile, _ := ioutil.ReadFile(par1 + strconv.Itoa(i) + par2) + coder := base64.StdEncoding.EncodeToString(bfile) + ioutil.WriteFile(par1+strconv.Itoa(i)+par2, []byte(coder), 0755) + + } + i++ + } + return true +} + +func DecodeFileByBase64(inputname, outputname string, filesum int) bool { + rempar := regexp.MustCompile(`(.*)\*(.*)`) + if !rempar.Match([]byte(inputname)) { + return false + } + rest := rempar.FindSubmatch([]byte(inputname)) + par1 := string(rest[1]) + par2 := string(rest[2]) + if filesum != 0 { + for i := 1; i <= filesum; i++ { + if !Exists(par1 + strconv.Itoa(i) + par2) { + return false + } + } + } else { + var i int + for i = 1; ; i++ { + if !Exists(par1 + strconv.Itoa(i) + par2) { + break + } + } + filesum = i - 1 + } + i := 1 + big := filesum + fpw, _ := os.Create(outputname) + defer fpw.Close() + for i <= big { + bfile, _ := ioutil.ReadFile(par1 + strconv.Itoa(i) + par2) + coder, _ := base64.StdEncoding.DecodeString(string(bfile)) + fpw.Write(coder) + i++ + //time.Sleep(time.Microsecond * 560) + } + return true +} + +func SlitFile(filename, outputname string, num int, databig, buffer int64) bool { + rempar := regexp.MustCompile(`(.*)\*(.*)`) + if !rempar.Match([]byte(outputname)) { + return false + } + rest := rempar.FindSubmatch([]byte(outputname)) + par1 := string(rest[1]) + par2 := string(rest[2]) + if !Exists(filename) { + return false + } + fileinfo, _ := os.Stat(filename) + filesize := fileinfo.Size() + var spbyte int64 + if num != 0 { + spbyte = filesize / int64(num) + } + if databig != 0 { + spbyte = databig + num = int(filesize/spbyte + 1) + } + if buffer == 0 { + buffer = spbyte / 10 + } + if buffer > 100*1024*1024 { + buffer = 50 * 1024 * 1024 + } + fp, _ := os.Open(filename) + defer fp.Close() + data := make([]byte, buffer) + var i int64 = 0 + var k int = 1 + fpw, _ := os.Create(par1 + strconv.Itoa(k) + par2) + for { + data = data[:cap(data)] + + // read bytes to slice + n, err := fp.Read(data) + if err != nil { + if err == io.EOF { + break + } + fmt.Println(err) + break + } + i += int64(n) + data = data[:n] + fpw.Write(data) + if i > spbyte && k < num { + fpw.Close() + k++ + i = 1 + fpw, _ = os.Create(par1 + strconv.Itoa(k) + par2) + defer fpw.Close() + } + } + return true +} + +func SpliceFile(inputname, outputname string, num int, buffer int64) bool { + rempar := regexp.MustCompile(`(.*)\*(.*)`) + if !rempar.Match([]byte(inputname)) { + return false + } + rest := rempar.FindSubmatch([]byte(inputname)) + par1 := string(rest[1]) + par2 := string(rest[2]) + if num != 0 { + for i := 1; i <= num; i++ { + if !Exists(par1 + strconv.Itoa(i) + par2) { + return false + } + } + } else { + var i int + for i = 1; ; i++ { + if !Exists(par1 + strconv.Itoa(i) + par2) { + break + } + } + num = i - 1 + } + fpw, _ := os.Create(outputname) + defer fpw.Close() + fileinfo, _ := os.Stat(par1 + "1" + par2) + filesize := fileinfo.Size() + if buffer == 0 { + buffer = filesize / 5 + } + if buffer > 1024*1024*100 { + buffer = 1024 * 1024 * 100 + } + data := make([]byte, buffer) + for i := 1; i <= num; i++ { + fp, _ := os.Open(par1 + strconv.Itoa(i) + par2) + for { + data = data[:cap(data)] + // read bytes to slice + n, err := fp.Read(data) + if err != nil { + if err == io.EOF { + break + } + fmt.Println(err) + break + } + data = data[:n] + fpw.Write(data) + } + fp.Close() + } + return true +} + +func MixFile(filepath, outputname string, buffer int64, remix bool) bool { + if !Exists(filepath) || !IsFile(filepath) { + return false + } + fileinfo, _ := os.Stat(filepath) + filesize := fileinfo.Size() + if buffer == 0 { + buffer = filesize / 5 + } + if buffer > 1024*1024*100 { + buffer = 1024 * 1024 * 100 + } + var spbyte int64 + if !remix { + spbyte = filesize / 2 + } else { + spbyte = filesize - filesize/2 + } + fpw, _ := os.Create(outputname) + defer fpw.Close() + fp, _ := os.Open(filepath) + defer fp.Close() + data := make([]byte, buffer) + _, _ = fp.Seek(spbyte, 0) + for { + data = data[:cap(data)] + + // read bytes to slice + n, err := fp.Read(data) + if err != nil { + if err == io.EOF { + break + } + fmt.Println(err) + break + } + data = data[:n] + fpw.Write(data) + } + _, _ = fp.Seek(0, 0) + i := int64(0) + for { + data = data[:cap(data)] + + // read bytes to slice + n, err := fp.Read(data) + if err != nil { + if err == io.EOF { + break + } + fmt.Println(err) + break + } + i += int64(n) + if i < spbyte { + data = data[:n] + fpw.Write(data) + } else { + data = data[:(int64(n) - i + spbyte)] + fpw.Write(data) + break + } + } + return true +} + +func Md5File(filepath string) string { + f, err := os.Open(filepath) + if err != nil { + fmt.Println("Open", err) + return "" + } + defer f.Close() + md5hash := md5.New() + if _, err := io.Copy(md5hash, f); err != nil { + fmt.Println("Copy", err) + return "" + } + result := md5hash.Sum(nil) + return hex.EncodeToString(result) +} + +func Crc32File(filepath string) string { + f, err := os.Open(filepath) + if err != nil { + fmt.Println("Open", err) + return "" + } + + defer f.Close() + crchash := crc32.NewIEEE() + if _, err := io.Copy(crchash, f); err != nil { + fmt.Println("Copy", err) + return "" + } + result := crchash.Sum(nil) + return hex.EncodeToString(result) +} + +func Sha1File(filepath string) string { + f, err := os.Open(filepath) + if err != nil { + fmt.Println("Open", err) + return "" + } + + defer f.Close() + sha1hash := sha1.New() + if _, err := io.Copy(sha1hash, f); err != nil { + fmt.Println("Copy", err) + return "" + } + result := sha1hash.Sum(nil) + return hex.EncodeToString(result) +} + +func Sha256File(filepath string) string { + f, err := os.Open(filepath) + if err != nil { + fmt.Println("Open", err) + return "" + } + + defer f.Close() + sha256hash := sha256.New() + if _, err := io.Copy(sha256hash, f); err != nil { + fmt.Println("Copy", err) + return "" + } + result := sha256hash.Sum(nil) + return hex.EncodeToString(result) +} + +func Sha512File(filepath string) string { + f, err := os.Open(filepath) + if err != nil { + fmt.Println("Open", err) + return "" + } + + defer f.Close() + sha512hash := sha512.New() + if _, err := io.Copy(sha512hash, f); err != nil { + fmt.Println("Copy", err) + return "" + } + result := sha512hash.Sum(nil) + return hex.EncodeToString(result) +} + +func RC4File(filepath string, key []byte) string { + rc4obj, _ := rc4.NewCipher(key) + plain, _ := ioutil.ReadFile(filepath) + res := make([]byte, len(plain)) + rc4obj.XORKeyStream(res, plain) + return hex.EncodeToString(res) +} +func DetachFile(source, output1, output2 string, key int64) bool { + if !Exists(source) { + return false + } + fin, _ := os.Stat(source) + filesize := fin.Size() + fpw, _ := os.Create(output1) + fp, _ := os.Open(source) + defer fp.Close() + buffer := filesize / 10 + if buffer > 100*1024*1024 { + buffer = 100 * 1024 * 1024 + } + data := make([]byte, buffer) + i := int64(0) + for { + data = data[:cap(data)] + + // read bytes to slice + n, err := fp.Read(data) + if err != nil { + if err == io.EOF { + break + } + fmt.Println(err) + break + } + i += int64(n) + if i < key { + data = data[:n] + fpw.Write(data) + } else { + data = data[:(int64(n) - i + key)] + fpw.Write(data) + break + } + } + fpw.Close() + _, _ = fp.Seek(key+20, 0) + fpw, _ = os.Create(output2) + for { + data = data[:cap(data)] + + // read bytes to slice + n, err := fp.Read(data) + if err != nil { + if err == io.EOF { + break + } + fmt.Println(err) + break + } + data = data[:n] + fpw.Write(data) + } + return true +} +func AttachFile(source, target, output string) (bool, string) { + if !Exists(source) { + return false, "" + } + if !Exists(target) { + return false, "" + } + fin, _ := os.Stat(source) + filesize := fin.Size() + _ = ioutil.WriteFile(output+".ini", []byte(strconv.FormatInt(filesize, 10)), 0755) + fpw, _ := os.Create(output) + defer fpw.Close() + fp, _ := os.Open(source) + buffer := filesize / 10 + if buffer > 100*1024*1024 { + buffer = 100 * 1024 * 1024 + } + data := make([]byte, buffer) + for { + data = data[:cap(data)] + // read bytes to slice + n, err := fp.Read(data) + if err != nil { + if err == io.EOF { + break + } + fmt.Println(err) + break + } + data = data[:n] + fpw.Write(data) + } + fp.Close() + fpw.Write([]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}) + fin, _ = os.Stat(target) + filesize2 := fin.Size() + fp, _ = os.Open(target) + buffer = filesize2 / 10 + if buffer > 100*1024*1024 { + buffer = 100 * 1024 * 1024 + } + data = make([]byte, buffer) + for { + data = data[:cap(data)] + // read bytes to slice + n, err := fp.Read(data) + if err != nil { + if err == io.EOF { + break + } + fmt.Println(err) + break + } + data = data[:n] + fpw.Write(data) + } + fp.Close() + return true, strconv.FormatInt(filesize, 10) +} + +func CurlGet(url string) (error, []byte) { + err, _, res, _, _ := Curl(url, "", HttpNul, HttpNul2, "GET") + return err, res +} + +func CurlPost(url, postdata string) (error, []byte) { + err, _, res, _, _ := Curl(url, postdata, HttpNul, HttpNul2, "POST") + return err, res +} +func HttpNulReset() { + var tmp map[string]string + HttpNul, HttpNul2 = tmp, tmp +} + +func Curl(url string, postdata string, header map[string]string, cookie map[string]string, method string) (error, int, []byte, http.Header, []*http.Cookie) { + var req *http.Request + if method == "" { + if len(postdata) != 0 { + method = "POST" + } else { + method = "GET" + } + } + BytePostData := []byte(postdata) + if postdata == "" || len(postdata) == 0 { + req, _ = http.NewRequest(method, url, nil) + } else { + req, _ = http.NewRequest(method, url, bytes.NewBuffer(BytePostData)) + } + + if (len(header) == 0 || header == nil) && method == "POST" { + req.Header.Set("Content-Type", "application/x-www-form-urlencoded") + } + for k, v := range header { + req.Header.Set(k, v) + } + if len(cookie) != 0 { + for k, v := range cookie { + req.AddCookie(&http.Cookie{Name: k, Value: v, HttpOnly: true}) + } + + } + client := &http.Client{ + Transport: &http.Transport{ + Dial: func(netw, addr string) (net.Conn, error) { + deadline := time.Now().Add(time.Duration(HttpTimeOut) * time.Second) + c, err := net.DialTimeout(netw, addr, time.Second*time.Duration(HttpTimeOut)) + if err != nil { + return nil, err + } + c.SetDeadline(deadline) + return c, nil + }, + }} + resp, err := client.Do(req) + var rte []*http.Cookie + if err != nil { + return err, 0, []byte(""), req.Header, rte + } + defer resp.Body.Close() + + statuscode := resp.StatusCode + hea := resp.Header + body, _ := ioutil.ReadAll(resp.Body) + return nil, statuscode, body, hea, resp.Cookies() + +} + +func FetchAll(rows *sql.Rows) (error, map[int]map[string]string) { + var ii int = 0 + records := make(map[int]map[string]string) + columns, err := rows.Columns() + if err != nil { + return err, records + } + scanArgs := make([]interface{}, len(columns)) + values := make([]interface{}, len(columns)) + for i := range values { + scanArgs[i] = &values[i] + } + for rows.Next() { + if err := rows.Scan(scanArgs...); err != nil { + return err, records + } + record := make(map[string]string) + for i, col := range values { + switch vtype := col.(type) { + case int64: + record[columns[i]] = strconv.FormatInt(vtype, 10) + default: + record[columns[i]] = string(vtype.([]byte)) + } + } + records[ii] = record + ii++ + } + return nil, records +} + +func OpenDB(Method, ConnStr string) error { + var err error + DBRes, err = sql.Open(Method, ConnStr) + return err +} +func CloseDB() { + DBRes.Close() + DBRows.Close() +} + +func Query(args ...interface{}) (error, map[int]map[string]string) { + var err error + records := make(map[int]map[string]string) + if err = DBRes.Ping(); err != nil { + return err, records + } + if len(args) == 0 { + return errors.New("no args"), records + } + if len(args) == 1 { + sql := args[0] + if DBRows, err = DBRes.Query(sql.(string)); err != nil { + return err, records + } + return FetchAll(DBRows) + } + sql := args[0] + stmt, err := DBRes.Prepare(sql.(string)) + if err != nil { + return err, records + } + var para []interface{} + for k, v := range args { + if k != 0 { + switch vtype := v.(type) { + default: + para = append(para, vtype) + } + } + } + if DBRows, err = stmt.Query(para...); err != nil { + return err, records + } + return FetchAll(DBRows) + +} + +func DBExec(args ...interface{}) error { + var err error + if err = DBRes.Ping(); err != nil { + return err + } + if len(args) == 0 { + return errors.New("no args") + } + if len(args) == 1 { + sql := args[0] + if _, err = DBRes.Exec(sql.(string)); err != nil { + return err + } + return nil + } + sql := args[0] + stmt, err := DBRes.Prepare(sql.(string)) + if err != nil { + return err + } + var para []interface{} + for k, v := range args { + if k != 0 { + switch vtype := v.(type) { + default: + para = append(para, vtype) + } + } + } + if _, err = stmt.Exec(para...); err != nil { + return err + } + return nil + +} + +type suncli struct { + outfile io.ReadCloser + infile io.WriteCloser + errfile io.ReadCloser + cmd *exec.Cmd + thread bool + counter int +} + +func (this suncli) IsExit() bool { + return ShellExit +} + +func NewPipeShell(command string, arg ...string) (*suncli, error) { + var err error + lovecli := suncli{} + lovecli.counter = 0 + cmd := exec.Command(command, arg...) + lovecli.cmd = cmd + lovecli.infile, err = lovecli.cmd.StdinPipe() + if err != nil { + return &lovecli, err + } + lovecli.outfile, err = lovecli.cmd.StdoutPipe() + if err != nil { + return &lovecli, err + } + lovecli.errfile, err = lovecli.cmd.StderrPipe() + if err != nil { + return &lovecli, err + } + if err := lovecli.cmd.Start(); err != nil { + return &lovecli, err + } + go func() { + lovecli.cmd.Wait() + }() + ShellExit = false + lovecli.thread = false + return &lovecli, nil +} + +func (this suncli) GetResult(maxtime int) (string, string, bool) { + var stop bool + reader := bufio.NewReader(this.outfile) + erreader := bufio.NewReader(this.errfile) + if !this.thread { + this.thread = true + go func() { + var line2 string + var stack bool = false + stop = false + for { + if !stack { + go func() { + stack = true + if erreader.Size() > 0 { + line2, _ = erreader.ReadString('\n') + ShellErr += line2 + line2 = "" + } + stack = false + }() + } + line, err2 := reader.ReadString('\n') + if err2 != nil || io.EOF == err2 { + stop = true + break + } + this.counter++ + ShellRes += line + } + }() + } + waittm := 0 + for !stop { + time.Sleep(time.Millisecond * 250) + waittm += 1 + if maxtime >= 0 { + if waittm/4 > maxtime { + restr := ShellRes + ShellRes = "" + errstr := ShellErr + ShellErr = "" + return restr, errstr, false + } + } + } + ShellExit = true + this.thread = false + restr := ShellRes + ShellRes = "" + errstr := ShellErr + ShellErr = "" + return restr, errstr, true +} + +func (this suncli) Exec(cmdstr string, maxtime int) (string, string, bool) { + this.infile.Write([]byte(cmdstr + "\n")) + return this.GetResult(maxtime) +} + +func (this suncli) WriteCmd(cmdstr string) { + this.infile.Write([]byte(cmdstr + "\n")) + return +}