Add rlib

raylib/rres.go

@@ -1,26 +1,14 @@
 package raylib
 
 import (
-	"bytes"
-	"crypto/aes"
-	"crypto/cipher"
-	"crypto/des"
 	"encoding/binary"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"os"
 	"unsafe"
 
-	"github.com/dsnet/compress/bzip2"
-	"github.com/klauspost/compress/flate"
-	"github.com/pierrec/lz4"
-	"github.com/rootlch/encrypt"
-	"github.com/ulikunitz/xz"
-	"golang.org/x/crypto/blowfish"
-	"golang.org/x/crypto/xtea"
-
 	"github.com/gen2brain/raylib-go/rres"
+	"github.com/gen2brain/raylib-go/rres/rlib"
 )
 
 // LoadResource - Load resource from file by id
@@ -68,14 +56,14 @@ func LoadResource(reader io.ReadSeeker, rresID int, key []byte) (data rres.Data)
 			b := make([]byte, infoHeader.DataSize)
 			reader.Read(b)
 
-			// Uncompress data
-			data.Data, err = uncompress(b, int(infoHeader.CompType))
+			// Decompress data
+			data.Data, err = rlib.Decompress(b, int(infoHeader.CompType))
 			if err != nil {
 				TraceLog(LogWarning, "[ID %d] %v", infoHeader.ID, err)
 			}
 
 			// Decrypt data
-			data.Data, err = decrypt(key, data.Data, int(infoHeader.CryptoType))
+			data.Data, err = rlib.Decrypt(key, data.Data, int(infoHeader.CryptoType))
 			if err != nil {
 				TraceLog(LogWarning, "[ID %d] %v", infoHeader.ID, err)
 			}
@@ -95,209 +83,3 @@ func LoadResource(reader io.ReadSeeker, rresID int, key []byte) (data rres.Data)
 
 	return
 }
-
-// decrypt data
-func decrypt(key, data []byte, cryptoType int) ([]byte, error) {
-	switch cryptoType {
-	case rres.CryptoXOR:
-		c, err := encrypt.NewXor(string(key))
-		if err != nil {
-			return nil, err
-		}
-
-		b := c.Encode(data)
-		return b, nil
-	case rres.CryptoAES:
-		b, err := decryptAES(key, data)
-		if err != nil {
-			return nil, err
-		}
-		return b, nil
-	case rres.Crypto3DES:
-		b, err := decrypt3DES(key, data)
-		if err != nil {
-			return nil, err
-		}
-		return b, nil
-	case rres.CryptoBlowfish:
-		b, err := decryptBlowfish(key, data)
-		if err != nil {
-			return nil, err
-		}
-		return b, nil
-	case rres.CryptoXTEA:
-		b, err := decryptXTEA(key, data)
-		if err != nil {
-			return nil, err
-		}
-		return b, nil
-	default:
-		return data, nil
-	}
-}
-
-// uncompress data
-func uncompress(data []byte, compType int) ([]byte, error) {
-	switch compType {
-	case rres.CompNone:
-		return data, nil
-	case rres.CompDeflate:
-		r := flate.NewReader(bytes.NewReader(data))
-
-		u, err := ioutil.ReadAll(r)
-		if err != nil {
-			return nil, err
-		}
-
-		r.Close()
-
-		return u, nil
-	case rres.CompLZ4:
-		r := lz4.NewReader(bytes.NewReader(data))
-
-		u, err := ioutil.ReadAll(r)
-		if err != nil {
-			return nil, err
-		}
-
-		return u, nil
-	case rres.CompLZMA2:
-		r, err := xz.NewReader(bytes.NewReader(data))
-		if err != nil {
-			return nil, err
-		}
-
-		u, err := ioutil.ReadAll(r)
-		if err != nil {
-			return nil, err
-		}
-
-		return u, nil
-	case rres.CompBZIP2:
-		r, err := bzip2.NewReader(bytes.NewReader(data), &bzip2.ReaderConfig{})
-		if err != nil {
-			return nil, err
-		}
-
-		u, err := ioutil.ReadAll(r)
-		if err != nil {
-			return nil, err
-		}
-
-		return u, nil
-	default:
-		return data, nil
-	}
-}
-
-// unpad
-func unpad(src []byte) ([]byte, error) {
-	length := len(src)
-	unpadding := int(src[length-1])
-
-	if unpadding > length {
-		return nil, fmt.Errorf("unpad error. This can happen when incorrect encryption key is used.")
-	}
-
-	return src[:(length - unpadding)], nil
-}
-
-// decryptAES
-func decryptAES(key, text []byte) ([]byte, error) {
-	block, err := aes.NewCipher(key)
-	if err != nil {
-		return nil, err
-	}
-
-	if (len(text) % aes.BlockSize) != 0 {
-		return nil, fmt.Errorf("blocksize must be multiple of decoded message length")
-	}
-
-	iv := text[:aes.BlockSize]
-	msg := text[aes.BlockSize:]
-
-	cfb := cipher.NewCFBDecrypter(block, iv)
-	cfb.XORKeyStream(msg, msg)
-
-	unpadMsg, err := unpad(msg)
-	if err != nil {
-		return nil, err
-	}
-
-	return unpadMsg, nil
-}
-
-// decrypt3DES
-func decrypt3DES(key, text []byte) ([]byte, error) {
-	block, err := des.NewCipher(key)
-	if err != nil {
-		return nil, err
-	}
-
-	if (len(text) % des.BlockSize) != 0 {
-		return nil, fmt.Errorf("blocksize must be multiple of decoded message length")
-	}
-
-	iv := text[:des.BlockSize]
-	msg := text[des.BlockSize:]
-
-	cbc := cipher.NewCBCDecrypter(block, iv)
-	cbc.CryptBlocks(msg, msg)
-
-	unpadMsg, err := unpad(msg)
-	if err != nil {
-		return nil, err
-	}
-
-	return unpadMsg, nil
-}
-
-// decryptBlowfish
-func decryptBlowfish(key, text []byte) ([]byte, error) {
-	block, err := blowfish.NewCipher(key)
-	if err != nil {
-		return nil, err
-	}
-
-	if (len(text) % blowfish.BlockSize) != 0 {
-		return nil, fmt.Errorf("blocksize must be multiple of decoded message length")
-	}
-
-	iv := text[:blowfish.BlockSize]
-	msg := text[blowfish.BlockSize:]
-
-	cbc := cipher.NewCBCDecrypter(block, iv)
-	cbc.CryptBlocks(msg, msg)
-
-	unpadMsg, err := unpad(msg)
-	if err != nil {
-		return nil, err
-	}
-
-	return unpadMsg, nil
-}
-
-// decryptXTEA
-func decryptXTEA(key, text []byte) ([]byte, error) {
-	block, err := xtea.NewCipher(key)
-	if err != nil {
-		return nil, err
-	}
-
-	if (len(text) % xtea.BlockSize) != 0 {
-		return nil, fmt.Errorf("blocksize must be multiple of decoded message length")
-	}
-
-	iv := text[:xtea.BlockSize]
-	msg := text[xtea.BlockSize:]
-
-	cbc := cipher.NewCBCDecrypter(block, iv)
-	cbc.CryptBlocks(msg, msg)
-
-	unpadMsg, err := unpad(msg)
-	if err != nil {
-		return nil, err
-	}
-
-	return unpadMsg, nil
-}