Remove go module for example

Bumps [golang.org/x/crypto](https://github.com/golang/crypto) from 0.36.0 to 0.37.0.
- [Commits](https://github.com/golang/crypto/compare/v0.36.0...v0.37.0)

---
updated-dependencies:
- dependency-name: golang.org/x/crypto
  dependency-version: 0.37.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

README.md

@@ -1 +1,82 @@
-# go-transcrypt
+# go-transcrypt
+
+This library enables the encryption/decryption of arbitrary data into a hex-encoded string for safe on-disk storage.
+
+[![Go Reference](https://pkg.go.dev/badge/github.com/jantytgat/go-transcrypt.svg)](https://pkg.go.dev/github.com/jantytgat/go-transcrypt)
+
+---
+
+## Basics
+
+### Add the package to your project
+
+```bash
+go get github.com/jantytgat/go-transcrypt
+```
+
+### Import
+
+Next, you can manually add the import statement to your ```.go```-file, or have it added automatically when using it.
+
+```text
+import github.com/jantytgat/go-transcrypt
+```
+
+### Encryption key
+
+The encryption key is a string provide to encrypt the data with.
+A function ```CreateHexKey(bitSize int)``` is available to create a random key based on an RSA Private Key, and returns
+it as a hex-encoded string.
+
+```go
+var err error
+var key string
+if key, err = transcrypt.CreateHexKey(2048); err != nil {
+panic(err)
+}
+```
+
+### Salt
+
+A salt is also required for proper encryption.
+It is possible to either generate a new salt for every call, by leaving the salt to ```nil``` when calling the ``
+Encrypt``` function.
+If you want to use a specific salt, you can either provide it manually (at least 12 bytes) or generate one.
+
+```go
+var salt []byte
+if salt, err = transcrypt.CreateSalt(); err != nil {
+panic(err)
+}
+```
+
+## Operations
+
+Currently, the following data types are supported for encryption:
+
+- string
+- int
+
+### Encrypt
+
+```go
+var inputString = "hello world"
+var encryptedString string
+if encryptedString, err = transcrypt.Encrypt(key, salt, transcrypt.AES_256_GCM, inputString); err != nil {
+panic(err)
+}
+```
+
+### Decrypt
+
+```go
+var decryptedString any
+if decryptedString, err = transcrypt.Decrypt(key, encryptedString); err != nil {
+panic(err)
+}
+```
+
+## Example
+
+An example is available in the [examples](https://github.com/jantytgat/go-transcrypt/tree/main/examples/simple)
+directory.

examples/simple/main.go

@@ -3,13 +3,13 @@ package main
 import (
 	"fmt"
 
-	"github.com/jantytgat/go-transcrypt/pkg/transcrypt"
+	"git.flexabyte.io/flexabyte/go-transcrypt/pkg/transcrypt"
 )
 
 func main() {
 	var err error
 	var key string
-	if key, err = transcrypt.CreateHexKey(12); err != nil {
+	if key, err = transcrypt.CreateHexKey(2048); err != nil {
 		panic(err)
 	}
 

go.mod

@@ -1,10 +1,10 @@
-module github.com/jantytgat/go-transcrypt
+module git.flexabyte.io/flexabyte/go-transcrypt
 
-go 1.23
+go 1.24
 
 require (
 	github.com/minio/sio v0.4.1
-	golang.org/x/crypto v0.32.0
+	golang.org/x/crypto v0.38.0
 )
 
-require golang.org/x/sys v0.29.0 // indirect
+require golang.org/x/sys v0.33.0 // indirect

go.sum

@@ -1,8 +1,12 @@
+github.com/jantytgat/go-transcrypt v0.1.4 h1:81CofWmSkpinHWglYRHhCwyK4T15ZmjXzJpMwjJXWCI=
+github.com/jantytgat/go-transcrypt v0.1.4/go.mod h1:pe9VBn+ksuuWFvft+wSuF3FWEW+b/R7VjjuQxVhMm1c=
 github.com/minio/sio v0.4.1 h1:EMe3YBC1nf+sRQia65Rutxi+Z554XPV0dt8BIBA+a/0=
 github.com/minio/sio v0.4.1/go.mod h1:oBSjJeGbBdRMZZwna07sX9EFzZy+ywu5aofRiV1g79I=
-golang.org/x/crypto v0.32.0 h1:euUpcYgM8WcP71gNpTqQCn6rC2t6ULUPiOzfWaXVVfc=
-golang.org/x/crypto v0.32.0/go.mod h1:ZnnJkOaASj8g0AjIduWNlq2NRxL0PlBrbKVyZ6V/Ugc=
-golang.org/x/sys v0.29.0 h1:TPYlXGxvx1MGTn2GiZDhnjPA9wZzZeGKHHmKhHYvgaU=
-golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/term v0.28.0 h1:/Ts8HFuMR2E6IP/jlo7QVLZHggjKQbhu/7H0LJFr3Gg=
-golang.org/x/term v0.28.0/go.mod h1:Sw/lC2IAUZ92udQNf3WodGtn4k/XoLyZoh8v/8uiwek=
+golang.org/x/crypto v0.37.0 h1:kJNSjF/Xp7kU0iB2Z+9viTPMW4EqqsrywMXLJOOsXSE=
+golang.org/x/crypto v0.37.0/go.mod h1:vg+k43peMZ0pUMhYmVAWysMK35e6ioLh3wB8ZCAfbVc=
+golang.org/x/crypto v0.38.0 h1:jt+WWG8IZlBnVbomuhg2Mdq0+BBQaHbtqHEFEigjUV8=
+golang.org/x/crypto v0.38.0/go.mod h1:MvrbAqul58NNYPKnOra203SB9vpuZW0e+RRZV+Ggqjw=
+golang.org/x/sys v0.32.0 h1:s77OFDvIQeibCmezSnk/q6iAfkdiQaJi4VzroCFrN20=
+golang.org/x/sys v0.32.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
+golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=

pkg/transcrypt/crypto.go

@@ -19,8 +19,8 @@ import (
 // CreateHexKey generates a random key which can be used for encryption.
 // It generates a RSA Private Key with the supplied bitSize, and converts it to a hex-encoded PEM Block.
 func CreateHexKey(bitSize int) (string, error) {
-	if bitSize < 12 {
-		return "", errors.New("bit size must be at least 12")
+	if bitSize < 1024 {
+		return "", errors.New("bit size must be at least 1024")
 	}
 	var err error
 	var privKey *rsa.PrivateKey

pkg/transcrypt/crypto_test.go

@@ -25,14 +25,14 @@ func Test_CreateHexKey(t *testing.T) {
 			wantErr: true,
 		},
 		{
-			name:    "valid_size_12",
+			name:    "invalid_size_12",
 			bitSize: 12,
-			wantErr: false,
+			wantErr: true,
 		},
 		{
-			name:    "valid_size_256",
+			name:    "invalid_size_256",
 			bitSize: 256,
-			wantErr: false,
+			wantErr: true,
 		},
 		{
 			name:    "valid_size_1024",