Initial commit

Author: rnben

.github/workflows/go.yml

@@ -0,0 +1,39 @@
+name: go-test
+
+on:
+  push:
+    branches:
+    - master
+  pull_request:
+    branches:
+    - master
+
+jobs:
+  build:
+    name: Test
+    runs-on: ubuntu-latest
+    steps:
+      # Checkout your project with git
+      - name: Checkout
+        uses: actions/checkout@v2
+
+      # Install Go on the VM running the action.
+      - name: Set up Go
+        uses: actions/setup-go@v2
+        with:
+          go-version: 1.16
+
+      - name: Install gocover-cobertura
+        run: |
+          go install github.com/boumenot/gocover-cobertura@latest
+
+      # Alternatively, install using go install
+      - name: Set up gotestfmt
+        run: |
+          go install github.com/gotesttools/gotestfmt/v2/cmd/gotestfmt@latest
+
+      # Run tests with nice formatting. Save the original log in /tmp/gotest.log
+      - name: Run tests
+        run: |
+          set -euo pipefail
+          go test -json -v -coverprofile=coverage.txt -v ./... 2>&1 | tee /tmp/gotest.log | gotestfmt

README.md

@@ -0,0 +1,5 @@
+# README
+
+Replicating MySQL DES Encryption Methods With Go
+
+[The result from des_encrypt is different from Java DESede Algorithm](https://bugs.mysql.com/bug.php?id=49249)

base64.go

@@ -0,0 +1,17 @@
+package mysqlfuncs
+
+import "encoding/base64"
+
+// ToBase64 MySQL TO_BASE64
+func ToBase64(b []byte) string {
+	return base64.StdEncoding.EncodeToString(b)
+}
+
+// FromBase64 MySQL FROM_BASE64
+func FromBase64(b string) ([]byte, error) {
+	if b == "" {
+		return nil, nil
+	}
+
+	return base64.StdEncoding.DecodeString(b)
+}

des_decrypt.go

@@ -0,0 +1,53 @@
+package mysqlfuncs
+
+import (
+	"crypto/cipher"
+	"crypto/des"
+	"crypto/md5"
+	"errors"
+	"fmt"
+	"github.com/rnben/mysql-funcs-go/openssl"
+)
+
+// DesDecrypt MySQL DES_DECRYPT
+func DesDecrypt(encrypted []byte, plainKey string) (res string, err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			err = fmt.Errorf("err: %v", r)
+			return
+		}
+	}()
+
+	length := len(encrypted)
+
+	if length == 0 {
+		return "", nil
+	}
+	if encrypted[0] != 0xff {
+		return "", errors.New("invalid encrypted text")
+	}
+
+	encrypted = encrypted[1:]
+	if len(encrypted)%8 != 0 {
+		return "", errors.New("invalid encrypted text")
+	}
+
+	iv := []byte{0, 0, 0, 0, 0, 0, 0, 0}
+	key, _ := openssl.EVPBytesToKey(24, 8, md5.New(), nil, []byte(plainKey), 1)
+
+	block, err := des.NewTripleDESCipher(key)
+	if err != nil {
+		return "", err
+	}
+
+	blockMode := cipher.NewCBCDecrypter(block, iv)
+	decrypted := make([]byte, length-1)
+	blockMode.CryptBlocks(decrypted, encrypted)
+	return string(unPadding(decrypted)), nil
+}
+
+func unPadding(decrypted []byte) []byte {
+	length := len(decrypted)
+	tail := int(decrypted[length-1])
+	return decrypted[:(length - tail)]
+}

des_encrypt.go

@@ -0,0 +1,51 @@
+package mysqlfuncs
+
+import (
+	"bytes"
+	"crypto/cipher"
+	"crypto/des"
+	"crypto/md5"
+	"fmt"
+	"github.com/rnben/mysql-funcs-go/openssl"
+)
+
+// DesEncrypt MySQL DES_ENCRYPT
+func DesEncrypt(plainText, plainKey string) (res []byte, err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			err = fmt.Errorf("panic: %v", r)
+			return
+		}
+	}()
+
+	if plainText == "" {
+		return nil, nil
+	}
+
+	orgLength := len(plainText)
+	resLength := orgLength + (8 - (orgLength % 8))
+
+	iv := []byte{0, 0, 0, 0, 0, 0, 0, 0}
+	text := padding([]byte(plainText), 8)
+	key, _ := openssl.EVPBytesToKey(24, 8, md5.New(), nil, []byte(plainKey), 1)
+
+	block, err := des.NewTripleDESCipher(key)
+	if err != nil {
+		return nil, err
+	}
+
+	blockMode := cipher.NewCBCEncrypter(block, iv)
+	cipherText := make([]byte, resLength)
+	blockMode.CryptBlocks(cipherText, text)
+
+	cipherText = append([]byte{255}, cipherText...)
+
+	return cipherText, nil
+}
+
+func padding(ciphertext []byte, blockSize int) []byte {
+	tail := blockSize - len(ciphertext)%blockSize
+	padText := bytes.Repeat([]byte("*"), tail)
+	padText[len(padText)-1] = byte(tail)
+	return append(ciphertext, padText...)
+}

go.mod

@@ -0,0 +1,3 @@
+module github.com/rnben/mysql-funcs-go
+
+go 1.16

go.sum

@@ -0,0 +1,73 @@
+package openssl
+
+import "hash"
+
+func EVPBytesToKey(keyLen int, ivLen int, md hash.Hash, salt []byte, data []byte, count int) ([]byte, []byte) {
+	key := make([]byte, keyLen)
+	keyIx := 0
+	iv := make([]byte, ivLen)
+	ivIx := 0
+	var mdBuf []byte
+	nkey := keyLen
+	niv := ivLen
+	i := 0
+	if data == nil {
+		return key, iv
+	}
+
+	addmd := 0
+	for {
+		md.Reset()
+		if addmd > 0 {
+			md.Write(mdBuf)
+		}
+		addmd++
+		md.Write(data)
+		if salt != nil {
+			md.Write(salt[:8])
+		}
+		mdBuf = md.Sum(nil)
+		for i = 1; i < count; i++ {
+			md.Reset()
+			md.Write(mdBuf)
+			mdBuf = md.Sum(nil)
+		}
+		i = 0
+		if nkey > 0 {
+			for {
+				if nkey == 0 {
+					break
+				}
+				if i == len(mdBuf) {
+					break
+				}
+				key[keyIx] = mdBuf[i]
+				keyIx++
+				nkey--
+				i++
+			}
+		}
+		if niv > 0 && i != len(mdBuf) {
+			for {
+				if niv == 0 {
+					break
+				}
+				if i == len(mdBuf) {
+					break
+				}
+				iv[ivIx] = mdBuf[i]
+				ivIx++
+				niv--
+				i++
+			}
+		}
+		if nkey == 0 && niv == 0 {
+			break
+		}
+	}
+	for i = 0; i < len(mdBuf); i++ {
+		mdBuf[i] = 0
+	}
+
+	return key, iv
+}

openssl/evp.go

@@ -0,0 +1,83 @@
+package tests
+
+import (
+	"reflect"
+	"testing"
+
+	. "github.com/rnben/mysql-funcs-go"
+)
+
+func TestDesDecrypt(t *testing.T) {
+	type args struct {
+		encrypted string
+		plainKey  string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    string
+		wantErr bool
+	}{
+		{
+			name: "test-01",
+			args: args{
+				plainKey:  "1234554321",
+				encrypted: "/4XOZReziOTR",
+			},
+			want: "d123456",
+		},
+		{
+			name: "test-02",
+			args: args{
+				plainKey:  "1234554321",
+				encrypted: "/xz9BQ1Ut+OK30k9ll72Nvs=",
+			},
+			want: "system123456",
+		},
+		{
+			name: "test-03",
+			args: args{
+				plainKey:  "1234554321",
+				encrypted: "",
+			},
+			want: "",
+		},
+		{
+			name: "test-04",
+			args: args{
+				plainKey:  "",
+				encrypted: "",
+			},
+			want: "",
+		},
+		{
+			name: "test-05",
+			args: args{
+				plainKey:  "",
+				encrypted: "/x5b4HgjdjYm",
+			},
+			want: "hello",
+		},
+		{
+			name: "test-06",
+			args: args{
+				plainKey:  "",
+				encrypted: "aGVsbG9oZWxs",
+			},
+			want:    "",
+			wantErr: true, // invalid encrypted text
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			encryptedBytes, _ := FromBase64(tt.args.encrypted)
+			got, err := DesDecrypt(encryptedBytes, tt.args.plainKey)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("DESDecrypt() error = %v, wantErr %v", err, tt.wantErr)
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("DesDecrypt() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}