initial import

pkg/auxtool/aux509/x509cert.go

@@ -0,0 +1,171 @@
+package aux509
+
+import (
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/x509"
+	"crypto/x509/pkix"
+	"encoding/pem"
+	"fmt"
+	"math/big"
+	"time"
+)
+
+func CreateX509SelfSignedCert(commonName string) ([]byte, []byte, error) {
+	var err error
+	certPem := make([]byte, 0)
+	keyPem := make([]byte, 0)
+
+	now := time.Now()
+
+	const yearsAfter int = 10
+	const keySize int = 2048
+
+	key, err := rsa.GenerateKey(rand.Reader, keySize)
+	if err != nil {
+		err := fmt.Errorf("Can't create a private key: %v", err)
+		return certPem, keyPem, err
+
+	}
+	keyPemBlock := pem.Block{
+		Type:  "RSA PRIVATE KEY",
+		Bytes: x509.MarshalPKCS1PrivateKey(key),
+	}
+	keyPem = pem.EncodeToMemory(&keyPemBlock)
+
+	tml := x509.Certificate{
+		SerialNumber: big.NewInt(now.Unix()),
+		NotBefore:    now,
+		NotAfter:     now.AddDate(yearsAfter, 0, 0),
+		Subject: pkix.Name{
+			CommonName: commonName,
+		},
+		DNSNames:              []string{commonName},
+		BasicConstraintsValid: true,
+	}
+	certBytes, err := x509.CreateCertificate(rand.Reader, &tml, &tml, &key.PublicKey, key)
+	if err != nil {
+		return certPem, keyPem, fmt.Errorf("Can't create a certificate: %v", err)
+
+	}
+	certPemBlock := pem.Block{
+		Type:  "CERTIFICATE",
+		Bytes: certBytes,
+	}
+	certPem = pem.EncodeToMemory(&certPemBlock)
+	if err != nil {
+		return certPem, keyPem, err
+	}
+	return certPem, keyPem, err
+}
+
+func CreateX509CACert(commonName string) ([]byte, []byte, error) {
+	var err error
+	certPem := make([]byte, 0)
+	keyPem := make([]byte, 0)
+
+	now := time.Now()
+
+	const yearsAfter int = 10
+	const keySize int = 2048
+
+	key, err := rsa.GenerateKey(rand.Reader, keySize)
+	if err != nil {
+		err := fmt.Errorf("Can't create a private key: %v", err)
+		return certPem, keyPem, err
+
+	}
+	keyPemBlock := pem.Block{
+		Type:  "RSA PRIVATE KEY",
+		Bytes: x509.MarshalPKCS1PrivateKey(key),
+	}
+	keyPem = pem.EncodeToMemory(&keyPemBlock)
+
+	tml := x509.Certificate{
+		SerialNumber: big.NewInt(now.Unix()),
+		NotBefore:    now,
+		NotAfter:     now.AddDate(yearsAfter, 0, 0),
+		Subject: pkix.Name{
+			CommonName: commonName,
+		},
+		IsCA:                  true,
+		ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth, x509.ExtKeyUsageServerAuth},
+		KeyUsage:              x509.KeyUsageDigitalSignature | x509.KeyUsageCertSign,
+		BasicConstraintsValid: true,
+	}
+	certBytes, err := x509.CreateCertificate(rand.Reader, &tml, &tml, &key.PublicKey, key)
+	if err != nil {
+		return certPem, keyPem, fmt.Errorf("Can't create a certificate: %v", err)
+
+	}
+	certPemBlock := pem.Block{
+		Type:  "CERTIFICATE",
+		Bytes: certBytes,
+	}
+	certPem = pem.EncodeToMemory(&certPemBlock)
+
+	if err != nil {
+		return certPem, keyPem, err
+	}
+	return certPem, keyPem, err
+}
+
+func CreateX509Cert(commonName string, caKeyPem []byte, dnsNames ...string) ([]byte, []byte, error) {
+	var err error
+	certPem := make([]byte, 0)
+	keyPem := make([]byte, 0)
+	now := time.Now()
+
+	const yearsAfter int = 10
+	const keySize int = 2048
+
+	key, err := rsa.GenerateKey(rand.Reader, keySize)
+	if err != nil {
+		err := fmt.Errorf("Can't create a private key: %v", err)
+		return certPem, keyPem, err
+	}
+	keyPemBlock := pem.Block{
+		Type:  "RSA PRIVATE KEY",
+		Bytes: x509.MarshalPKCS1PrivateKey(key),
+	}
+	keyPem = pem.EncodeToMemory(&keyPemBlock)
+
+	pemBlock, _ := pem.Decode(caKeyPem)
+	if pemBlock == nil {
+		err := fmt.Errorf("Can't parse a CA private key block")
+		return certPem, keyPem, err
+	}
+	caKey, err := x509.ParsePKCS1PrivateKey(pemBlock.Bytes)
+	if err != nil {
+		err := fmt.Errorf("Can't parse a CA private key")
+		return certPem, keyPem, err
+	}
+
+	tml := x509.Certificate{
+		SerialNumber: big.NewInt(now.Unix()),
+		NotBefore:    now,
+		NotAfter:     now.AddDate(yearsAfter, 0, 0),
+		Subject: pkix.Name{
+			CommonName: commonName,
+		},
+		DNSNames:              append([]string{commonName}, dnsNames...),
+		IsCA:                  false,
+		ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth, x509.ExtKeyUsageServerAuth},
+		KeyUsage:              x509.KeyUsageDigitalSignature,
+		BasicConstraintsValid: true,
+	}
+	certBytes, err := x509.CreateCertificate(rand.Reader, &tml, &tml, &key.PublicKey, caKey)
+	if err != nil {
+		return certPem, keyPem, fmt.Errorf("Can't create a certificate: %v", err)
+
+	}
+	certPemBlock := pem.Block{
+		Type:  "CERTIFICATE",
+		Bytes: certBytes,
+	}
+	certPem = pem.EncodeToMemory(&certPemBlock)
+	if err != nil {
+		return certPem, keyPem, err
+	}
+	return certPem, keyPem, err
+}

pkg/auxtool/aux509/x509cert_test.go

@@ -0,0 +1,29 @@
+package aux509
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestCert(t *testing.T) {
+
+	{
+		//caCert, caKey, err := CreateX509SelfSignedCert("test1")
+		//require.NoError(t, err)
+		//fmt.Println(string(caCert))
+		//fmt.Println(string(caKey))
+	}
+	{
+		caCert, caKey, err := CreateX509CACert("test1")
+		require.NoError(t, err)
+		fmt.Println(string(caCert))
+		fmt.Println(string(caKey))
+
+		caCert, caKey, err = CreateX509Cert("test1", caKey)
+		require.NoError(t, err)
+		fmt.Println(string(caCert))
+		fmt.Println(string(caKey))
+	}
+}

pkg/auxtool/auxgin/corsmw.go

@@ -0,0 +1,31 @@
+package auxgin
+
+import (
+	"net/http"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+)
+
+func CorsMiddleware() gin.HandlerFunc {
+
+	headers := []string{"Content-Type", "Content-Length", "Accept-Encoding", "X-CSRF-Token", "Authorization"}
+	headerList := strings.Join(headers, ",")
+
+	methods := []string{"POST", "GET", "OPTIONS", "PUT", "DELETE", "UPDATE"}
+	methodList := strings.Join(methods, ",")
+
+	return func(gctx *gin.Context) {
+		gctx.Writer.Header().Set("Access-Control-Allow-Origin", "*")
+		gctx.Writer.Header().Set("Access-Control-Max-Age", "86400")
+		gctx.Writer.Header().Set("Access-Control-Allow-Methods", methodList)
+		gctx.Writer.Header().Set("Access-Control-Allow-Headers", headerList)
+		gctx.Writer.Header().Set("Access-Control-Allow-Credentials", "true")
+
+		if gctx.Request.Method == "OPTIONS" {
+			gctx.AbortWithStatus(http.StatusOK)
+		} else {
+			gctx.Next()
+		}
+	}
+}

pkg/auxtool/auxgin/logmw.go

@@ -0,0 +1,59 @@
+package auxgin
+
+import (
+	"bytes"
+	"fmt"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+)
+
+func LogMiddleware() gin.HandlerFunc {
+	return func(ctx *gin.Context) {
+
+		start := time.Now()
+
+		ctx.Next()
+
+		var reqSize int64
+		var method string
+		var reqURI string
+		if ctx.Request != nil {
+			reqSize = ctx.Request.ContentLength
+			method = ctx.Request.Method
+			reqURI = ctx.Request.RequestURI
+		}
+
+		duration := time.Since(start).Microseconds()
+		remAddr := ctx.RemoteIP()
+
+		var resCode int
+		var resSize int
+		if ctx.Writer != nil {
+			resCode = ctx.Writer.Status()
+			resSize = ctx.Writer.Size()
+		}
+
+		logString := fmt.Sprintf("%s %s %s in=%d out=%d res=%d %dms",
+			remAddr, method, reqURI, reqSize, resSize, resCode, duration)
+
+		logger := logrus.WithField("object", "accesslog")
+		logger.Infoln(logString)
+	}
+}
+
+type LogWriter struct {
+	gin.ResponseWriter
+	body *bytes.Buffer
+}
+
+func (lw LogWriter) Write(data []byte) (int, error) {
+	lw.body.Write(data)
+	return lw.ResponseWriter.Write(data)
+}
+
+func (lw LogWriter) WriteString(data string) (int, error) {
+	lw.body.WriteString(data)
+	return lw.ResponseWriter.WriteString(data)
+}

pkg/logger/logger.go

@@ -0,0 +1,76 @@
+package logger
+
+import (
+	"fmt"
+	"os"
+	"time"
+
+	"github.com/sirupsen/logrus"
+)
+
+type LogFormatter struct {
+}
+
+func (lf *LogFormatter) Format(entry *logrus.Entry) ([]byte, error) {
+	var err error
+	timeStamp := time.Now().Format(time.RFC3339)
+	levelString := entry.Level.String()
+	labelString := ""
+	for key, value := range entry.Data {
+		labelString += fmt.Sprintf("<%s:%v>", key, value)
+	}
+	if labelString != "" {
+		message := fmt.Sprintf("%s %s %s [%s]\n", timeStamp, levelString, labelString, entry.Message)
+		return []byte(message), err
+	}
+	message := fmt.Sprintf("%s %s [%s]\n", timeStamp, levelString, entry.Message)
+	return []byte(message), err
+}
+
+func init() {
+	logrus.SetOutput(os.Stdout)
+	logrus.SetFormatter(&LogFormatter{})
+	logrus.SetLevel(logrus.DebugLevel)
+}
+
+type Logger struct {
+	logrus *logrus.Entry
+}
+
+func NewLogger(label string) *Logger {
+	return &Logger{
+		logrus: logrus.WithField("object", label),
+	}
+}
+
+func (log *Logger) Errorf(format string, args ...any) {
+	log.logrus.Errorf(format, args...)
+}
+
+func (log *Logger) Debugf(format string, args ...any) {
+	log.logrus.Debugf(format, args...)
+}
+
+func (log *Logger) Warningf(format string, args ...any) {
+	log.logrus.Warningf(format, args...)
+}
+
+func (log *Logger) Infof(format string, args ...any) {
+	log.logrus.Infof(format, args...)
+}
+
+func (log *Logger) Error(args ...any) {
+	log.logrus.Error(args...)
+}
+
+func (log *Logger) Debug(args ...any) {
+	log.logrus.Debug(args...)
+}
+
+func (log *Logger) Warning(args ...any) {
+	log.logrus.Warning(args...)
+}
+
+func (log *Logger) Info(args ...any) {
+	log.logrus.Info(args...)
+}