You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
starainrt/starainrt.go

873 lines
17 KiB
Go

6 years ago
package starainrt
import (
"bufio"
6 years ago
"bytes"
6 years ago
"crypto/md5"
"crypto/rc4"
"crypto/sha1"
"crypto/sha256"
"crypto/sha512"
6 years ago
"database/sql"
"errors"
6 years ago
"encoding/base64"
"encoding/hex"
"fmt"
"hash/crc32"
"io"
"io/ioutil"
6 years ago
"net"
"net/http"
6 years ago
"os"
"regexp"
"strconv"
"strings"
6 years ago
"time"
6 years ago
)
6 years ago
var HttpNul, HttpNul2 map[string]string
var HttpTimeOut int64 = 15
var DBRes *sql.DB
var DBRows *sql.Rows
6 years ago
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()
}
6 years ago
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)
}
6 years ago
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
}