From fe167d7281e8cfc84702ca6b9f4229ca2be419d4 Mon Sep 17 00:00:00 2001 From: 兔子 Date: Wed, 4 Sep 2019 16:00:23 +0800 Subject: [PATCH] new starainrt release --- crypto.go | 1103 +++++++++++++++++++++++++++++----------------- crypto.go.old | 536 ++++++++++++++++++++++ crypto_test.go | 13 + database.go | 326 ++++++++++++++ database_test.go | 19 + net.go | 385 ++++++++++++++++ starainrt.go | 202 ++++++--- 7 files changed, 2118 insertions(+), 466 deletions(-) create mode 100644 crypto.go.old create mode 100644 crypto_test.go create mode 100644 database_test.go create mode 100644 net.go diff --git a/crypto.go b/crypto.go index f0d607f..654f2bc 100644 --- a/crypto.go +++ b/crypto.go @@ -1,530 +1,829 @@ package starainrt import ( + "bufio" + "crypto" "crypto/md5" - "crypto/rc4" + "crypto/rand" + "crypto/rsa" "crypto/sha1" "crypto/sha256" "crypto/sha512" + "crypto/x509" "encoding/base64" + "encoding/binary" "encoding/hex" + "encoding/pem" + "errors" "fmt" + "hash" "hash/crc32" "io" "io/ioutil" + rands "math/rand" "os" + "path/filepath" "regexp" "strconv" + "strings" + "time" ) -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 +type StarCrypto struct { } -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 +/* +输出格式化后的Base64字符串 +*/ +func (this StarCrypto) Base64Encode(bstr []byte) string { + return base64.StdEncoding.EncodeToString(bstr) } -func EncodeFileByBase64(filepath, outputname string, buffer int) bool { - if !Exists(filepath) { - return false +/* +输出解密前的Base64数据 +*/ +func (this StarCrypto) Base64Decode(str string) ([]byte, error) { + return base64.StdEncoding.DecodeString(str) +} + +/* +输出MD5校验值 +*/ +func (this StarCrypto) MD5(bstr []byte) string { + md5sum := md5.New() + return hex.EncodeToString(md5sum.Sum(bstr)) +} + +/* +输出CRC32校验值 +*/ +func (this StarCrypto) CRC32(bstr []byte) string { + crcsum := crc32.NewIEEE() + return hex.EncodeToString(crcsum.Sum(bstr)) +} + +/* +输出SHA512校验值 +*/ +func (this StarCrypto) Sha512(bstr []byte) string { + shasum := sha512.New() + return hex.EncodeToString(shasum.Sum(bstr)) +} + +/* +输出SHA256校验值 +*/ +func (this StarCrypto) SHA256(bstr []byte) string { + shasum := sha256.New() + return hex.EncodeToString(shasum.Sum(bstr)) +} + +/* +输出SHA1校验值 +*/ +func (this StarCrypto) SHA1(bstr []byte) string { + shasum := sha1.New() + return hex.EncodeToString(shasum.Sum(bstr)) +} + +/* +多校验方法校验函数 +*/ +func (this StarCrypto) SumAll(data []byte, method []string) (map[string]string, error) { + result := make(map[string]string) + methods := make(map[string]hash.Hash) + var iscrc bool + if len(method) == 0 { + method = []string{"sha512", "sha256", "sha384", "sha224", "sha1", "crc32", "md5"} + } + sum512 := sha512.New() + sum384 := sha512.New384() + sum256 := sha256.New() + sum224 := sha256.New224() + sum1 := sha1.New() + crcsum := crc32.NewIEEE() + md5sum := md5.New() + for _, v := range method { + switch v { + case "md5": + methods["md5"] = md5sum + case "crc32": + iscrc = true + case "sha1": + methods["sha1"] = sum1 + case "sha224": + methods["sha224"] = sum224 + case "sha256": + methods["sha256"] = sum256 + case "sha384": + methods["sha384"] = sum384 + case "sha512": + methods["sha512"] = sum512 + } } - rempar := regexp.MustCompile(`(.*)\*(.*)`) - if !rempar.Match([]byte(outputname)) { - return false + for _, v := range methods { + v.Write(data) } - 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 + if iscrc { + crcsum.Write(data) } - 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++ + for k, v := range methods { + result[k] = hex.EncodeToString(v.Sum(nil)) } - return true + if iscrc { + result["crc32"] = hex.EncodeToString(crcsum.Sum(nil)) + } + return result, nil } -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 +/* +输出文件内容校验值，method为单个校验方法,小写 +例：FileSum("./test.txt","md5",shell(pect float64){fmt.Sprintf("已完成 %f\r",pect)}) +*/ +func (this StarCrypto) FileSum(filepath, method string, shell func(float64)) (string, error) { + var sum hash.Hash + var sum32 hash.Hash32 + var issum32 bool + var result string + if !Exists(filepath) { + return "", errors.New("File Not Exists!") + } + fp, err := os.Open(filepath) + if err != nil { + return "", err + } + switch method { + case "sha512": + sum = sha512.New() + case "sha384": + sum = sha512.New384() + case "sha256": + sum = sha256.New() + case "sha224": + sum = sha256.New224() + case "sha1": + sum = sha1.New() + case "crc32": + sum32 = crc32.NewIEEE() + issum32 = true + case "md5": + sum = md5.New() + default: + return "", errors.New("Cannot Recognize The Method:" + method) + } + writer := 0 + stat, _ := os.Stat(filepath) + filebig := float64(stat.Size()) + if !issum32 { + // if _, err := io.Copy(sum, fp); err != nil { + for { + buf := make([]byte, 1048574) + n, err := fp.Read(buf) + if err != nil { + if err == io.EOF { + break + } + return result, err } + writer += n + pect := (float64(writer) / filebig) * 100 + go shell(pect) + sum.Write(buf[0:n]) } + result = hex.EncodeToString(sum.Sum(nil)) } else { - var i int - for i = 1; ; i++ { - if !Exists(par1 + strconv.Itoa(i) + par2) { - break + for { + buf := make([]byte, 1048574) + n, err := fp.Read(buf) + if err != nil { + if err == io.EOF { + break + } + return result, err } + writer += n + pect := (float64(writer) / filebig) * 100 + go shell(pect) + sum32.Write(buf[0:n]) } - 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) + result = hex.EncodeToString(sum32.Sum(nil)) } - return true + return result, nil } -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) +/* +多校验方法校验文件函数 +*/ +func (this StarCrypto) FileSumAll(filepath string, method []string, shell func(float64)) (map[string]string, error) { + result := make(map[string]string) + methods := make(map[string]hash.Hash) + var iscrc bool + + if len(method) == 0 { + method = []string{"sha512", "sha256", "sha384", "sha224", "sha1", "crc32", "md5"} + } + if !Exists(filepath) { + return result, errors.New("File Not Exists!") + } + fp, err := os.Open(filepath) 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)] + if err != nil { + return result, err + } + stat, _ := os.Stat(filepath) + filebig := float64(stat.Size()) + sum512 := sha512.New() + sum384 := sha512.New384() + sum256 := sha256.New() + sum224 := sha256.New224() + sum1 := sha1.New() + crcsum := crc32.NewIEEE() + md5sum := md5.New() + for _, v := range method { + switch v { + case "md5": + methods["md5"] = md5sum + case "crc32": + iscrc = true + case "sha1": + methods["sha1"] = sum1 + case "sha224": + methods["sha224"] = sum224 + case "sha256": + methods["sha256"] = sum256 + case "sha384": + methods["sha384"] = sum384 + case "sha512": + methods["sha512"] = sum512 + } + } - // read bytes to slice - n, err := fp.Read(data) + writer := 0 + for { + buf := make([]byte, 1048574) + n, err := fp.Read(buf) if err != nil { if err == io.EOF { break } - fmt.Println(err) - break + return result, err + } + writer += n + pect := (float64(writer) / filebig) * 100 + go shell(pect) + for _, v := range methods { + v.Write(buf[0:n]) } - 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() + if iscrc { + crcsum.Write(buf[0:n]) } } - return true + for k, v := range methods { + result[k] = hex.EncodeToString(v.Sum(nil)) + } + if iscrc { + result["crc32"] = hex.EncodeToString(crcsum.Sum(nil)) + } + return result, nil } -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) { +func (this StarCrypto) Attach(src, dst, output string) error { + if !Exists(src) { + return errors.New("Source File Not Exists!") + } + if !Exists(dst) { + return errors.New("Dest File Not Exists!") + } + fpsrc, err := os.Open(src) + if err != nil { + return err + } + defer fpsrc.Close() + fpdst, err := os.Open(dst) + if err != nil { + return err + } + defer fpdst.Close() + fpout, err := os.Create(output) + if err != nil { + return err + } + defer fpout.Close() + if _, err := io.Copy(fpout, fpsrc); err != nil { + return err + } + for { + buf := make([]byte, 1048574) + n, err := fpdst.Read(buf) + if err != nil { + if err == io.EOF { break } + return err } - num = i - 1 + fpout.Write(buf[0:n]) } - fpw, _ := os.Create(outputname) - defer fpw.Close() - fileinfo, _ := os.Stat(par1 + "1" + par2) - filesize := fileinfo.Size() - if buffer == 0 { - buffer = filesize / 5 + return nil +} + +func (this StarCrypto) Detach(src string, bytenum int, dst1, dst2 string) error { + if !Exists(src) { + return errors.New("Source File Not Exists!") } - if buffer > 1024*1024*100 { - buffer = 1024 * 1024 * 100 + fpsrc, err := os.Open(src) + if err != nil { + return err } - 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) + defer fpsrc.Close() + fpdst1, err := os.Create(dst1) + if err != nil { + return err + } + defer fpdst1.Close() + fpdst2, err := os.Create(dst2) + if err != nil { + return err + } + defer fpdst2.Close() + sumall := 0 + var buf []byte + for { + if bytenum-sumall < 1048576 { + buf = make([]byte, bytenum-sumall) + } else { + buf = make([]byte, 1048576) + } + n, err := fpsrc.Read(buf) + if err != nil { + return err + } + sumall += n + fpdst1.Write(buf[0:n]) + if sumall == bytenum { + break + } + } + for { + buf = make([]byte, 1048576) + n, err := fpsrc.Read(buf) + if err != nil { + if err == io.EOF { break } - data = data[:n] - fpw.Write(data) + return err } - fp.Close() + fpdst2.Write(buf[0:n]) } - return true + return nil } -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 +func (this StarCrypto) Base64EncodeFile(src, dst string, shell func(float64)) error { + if !Exists(src) { + return errors.New("Source File Not Exists!") } - if buffer > 1024*1024*100 { - buffer = 1024 * 1024 * 100 + fpsrc, err := os.Open(src) + if err != nil { + return err } - var spbyte int64 - if !remix { - spbyte = filesize / 2 - } else { - spbyte = filesize - filesize/2 + defer fpsrc.Close() + stat, _ := os.Stat(src) + filebig := float64(stat.Size()) + sum := 0 + fpdst, err := os.Create(dst) + if err != nil { + return err } - fpw, _ := os.Create(outputname) - defer fpw.Close() - fp, _ := os.Open(filepath) - defer fp.Close() - data := make([]byte, buffer) - _, _ = fp.Seek(spbyte, 0) + defer fpdst.Close() + b64 := base64.NewEncoder(base64.StdEncoding, fpdst) for { - data = data[:cap(data)] - - // read bytes to slice - n, err := fp.Read(data) + buf := make([]byte, 1048575) + n, err := fpsrc.Read(buf) if err != nil { if err == io.EOF { break } - fmt.Println(err) - break + return err } - data = data[:n] - fpw.Write(data) + sum += n + go shell(float64(sum) / filebig * 100) + b64.Write(buf[0:n]) } - _, _ = fp.Seek(0, 0) - i := int64(0) - for { - data = data[:cap(data)] + return nil +} - // read bytes to slice - n, err := fp.Read(data) +func (this StarCrypto) Base64DecodeFile(src, dst string, shell func(float64)) error { + if !Exists(src) { + return errors.New("Source File Not Exists!") + } + fpsrc, err := os.Open(src) + if err != nil { + return err + } + defer fpsrc.Close() + stat, _ := os.Stat(src) + filebig := float64(stat.Size()) + sum := 0 + defer fpsrc.Close() + fpdst, err := os.Create(dst) + if err != nil { + return err + } + defer fpdst.Close() + b64 := base64.NewDecoder(base64.StdEncoding, fpsrc) + for { + buf := make([]byte, 1048576) + n, err := b64.Read(buf) 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 err } + sum += n + go shell(float64(sum) / filebig * 100) + fpdst.Write(buf[0:n]) } - return true + return nil } -func Md5File(filepath string) string { - f, err := os.Open(filepath) +/* +如果bynum=true 则把文件分割成num份 +如果bynum=false 则把文件按num字节分成多份 +*/ +func (this StarCrypto) SplitFile(src, dst string, num int, bynum bool, shell func(float64)) error { + if !Exists(src) { + return errors.New("Source File Not Exists!") + } + fpsrc, err := os.Open(src) if err != nil { - fmt.Println("Open", err) - return "" + return err + } + defer fpsrc.Close() + stat, _ := os.Stat(src) + filebig := float64(stat.Size()) + if bynum { + if int(filebig) < num { + return errors.New("File is too small to split") + } + } + balance := int(filebig/float64(num)) + 1 + if !bynum { + balance = num } - defer f.Close() - md5hash := md5.New() - if _, err := io.Copy(md5hash, f); err != nil { - fmt.Println("Copy", err) - return "" + nownum := 0 + fpdst, err := os.Create(strings.Replace(dst, "*", fmt.Sprint(nownum), -1)) + if err != nil { + return err } - result := md5hash.Sum(nil) - return hex.EncodeToString(result) + defer fpdst.Close() + var sum, tsum int = 0, 0 + var buf []byte + for { + if balance-sum < 1048576 { + buf = make([]byte, balance-sum) + } else { + buf = make([]byte, 1048576) + } + n, err := fpsrc.Read(buf) + if err != nil { + if err == io.EOF { + break + } + return err + } + sum += n + tsum += n + fpdst.Write(buf[0:n]) + go shell(float64(tsum) / filebig * 100) + if sum == balance { + fpdst.Close() + nownum++ + fpdst, err = os.Create(strings.Replace(dst, "*", fmt.Sprint(nownum), -1)) + if err != nil { + return err + } + sum = 0 + } + } + return nil } -func Crc32File(filepath string) string { - f, err := os.Open(filepath) +func (this StarCrypto) MergeFile(src, dst string, shell func(float64)) error { + tmp := strings.Replace(src, "*", "0", -1) + dir, err := ioutil.ReadDir(filepath.Dir(tmp)) if err != nil { - fmt.Println("Open", err) - return "" + return err + } + base := filepath.Base(src) + tmp = strings.Replace(base, "*", "(\\d+)", -1) + reg := regexp.MustCompile(tmp) + count := 0 + var filebig float64 = 0 + for _, v := range dir { + if reg.MatchString(v.Name()) { + count++ + filebig += float64(v.Size()) + } } - - 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) + fpdst, err := os.Create(dst) + defer fpdst.Close() + if err != nil { + return err + } + sum := 0 + for i := 0; i < count; i++ { + fpsrc, err := os.Open(strings.Replace(src, "*", strconv.Itoa(i), -1)) + if err != nil { + return err + } + for { + buf := make([]byte, 1048576) + n, err := fpsrc.Read(buf) + if err != nil { + if err == io.EOF { + break + } + return err + } + sum += n + go shell(float64(sum) / filebig * 100) + fpdst.Write(buf[0:n]) + } + fpsrc.Close() + } + return nil } -func Sha1File(filepath string) string { - f, err := os.Open(filepath) +func (this StarCrypto) RSAEncrypt(data, public []byte) ([]byte, error) { + blk, _ := pem.Decode(public) + if blk == nil { + return []byte{}, errors.New("public key error！") + } + pubkey, err := x509.ParsePKIXPublicKey(blk.Bytes) if err != nil { - fmt.Println("Open", err) - return "" + return []byte{}, err } - - 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) + return rsa.EncryptPKCS1v15(rand.Reader, pubkey.(*rsa.PublicKey), data) } -func Sha256File(filepath string) string { - f, err := os.Open(filepath) - if err != nil { - fmt.Println("Open", err) - return "" +func (this StarCrypto) RSADecrypt(data, private []byte, password string) ([]byte, error) { + var prikey *rsa.PrivateKey + var err error + blk, _ := pem.Decode(private) + if blk == nil { + return []byte{}, errors.New("private key error！") + } + if password != "" { + tmp, err := x509.DecryptPEMBlock(blk, []byte(password)) + if err != nil { + return []byte{}, err + } + prikey, err = x509.ParsePKCS1PrivateKey(tmp) + if err != nil { + return []byte{}, err + } + } else { + prikey, err = x509.ParsePKCS1PrivateKey(blk.Bytes) + if err != nil { + return []byte{}, err + } } + return rsa.DecryptPKCS1v15(rand.Reader, prikey, data) +} - 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 (this StarCrypto) RSASign(hash256, private []byte, password string) ([]byte, error) { + var prikey *rsa.PrivateKey + var err error + blk, _ := pem.Decode(private) + if blk == nil { + return []byte{}, errors.New("private key error！") + } + if password != "" { + tmp, err := x509.DecryptPEMBlock(blk, []byte(password)) + if err != nil { + return []byte{}, err + } + prikey, err = x509.ParsePKCS1PrivateKey(tmp) + if err != nil { + return []byte{}, err + } + } else { + prikey, err = x509.ParsePKCS1PrivateKey(blk.Bytes) + if err != nil { + return []byte{}, err + } + } + return rsa.SignPKCS1v15(rand.Reader, prikey, crypto.SHA256, hash256) } -func Sha512File(filepath string) string { - f, err := os.Open(filepath) +func (this StarCrypto) RSAVerify(data, hash256, public []byte) error { + blk, _ := pem.Decode(public) + if blk == nil { + return errors.New("public key error！") + } + pubkey, err := x509.ParsePKIXPublicKey(blk.Bytes) if err != nil { - fmt.Println("Open", err) - return "" + return err } - - 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) + return rsa.VerifyPKCS1v15(pubkey.(*rsa.PublicKey), crypto.SHA256, hash256, data) } -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 +func (this StarCrypto) VicqueEncodeV1(srcdata []byte, key string) []byte { + var keys []int + var saku, piku uint8 + data := make([]byte, len(srcdata)) + copy(data, srcdata) + binary.Read(rand.Reader, binary.LittleEndian, &saku) + binary.Read(rand.Reader, binary.LittleEndian, &piku) + keys = append(keys, len(key)+int(saku)) + lens := len(data) + for _, v := range key { + keys = append(keys, int(byte(v))+int(saku)-int(piku)) + } + lenkey := len(keys) + for k, v := range data { + if k == lens/2 { + break + } + nv := int(v) + t := 0 + if k%2 == 0 { + nv += keys[k%lenkey] + if nv > 255 { + nv -= 256 + } + t = int(data[lens-1-k]) + t += keys[k%lenkey] + if t > 255 { + t -= 256 + } + } else { + nv -= keys[k%lenkey] + if nv < 0 { + nv += 256 + } + t = int(data[lens-1-k]) + t -= keys[k%lenkey] + if t > 255 { + t += 256 + } + } + data[k] = byte(t) + data[lens-1-k] = byte(nv) } - data := make([]byte, buffer) - i := int64(0) - for { - data = data[:cap(data)] + data = append(data, byte(saku), byte(piku)) + return data +} - // read bytes to slice - n, err := fp.Read(data) - if err != nil { - if err == io.EOF { - break - } - fmt.Println(err) +func (this StarCrypto) VicqueDecodeV1(srcdata []byte, key string) []byte { + var keys []int + var saku, piku int + data := make([]byte, len(srcdata)) + copy(data, srcdata) + lens := len(data) + saku = int(data[lens-2]) + piku = int(data[lens-1]) + keys = append(keys, len(key)+int(saku)) + for _, v := range key { + keys = append(keys, int(byte(v))+int(saku)-int(piku)) + } + lenkey := len(keys) + lens -= 2 + for k, v := range data { + if k == lens/2 { break } - i += int64(n) - if i < key { - data = data[:n] - fpw.Write(data) + nv := int(v) + t := 0 + if k%2 == 0 { + nv -= keys[k%lenkey] + if nv < 0 { + nv += 256 + } + t = int(data[lens-1-k]) + t -= keys[k%lenkey] + if t > 255 { + t += 256 + } } else { - data = data[:(int64(n) - i + key)] - fpw.Write(data) - break + nv += keys[k%lenkey] + if nv > 255 { + nv -= 256 + } + t = int(data[lens-1-k]) + t += keys[k%lenkey] + if t > 255 { + t -= 256 + } } + data[k] = byte(t) + data[lens-1-k] = byte(nv) } - fpw.Close() - _, _ = fp.Seek(key+20, 0) - fpw, _ = os.Create(output2) - for { - data = data[:cap(data)] + return data[:lens] +} - // read bytes to slice - n, err := fp.Read(data) +func (this StarCrypto) VicqueEncodeV1File(src, dst, pwd string, shell func(float64)) error { + fpsrc, err := os.Open(src) + if err != nil { + return err + } + defer fpsrc.Close() + stat, _ := os.Stat(src) + filebig := float64(stat.Size()) + sum := 0 + defer fpsrc.Close() + fpdst, err := os.Create(dst) + if err != nil { + return err + } + defer fpdst.Close() + for { + buf := make([]byte, 1048576) + n, err := fpsrc.Read(buf) if err != nil { if err == io.EOF { break } - fmt.Println(err) - break + return err } - data = data[:n] - fpw.Write(data) + sum += n + go shell(float64(sum) / filebig * 100) + data := this.VicqueEncodeV1(buf[0:n], pwd) + fpdst.Write(data) } - return true + return nil } -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) + +func (this StarCrypto) VicqueDecodeV1File(src, dst, pwd string, shell func(float64)) error { + fpsrc, err := os.Open(src) + if err != nil { + return err + } + defer fpsrc.Close() + stat, _ := os.Stat(src) + filebig := float64(stat.Size()) + sum := 0 + defer fpsrc.Close() + fpdst, err := os.Create(dst) + if err != nil { + return err + } + defer fpdst.Close() for { - data = data[:cap(data)] - // read bytes to slice - n, err := fp.Read(data) + buf := make([]byte, 1048578) + n, err := fpsrc.Read(buf) if err != nil { if err == io.EOF { break } - fmt.Println(err) - break + return err } - data = data[:n] - fpw.Write(data) + sum += n + go shell(float64(sum) / filebig * 100) + data := this.VicqueDecodeV1(buf[0:n], pwd) + fpdst.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 + return nil +} + +func FillWithRandom(filepath string, filesize int, bufcap int, bufnum int, shell func(float64)) error { + var buf [][]byte + var buftmp []byte + rands.Seed(time.Now().Unix()) + if bufnum <= 0 { + bufnum = 1 + } + if bufcap > filesize { + bufcap = filesize + } + myfile, err := os.Create(filepath) + if err != nil { + return err + } + defer myfile.Close() + writer := bufio.NewWriter(myfile) + for i := 0; i < bufnum; i++ { + buftmp = []byte{} + for j := 0; j < bufcap; j++ { + buftmp = append(buftmp, byte(rands.Intn(255))) + } + buf = append(buf, buftmp) } - data = make([]byte, buffer) + sum := 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) + if filesize-sum < bufcap { + writer.Write(buf[rands.Intn(bufnum-1)][0 : filesize-sum]) + sum += filesize - sum + } else { + writer.Write(buf[rands.Intn(bufnum-1)]) + sum += bufcap + } + go shell(float64(sum) / float64(filesize) * 100) + if sum >= filesize { break } - data = data[:n] - fpw.Write(data) } - fp.Close() - return true, strconv.FormatInt(filesize, 10) + writer.Flush() + return nil } diff --git a/crypto.go.old b/crypto.go.old new file mode 100644 index 0000000..9d2214f --- /dev/null +++ b/crypto.go.old @@ -0,0 +1,536 @@ +package starainrt + +import ( + "crypto/md5" + "crypto/rc4" + "crypto/sha1" + "crypto/sha256" + "crypto/sha512" + "encoding/base64" + "encoding/hex" + "fmt" + "hash/crc32" + "io" + "io/ioutil" + "os" + "regexp" + "strconv" +) + +type StarCrypto struct { +} + +func (this StarCrypto) 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 (this StarCrypto) 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 (this StarCrypto) 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 := this.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 (this StarCrypto) 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 (this StarCrypto) 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 (this StarCrypto) 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) +} diff --git a/crypto_test.go b/crypto_test.go new file mode 100644 index 0000000..509b38d --- /dev/null +++ b/crypto_test.go @@ -0,0 +1,13 @@ +package starainrt + +import ( + "fmt" + "testing" +) + +func Test_FileSumAll(t *testing.T) { + cry := new(StarCrypto) + fmt.Println(cry.FileSumAll("D:\\Download\\macos.iso", func(pect float64) { + fmt.Printf("已处理%f\r", pect) + })) +} diff --git a/database.go b/database.go index 13902f0..27eedbb 100644 --- a/database.go +++ b/database.go @@ -3,9 +3,333 @@ package starainrt import ( "database/sql" "errors" + "reflect" "strconv" ) +var DBRes *sql.DB +var DBRows *sql.Rows + +type StarDB struct { + DB *sql.DB + Rows *sql.Rows +} + +type StarRows struct { + Rows *sql.Rows + Length int + StringResult []map[string]string + Columns []string + ColumnsType []reflect.Type + columnref map[string]int + result [][]interface{} +} + +type StarResult struct { + Result []interface{} + Columns []string + columnref map[string]int + ColumnsType []reflect.Type +} + +type StarResultCol struct { + Result []interface{} +} + +func (this *StarResultCol) MustBytes() [][]byte { + var res [][]byte + for _, v := range this.Result { + res = append(res, v.([]byte)) + } + return res +} + +func (this *StarResultCol) MustBool() []bool { + var res []bool + for _, v := range this.Result { + res = append(res, v.(bool)) + } + return res +} +func (this *StarResultCol) MustFloat32() []float32 { + var res []float32 + for _, v := range this.Result { + res = append(res, v.(float32)) + } + return res +} +func (this *StarResultCol) MustFloat64() []float64 { + var res []float64 + for _, v := range this.Result { + res = append(res, v.(float64)) + } + return res +} +func (this *StarResultCol) MustString() []string { + var res []string + for _, v := range this.Result { + res = append(res, v.(string)) + } + return res +} +func (this *StarResultCol) MustInt32() []int32 { + var res []int32 + for _, v := range this.Result { + res = append(res, v.(int32)) + } + return res +} +func (this *StarResultCol) MustInt64() []int64 { + var res []int64 + for _, v := range this.Result { + res = append(res, v.(int64)) + } + return res +} +func (this *StarResultCol) MustInt() []int { + var res []int + for _, v := range this.Result { + res = append(res, v.(int)) + } + return res +} + +func (this *StarResult) MustInt64(name string) int64 { + num, ok := this.columnref[name] + if !ok { + return 0 + } + res := this.Result[num].(int64) + return res +} +func (this *StarResult) MustInt32(name string) int32 { + num, ok := this.columnref[name] + if !ok { + return 0 + } + res := this.Result[num].(int32) + return res +} +func (this *StarResult) MustString(name string) string { + num, ok := this.columnref[name] + if !ok { + return "" + } + res := this.Result[num].(string) + return res +} +func (this *StarResult) MustFloat64(name string) float64 { + num, ok := this.columnref[name] + if !ok { + return 0 + } + res := this.Result[num].(float64) + return res +} +func (this *StarResult) MustFloat32(name string) float32 { + num, ok := this.columnref[name] + if !ok { + return 0 + } + res := this.Result[num].(float32) + return res +} +func (this *StarResult) MustInt(name string) int { + num, ok := this.columnref[name] + if !ok { + return 0 + } + res := this.Result[num].(int) + return res +} + +func (this *StarResult) MustBool(name string) bool { + num, ok := this.columnref[name] + if !ok { + return false + } + res := this.Result[num].(bool) + return res +} +func (this *StarResult) MustBytes(name string) []byte { + num, ok := this.columnref[name] + if !ok { + return []byte{} + } + res := this.Result[num].([]byte) + return res +} + +func (this *StarRows) Rescan() { + this.parserows() +} + +func (this *StarRows) Col(name string) *StarResultCol { + result := new(StarResultCol) + if _, ok := this.columnref[name]; !ok { + return result + } + var rescol []interface{} + for _, v := range this.result { + rescol = append(rescol, v[this.columnref[name]]) + } + result.Result = rescol + return result +} + +func (this *StarRows) Row(id int) *StarResult { + result := new(StarResult) + if id+1 > len(this.result) { + return result + } + result.Result = this.result[id] + result.Columns = this.Columns + result.ColumnsType = this.ColumnsType + result.columnref = this.columnref + return result +} + +func (this *StarRows) Close() error { + return this.Rows.Close() +} + +func (this *StarRows) parserows() { + this.result = [][]interface{}{} + this.columnref = make(map[string]int) + this.StringResult = []map[string]string{make(map[string]string)} + this.Columns, _ = this.Rows.Columns() + types, _ := this.Rows.ColumnTypes() + for _, v := range types { + this.ColumnsType = append(this.ColumnsType, v.ScanType()) + } + scanArgs := make([]interface{}, len(this.Columns)) + values := make([]interface{}, len(this.Columns)) + for i, _ := range values { + this.columnref[this.Columns[i]] = i + scanArgs[i] = &values[i] + } + for this.Rows.Next() { + if err := this.Rows.Scan(scanArgs...); err != nil { + return + } + record := make(map[string]string) + var rescopy []interface{} + for i, col := range values { + rescopy = append(rescopy, col) + switch vtype := col.(type) { + case float64: + record[this.Columns[i]] = strconv.FormatFloat(vtype, 'f', -1, 64) + case int64: + record[this.Columns[i]] = strconv.FormatInt(vtype, 10) + case string: + record[this.Columns[i]] = vtype + case nil: + record[this.Columns[i]] = "" + default: + record[this.Columns[i]] = string(vtype.([]byte)) + } + } + this.result = append(this.result, rescopy) + this.StringResult = append(this.StringResult, record) + } + this.Length = len(this.StringResult) +} + +func (this *StarDB) Query(args ...interface{}) (*StarRows, error) { + var err error + effect := new(StarRows) + if err = this.DB.Ping(); err != nil { + return effect, err + } + if len(args) == 0 { + return effect, errors.New("no args") + } + if len(args) == 1 { + sql := args[0] + if this.Rows, err = this.DB.Query(sql.(string)); err != nil { + return effect, err + } + effect.Rows = this.Rows + effect.parserows() + return effect, nil + } + sql := args[0] + stmt, err := this.DB.Prepare(sql.(string)) + defer stmt.Close() + if err != nil { + return effect, err + } + var para []interface{} + for k, v := range args { + if k != 0 { + switch vtype := v.(type) { + default: + para = append(para, vtype) + } + } + } + if this.Rows, err = stmt.Query(para...); err != nil { + return effect, err + } + effect.Rows = this.Rows + effect.parserows() + return effect, nil +} + +func (this *StarDB) Open(Method, ConnStr string) error { + var err error + this.DB, err = sql.Open(Method, ConnStr) + if err != nil { + return err + } + err = this.DB.Ping() + return err +} + +func (this *StarDB) Close() error { + if err := this.DB.Close(); err != nil { + return err + } + return this.Rows.Close() +} + +func (this *StarDB) Exec(args ...interface{}) (sql.Result, error) { + var err error + var effect sql.Result + if err = this.DB.Ping(); err != nil { + return effect, err + } + if len(args) == 0 { + return effect, errors.New("no args") + } + if len(args) == 1 { + sql := args[0] + if _, err = this.DB.Exec(sql.(string)); err != nil { + return effect, err + } + return effect, nil + } + sql := args[0] + stmt, err := this.DB.Prepare(sql.(string)) + defer stmt.Close() + if err != nil { + return effect, err + } + var para []interface{} + for k, v := range args { + if k != 0 { + switch vtype := v.(type) { + default: + para = append(para, vtype) + } + } + } + if effect, err = stmt.Exec(para...); err != nil { + return effect, err + } + return effect, nil +} + func FetchAll(rows *sql.Rows) (error, map[int]map[string]string) { var ii int = 0 records := make(map[int]map[string]string) @@ -31,6 +355,8 @@ func FetchAll(rows *sql.Rows) (error, map[int]map[string]string) { record[columns[i]] = strconv.FormatInt(vtype, 10) case string: record[columns[i]] = vtype + case nil: + record[columns[i]] = "" default: record[columns[i]] = string(vtype.([]byte)) } diff --git a/database_test.go b/database_test.go new file mode 100644 index 0000000..c16222a --- /dev/null +++ b/database_test.go @@ -0,0 +1,19 @@ +package starainrt + +import ( + "fmt" + "testing" + + _ "github.com/mattn/go-sqlite3" +) + +func TestDataBase(t *testing.T) { + mysql := new(StarDB) + defer mysql.Close() + mysql.Open("sqlite3", "D:\\Ttest.db") + mysql.Exec("CREATE TABLE IF NOT EXISTS sakura(id INT PRIMARY KEY,xihuan TEXT)") + mysql.Exec("INSERT INTO sakura VALUES(?,?)", 2, "dssfsdfdf") + sakura, _ := mysql.Query("SELECT * FROM sakura") + defer sakura.Close() + fmt.Println(sakura.Row(0).MustString("xihuan")) +} diff --git a/net.go b/net.go new file mode 100644 index 0000000..843c83f --- /dev/null +++ b/net.go @@ -0,0 +1,385 @@ +package starainrt + +import ( + "bytes" + "crypto/rand" + "fmt" + "io" + "io/ioutil" + "mime/multipart" + "net" + "net/http" + urls "net/url" + "os" + "path/filepath" + "time" +) + +type StarCurl struct { + TimeOut int + DialTimeOut int + ReqHeader http.Header + ReqCookies []*http.Cookie + RespHeader http.Header + RespCookies []*http.Cookie + RespHttpCode int + PostBuffer *bytes.Buffer + CircleBuffer *CircleByteBuffer + Proxy string +} + +func NewStarCurl() *StarCurl { + star := new(StarCurl) + star.ReqHeader = make(http.Header) + star.TimeOut = 60 + star.DialTimeOut = 15 + star.PostBuffer = nil + return star +} + +func (this *StarCurl) ResetReqHeader() { + this.ReqHeader = make(http.Header) +} + +func (this *StarCurl) ResetReqCookies() { + this.ReqCookies = []*http.Cookie{} +} + +func (this *StarCurl) AddSimpleCookie(key, value string) { + this.ReqCookies = append(this.ReqCookies, &http.Cookie{Name: key, Value: value}) +} + +func randomBoundary() string { + var buf [30]byte + _, err := io.ReadFull(rand.Reader, buf[:]) + if err != nil { + panic(err) + } + return fmt.Sprintf("%x", buf[:]) + +} + +func (this *StarCurl) CurlWithFile(url string, postdata map[string]string, formname, fpath, savepath string, tofile bool, shell func(float64)) (result []byte, err error) { + fpsrc, err := os.Open(fpath) + if err != nil { + return + } + defer fpsrc.Close() + boundary := randomBoundary() + boundarybytes := []byte("\r\n--" + boundary + "\r\n") + endbytes := []byte("\r\n--" + boundary + "--\r\n") + fpstat, _ := os.Stat(fpath) + filebig := float64(fpstat.Size()) + sum, n := 0, 0 + fpdst := NewCircleByteBuffer(1048576) + if postdata != nil { + for k, v := range postdata { + header := fmt.Sprintf("Content-Disposition: form-data; name=\"%s\";\r\nContent-Type: x-www-form-urlencoded \r\n\r\n", k) + fpdst.Write(boundarybytes) + fpdst.Write([]byte(header)) + fpdst.Write([]byte(v)) + } + } + header := fmt.Sprintf("Content-Disposition: form-data; name=\"%s\"; filename=\"%s\"\r\nContent-Type: application/octet-stream\r\n\r\n", formname, fpstat.Name()) + fpdst.Write(boundarybytes) + fpdst.Write([]byte(header)) + go func() { + for { + bufs := make([]byte, 1048576) + n, err = fpsrc.Read(bufs) + if err != nil { + if err == io.EOF { + break + } + return + } + sum += n + go shell(float64(sum) / filebig * 100) + fpdst.Write(bufs[0:n]) + } + fpdst.Write(endbytes) + fpdst.Write(nil) + + }() + this.CircleBuffer = fpdst + this.ReqHeader.Set("Content-Type", "multipart/form-data;boundary="+boundary) + if tofile { + err = this.CurlDataToFile(url, []byte{}, "POST", savepath, shell) + this.ResetReqHeader() + } else { + result, err = this.Curl(url, []byte{}, "POST") + } + this.ResetReqHeader() + return +} + +func (this *StarCurl) CurlWithFileByMemory(url string, postdata map[string]string, formname, fpath, savepath string, tofile bool, shell func(float64)) (result []byte, err error) { + buf := &bytes.Buffer{} + bufwriter := multipart.NewWriter(buf) + if postdata != nil { + for k, v := range postdata { + bufwriter.WriteField(k, v) + } + } + fpdst, err := bufwriter.CreateFormFile(formname, filepath.Base(fpath)) + if err != nil { + return + } + fpsrc, err := os.Open(fpath) + if err != nil { + return + } + defer fpsrc.Close() + fpstat, _ := os.Stat(fpath) + filebig := float64(fpstat.Size()) + sum, n := 0, 0 + for { + bufs := make([]byte, 1048576) + n, err = fpsrc.Read(bufs) + if err != nil { + if err == io.EOF { + break + } + return + } + sum += n + go shell(float64(sum) / filebig * 100) + fpdst.Write(bufs[0:n]) + } + + this.PostBuffer = buf + this.ReqHeader.Set("Content-Type", "multipart/form-data;boundary="+bufwriter.Boundary()) + bufwriter.Close() + if tofile { + err = this.CurlDataToFile(url, []byte{}, "POST", savepath, shell) + this.ResetReqHeader() + } else { + result, err = this.Curl(url, []byte{}, "POST") + } + this.ResetReqHeader() + return +} + +func (this *StarCurl) CurlDataToFile(url string, postdata []byte, method, fpath string, shell func(float64)) (err error) { + var req *http.Request + if method == "" { + if len(postdata) != 0 { + method = "POST" + } else { + method = "GET" + } + } + if len(postdata) == 0 && this.PostBuffer == nil && this.CircleBuffer == nil { + req, err = http.NewRequest(method, url, nil) + } else if len(postdata) != 0 { + req, err = http.NewRequest(method, url, bytes.NewBuffer(postdata)) + } else if this.PostBuffer != nil { + req, err = http.NewRequest(method, url, this.PostBuffer) + } else { + req, err = http.NewRequest(method, url, this.CircleBuffer) + } + if err != nil { + return + } + if (this.ReqHeader == nil) && method == "POST" { + this.ReqHeader.Set("Content-Type", "application/x-www-form-urlencoded") + } + req.Header = this.ReqHeader + if len(this.ReqCookies) != 0 { + for _, v := range this.ReqCookies { + req.AddCookie(v) + } + } + transport := &http.Transport{ + Dial: func(netw, addr string) (net.Conn, error) { + deadline := time.Now().Add(time.Duration(this.TimeOut) * time.Second) + c, err := net.DialTimeout(netw, addr, time.Second*time.Duration(this.DialTimeOut)) + if err != nil { + return nil, err + } + if this.TimeOut != 0 { + c.SetDeadline(deadline) + } + return c, nil + }, + } + if this.Proxy != "" { + purl, _ := urls.Parse(this.Proxy) + transport.Proxy = http.ProxyURL(purl) + } + client := &http.Client{ + Transport: transport, + } + resp, err := client.Do(req) + if err != nil { + return + } + defer resp.Body.Close() + this.PostBuffer = nil + this.CircleBuffer = nil + this.RespHttpCode = resp.StatusCode + this.RespHeader = resp.Header + this.RespCookies = resp.Cookies() + fpsrc, err := os.Create(fpath) + if err != nil { + return + } + defer fpsrc.Close() + filebig := float64(resp.ContentLength) + if filebig <= 0 { + filebig = 100 + } + var n, sum int = 0, 0 + for { + buf := make([]byte, 1048576) + n, err = resp.Body.Read(buf) + if err != nil { + if err == io.EOF { + err = nil + go shell(100.00) + break + } + return + } + sum += n + go shell(float64(sum) / filebig * 100.00) + fpsrc.Write(buf[0:n]) + } + return +} + +func (this *StarCurl) Curl(url string, postdata []byte, method string) (body []byte, err error) { + var req *http.Request + if method == "" { + if len(postdata) != 0 { + method = "POST" + } else { + method = "GET" + } + } + if len(postdata) == 0 && this.PostBuffer == nil && this.CircleBuffer == nil { + req, err = http.NewRequest(method, url, nil) + } else if len(postdata) != 0 { + req, err = http.NewRequest(method, url, bytes.NewBuffer(postdata)) + } else if this.PostBuffer != nil { + req, err = http.NewRequest(method, url, this.PostBuffer) + } else { + req, err = http.NewRequest(method, url, this.CircleBuffer) + } + if err != nil { + return + } + if (this.ReqHeader == nil) && method == "POST" { + this.ReqHeader.Set("Content-Type", "application/x-www-form-urlencoded") + } + req.Header = this.ReqHeader + if len(this.ReqCookies) != 0 { + for _, v := range this.ReqCookies { + req.AddCookie(v) + } + } + transport := &http.Transport{ + Dial: func(netw, addr string) (net.Conn, error) { + deadline := time.Now().Add(time.Duration(this.TimeOut) * time.Second) + c, err := net.DialTimeout(netw, addr, time.Second*time.Duration(this.DialTimeOut)) + if err != nil { + return nil, err + } + if this.TimeOut != 0 { + c.SetDeadline(deadline) + } + return c, nil + }, + } + if this.Proxy != "" { + purl, _ := urls.Parse(this.Proxy) + transport.Proxy = http.ProxyURL(purl) + } + client := &http.Client{ + Transport: transport, + } + resp, err := client.Do(req) + if err != nil { + return + } + defer resp.Body.Close() + this.PostBuffer = nil + this.CircleBuffer = nil + this.RespHttpCode = resp.StatusCode + this.RespHeader = resp.Header + this.RespCookies = resp.Cookies() + body, err = ioutil.ReadAll(resp.Body) + return +} + +//HttpNulReset将重置Header和Cookie为空 +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() + +} + +//CurlGet发起一个HTTP GET请求 +func CurlGet(url string) (error, []byte) { + err, _, res, _, _ := Curl(url, "", HttpNul, HttpNul2, "GET") + return err, res +} + +//CurlPost发起一个基于表单的HTTP Post请求 +func CurlPost(url, postdata string) (error, []byte) { + err, _, res, _, _ := Curl(url, postdata, HttpNul, HttpNul2, "POST") + return err, res +} diff --git a/starainrt.go b/starainrt.go index a7670c6..95ce501 100644 --- a/starainrt.go +++ b/starainrt.go @@ -1,22 +1,42 @@ package starainrt import ( - "bytes" - "database/sql" - "io/ioutil" - "net" - "net/http" + "errors" + "fmt" + "io" "os" "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 +type CircleByteBuffer struct { + io.Reader + io.Writer + io.Closer + datas []byte + + start int + end int + size int + isClose bool + isEnd bool +} + +func NewCircleByteBuffer(len int) *CircleByteBuffer { + var e = new(CircleByteBuffer) + e.datas = make([]byte, len) + e.start = 0 + e.end = 0 + e.size = len + e.isClose = false + e.isEnd = false + return e +} + //Exits返回指定文件夹/文件是否存在 func Exists(filepath string) bool { _, err := os.Stat(filepath) @@ -46,74 +66,128 @@ func IsFolder(fpath string) bool { return s.IsDir() } -//CurlGet发起一个HTTP GET请求 -func CurlGet(url string) (error, []byte) { - err, _, res, _, _ := Curl(url, "", HttpNul, HttpNul2, "GET") - return err, res +func (e *CircleByteBuffer) getLen() int { + if e.start == e.end { + return 0 + } else if e.start < e.end { + return e.end - e.start + } else { + return e.start - e.end + } } - -//CurlPost发起一个基于表单的HTTP Post请求 -func CurlPost(url, postdata string) (error, []byte) { - err, _, res, _, _ := Curl(url, postdata, HttpNul, HttpNul2, "POST") - return err, res +func (e *CircleByteBuffer) getFree() int { + return e.size - e.getLen() +} +func (e *CircleByteBuffer) putByte(b byte) error { + if e.isClose { + return io.EOF + } + e.datas[e.end] = b + var pos = e.end + 1 + for pos == e.start { + if e.isClose { + return io.EOF + } + time.Sleep(time.Microsecond) + } + if pos == e.size { + e.end = 0 + } else { + e.end = pos + } + return nil } -//HttpNulReset将重置Header和Cookie为空 -func HttpNulReset() { - var tmp map[string]string - HttpNul, HttpNul2 = tmp, tmp +func (e *CircleByteBuffer) getByte() (byte, error) { + if e.isClose { + return 0, io.EOF + } + if e.isEnd && e.getLen() <= 0 { + return 0, io.EOF + } + if e.getLen() <= 0 { + return 0, errors.New("no datas") + } + var ret = e.datas[e.start] + e.start++ + if e.start == e.size { + e.start = 0 + } + return ret, nil +} +func (e *CircleByteBuffer) geti(i int) byte { + if i >= e.getLen() { + panic("out buffer") + } + var pos = e.start + i + if pos >= e.size { + pos -= e.size + } + return e.datas[pos] } -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" +/*func (e*CircleByteBuffer)puts(bts []byte){ + for i:=0;i