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/crypto.go

531 lines
10 KiB
Go

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"
)
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)
}