From 18476c6cba2d5d2bb3ecf3ad136dacbf41d0360e Mon Sep 17 00:00:00 2001 From: Martin Kagamino Lehoux Date: Tue, 24 Oct 2023 07:20:10 +0200 Subject: feat: Extract from other repo --- README.md | 0 auth/config.go | 34 ++++++++++++++++++++++ auth/cookie.go | 21 ++++++++++++++ auth/crypto.go | 54 +++++++++++++++++++++++++++++++++++ auth/middlewares.go | 82 +++++++++++++++++++++++++++++++++++++++++++++++++++++ core/core.go | 34 ++++++++++++++++++++++ core/error.go | 16 +++++++++++ core/file.go | 38 +++++++++++++++++++++++++ core/http.go | 28 ++++++++++++++++++ core/image.go | 38 +++++++++++++++++++++++++ core/middleware.go | 31 ++++++++++++++++++++ core/template.go | 33 +++++++++++++++++++++ go.mod | 20 +++++++++++++ go.sum | 26 +++++++++++++++++ 14 files changed, 455 insertions(+) create mode 100644 README.md create mode 100644 auth/config.go create mode 100644 auth/cookie.go create mode 100644 auth/crypto.go create mode 100644 auth/middlewares.go create mode 100644 core/core.go create mode 100644 core/error.go create mode 100644 core/file.go create mode 100644 core/http.go create mode 100644 core/image.go create mode 100644 core/middleware.go create mode 100644 core/template.go create mode 100644 go.mod create mode 100644 go.sum diff --git a/README.md b/README.md new file mode 100644 index 0000000..e69de29 diff --git a/auth/config.go b/auth/config.go new file mode 100644 index 0000000..6a55839 --- /dev/null +++ b/auth/config.go @@ -0,0 +1,34 @@ +package auth + +import ( + "encoding/hex" + "errors" + "os" + + "github.com/martinlehoux/kagamigo/core" + "golang.org/x/exp/slog" +) + +var ( + ErrCookieBadLength = errors.New("cookie secret must be 32 bytes") +) + +type AuthConfig struct { + Domain string + CookieSecret []byte +} + +func LoadCookieSecret(cookieSecretString string) []byte { + cookiesSecret, err := hex.DecodeString(cookieSecretString) + if err != nil { + err = core.Wrap(err, "error decoding cookie secret") + slog.Error(err.Error()) + os.Exit(1) + } + if len(cookiesSecret) != 32 { + slog.Error(ErrCookieBadLength.Error()) + os.Exit(1) + } + slog.Info("cookie secret loaded") + return cookiesSecret +} diff --git a/auth/cookie.go b/auth/cookie.go new file mode 100644 index 0000000..61349fa --- /dev/null +++ b/auth/cookie.go @@ -0,0 +1,21 @@ +package auth + +import ( + "fmt" + "net/http" + "time" + + "github.com/martinlehoux/kagamigo/core" +) + +func CraftCookie(id core.ID, config AuthConfig) http.Cookie { + expiresAt := time.Now().Add(24 * time.Hour) + cookieValue := encrypt(config.CookieSecret, fmt.Sprintf("%s:%d", id.String(), expiresAt.Unix())) + return http.Cookie{ + Domain: config.Domain, + Name: "authentication", + Value: cookieValue, + Expires: expiresAt, + Path: "/", + } +} diff --git a/auth/crypto.go b/auth/crypto.go new file mode 100644 index 0000000..254539f --- /dev/null +++ b/auth/crypto.go @@ -0,0 +1,54 @@ +package auth + +import ( + "crypto/aes" + "crypto/cipher" + "crypto/rand" + "encoding/base64" + "errors" + + "github.com/martinlehoux/kagamigo/core" +) + +var ( + ErrEncryptedTooShort = errors.New("encrypted text is too short") +) + +func encrypt(secret []byte, plainText string) string { + block, err := aes.NewCipher(secret) + core.Expect(err, "error creating AES cipher") + + aead, err := cipher.NewGCM(block) + core.Expect(err, "error creating AEAD") + + nonce := make([]byte, aead.NonceSize()) + _, err = rand.Read(nonce) + core.Expect(err, "error generating nonce") + + return base64.URLEncoding.EncodeToString(aead.Seal(nonce, nonce, []byte(plainText), nil)) +} + +func decrypt(secret []byte, encryptedText string) (string, error) { + encryptedBytes, err := base64.URLEncoding.DecodeString(encryptedText) + if err != nil { + err = core.Wrap(err, "error decoding base64") + return "", err + } + block, err := aes.NewCipher(secret) + core.Expect(err, "error creating AES cipher") + + aead, err := cipher.NewGCM(block) + core.Expect(err, "error creating AEAD") + + nonceSize := aead.NonceSize() + if len(encryptedBytes) < nonceSize { + return "", ErrEncryptedTooShort + } + nonce, cipherText := encryptedBytes[:nonceSize], encryptedBytes[nonceSize:] + plainBytes, err := aead.Open(nil, nonce, cipherText, nil) + if err != nil { + err = core.Wrap(err, "error decrypting") + return "", err + } + return string(plainBytes), nil +} diff --git a/auth/middlewares.go b/auth/middlewares.go new file mode 100644 index 0000000..433cbd2 --- /dev/null +++ b/auth/middlewares.go @@ -0,0 +1,82 @@ +package auth + +import ( + "context" + "errors" + "net/http" + "strconv" + "strings" + "time" + + "github.com/martinlehoux/kagamigo/core" + "golang.org/x/exp/slog" +) + +var ( + ErrUserNotLoggedIn = errors.New("user not logged in") + ErrCookieExpired = errors.New("cookie expired") + ErrBadCookie = errors.New("invalid cookie") +) + +type userContext struct{} + +func Unauthorized(w http.ResponseWriter, err error) { + w.WriteHeader(http.StatusUnauthorized) + if err != nil { + _, err = w.Write([]byte(err.Error())) + core.Expect(err, "error writing response") + } +} + +func CookieAuthMiddleware(loadUser func(context.Context, ...any) (any, error), config AuthConfig) func(http.Handler) http.Handler { + return func(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + ctx := r.Context() + cookie, err := r.Cookie("authentication") + if errors.Is(err, http.ErrNoCookie) { + next.ServeHTTP(w, r) + return + } + core.Expect(err, "error reading cookie") + + authentication, err := decrypt(config.CookieSecret, cookie.Value) + if err != nil { + err = core.Wrap(err, "error decrypting cookie") + slog.Warn(err.Error()) + http.Error(w, err.Error(), http.StatusBadRequest) + return + } + parts := strings.Split(authentication, ":") + if len(parts) != 2 { + slog.Warn(ErrBadCookie.Error()) + http.Error(w, ErrBadCookie.Error(), http.StatusBadRequest) + return + } + userId, err := core.ParseID(parts[0]) + if err != nil { + err = core.Wrap(err, "error parsing user id") + slog.Warn(err.Error()) + http.Error(w, err.Error(), http.StatusBadRequest) + return + } + expiresAtSeconds, err := strconv.Atoi(parts[1]) + if err != nil { + err = core.Wrap(err, "error parsing expires at") + slog.Warn(err.Error()) + http.Error(w, err.Error(), http.StatusBadRequest) + return + } + expiresAt := time.Unix(int64(expiresAtSeconds), 0) + if time.Now().After(expiresAt) { + slog.Warn(ErrCookieExpired.Error()) + http.Error(w, ErrCookieExpired.Error(), http.StatusUnauthorized) + return + } + user, err := loadUser(ctx, userId) + core.Expect(err, "error loading user") + + ctx = context.WithValue(ctx, userContext{}, user) + next.ServeHTTP(w, r.WithContext(ctx)) + }) + } +} diff --git a/core/core.go b/core/core.go new file mode 100644 index 0000000..5cd654d --- /dev/null +++ b/core/core.go @@ -0,0 +1,34 @@ +package core + +import ( + "encoding/base64" + + "github.com/gofrs/uuid" +) + +type ID struct { + uuid.UUID +} + +func NewID() ID { + id, err := uuid.NewV4() + Expect(err, "error generating uuid") + + return ID{id} +} + +func (id ID) String() string { + return base64.RawURLEncoding.EncodeToString(id.Bytes()) +} + +func ParseID(value string) (ID, error) { + bytes, err := base64.RawURLEncoding.DecodeString(value) + if err != nil { + return ID{}, Wrap(err, "error decoding value") + } + id, err := uuid.FromBytes(bytes) + if err != nil { + return ID{}, Wrap(err, "error parsing uuid") + } + return ID{id}, nil +} diff --git a/core/error.go b/core/error.go new file mode 100644 index 0000000..7b1871a --- /dev/null +++ b/core/error.go @@ -0,0 +1,16 @@ +package core + +import "fmt" + +func Wrap(err error, msg string) error { + return fmt.Errorf("%s: %w", msg, err) +} + +func Expect(err error, msg string) { + if err != nil { + if msg != "" { + err = Wrap(err, msg) + } + panic(err) + } +} diff --git a/core/file.go b/core/file.go new file mode 100644 index 0000000..083d8f7 --- /dev/null +++ b/core/file.go @@ -0,0 +1,38 @@ +package core + +import ( + "fmt" + "io" + "mime/multipart" + "os" +) + +type File (string) + +func NewFile(ext string) File { + return File(NewID().String() + ext) +} + +func (file File) Path() string { + return fmt.Sprintf("media/files/%s", file) +} + +func (file *File) Save(raw multipart.File) error { + dest, err := os.Create(file.Path()) + if err != nil { + return Wrap(err, "error creating file destination") + } + _, err = io.Copy(dest, raw) + if err != nil { + return Wrap(err, "error copying to file destination") + } + return nil +} + +func (file *File) Delete() error { + err := os.Remove(file.Path()) + if err != nil { + return Wrap(err, "error deleting file") + } + return nil +} diff --git a/core/http.go b/core/http.go new file mode 100644 index 0000000..778c5c9 --- /dev/null +++ b/core/http.go @@ -0,0 +1,28 @@ +package core + +import ( + "bytes" + "context" + "html/template" + "net/http" + + "github.com/a-h/templ" +) + +func ExecuteTemplate(w http.ResponseWriter, tpl template.Template, name string, data interface{}) { + var buf bytes.Buffer + err := tpl.ExecuteTemplate(&buf, name, data) + Expect(err, "error executing template") + w.Header().Set("Content-Type", "text/html; charset=UTF-8") + _, err = buf.WriteTo(w) + Expect(err, "error writing template to response writer") +} + +func RenderPage(ctx context.Context, page templ.Component, w http.ResponseWriter) { + var buf bytes.Buffer + err := page.Render(ctx, &buf) + Expect(err, "error rendering page") + w.Header().Set("Content-Type", "text/html; charset=UTF-8") + _, err = buf.WriteTo(w) + Expect(err, "error writing page to response writer") +} diff --git a/core/image.go b/core/image.go new file mode 100644 index 0000000..c06cbd8 --- /dev/null +++ b/core/image.go @@ -0,0 +1,38 @@ +package core + +import ( + "fmt" + "io" + "mime/multipart" + "os" +) + +type Image (ID) + +func NewImage() Image { + return Image(NewID()) +} + +func (image Image) Path() string { + return fmt.Sprintf("media/images/%s", image) +} + +func (image *Image) Save(raw multipart.File) error { + dest, err := os.Create(image.Path()) + if err != nil { + return Wrap(err, "error creating image destination") + } + _, err = io.Copy(dest, raw) + if err != nil { + return Wrap(err, "error copying to image destination") + } + return nil +} + +func (image *Image) Delete() error { + err := os.Remove(image.Path()) + if err != nil { + return Wrap(err, "error deleting image") + } + return nil +} diff --git a/core/middleware.go b/core/middleware.go new file mode 100644 index 0000000..55e67fb --- /dev/null +++ b/core/middleware.go @@ -0,0 +1,31 @@ +package core + +import ( + "errors" + "net/http" + + "golang.org/x/exp/slog" +) + +func RecoverMiddleware(next http.Handler) http.Handler { + fn := func(w http.ResponseWriter, r *http.Request) { + defer func() { + if rcv := recover(); rcv != nil { + switch err := rcv.(type) { + case error: + if errors.Is(err, http.ErrAbortHandler) { + panic(rcv) + } + slog.Error(err.Error()) + http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError) + default: + panic(err) + } + } + }() + + next.ServeHTTP(w, r) + } + + return http.HandlerFunc(fn) +} diff --git a/core/template.go b/core/template.go new file mode 100644 index 0000000..3a6833a --- /dev/null +++ b/core/template.go @@ -0,0 +1,33 @@ +package core + +import ( + "github.com/kataras/i18n" +) + +type Tr = func(format string, args ...any) string + +type WithLanguage interface { + Language() string +} + +func GetTr(wl WithLanguage) Tr { + lang := "en-GB" + if wl != nil { + lang = wl.Language() + } + return func(format string, args ...any) string { return i18n.Tr(lang, format, args...) } +} + +type LoginContext[U any] struct { + IsLoggedIn bool + User U + Tr Tr +} + +func GetLoginContext[U WithLanguage](user U, ok bool) LoginContext[U] { + return LoginContext[U]{ + IsLoggedIn: ok, + User: user, + Tr: GetTr(user), + } +} diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..03c9fcd --- /dev/null +++ b/go.mod @@ -0,0 +1,20 @@ +module github.com/martinlehoux/kagamigo + +go 1.20 + +require ( + github.com/a-h/templ v0.2.408 + github.com/gofrs/uuid v4.4.0+incompatible + github.com/kataras/i18n v0.0.8 + golang.org/x/exp v0.0.0-20231006140011-7918f672742d +) + +require ( + github.com/BurntSushi/toml v1.2.1 // indirect + github.com/davecgh/go-spew v1.1.1 // indirect + github.com/pmezard/go-difflib v1.0.0 // indirect + golang.org/x/net v0.9.0 // indirect + golang.org/x/text v0.9.0 // indirect + gopkg.in/ini.v1 v1.67.0 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..c3c925b --- /dev/null +++ b/go.sum @@ -0,0 +1,26 @@ +github.com/BurntSushi/toml v1.2.1 h1:9F2/+DoOYIOksmaJFPw1tGFy1eDnIJXg+UHjuD8lTak= +github.com/BurntSushi/toml v1.2.1/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ= +github.com/a-h/templ v0.2.408 h1:WmXdjVjxjMJyjRg+34cgg+hRC0duDg9OJy6euZbS4ek= +github.com/a-h/templ v0.2.408/go.mod h1:6Lfhsl3Z4/vXl7jjEjkJRCqoWDGjDnuKgzjYMDSddas= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/gofrs/uuid v4.4.0+incompatible h1:3qXRTX8/NbyulANqlc0lchS1gqAVxRgsuW1YrTJupqA= +github.com/gofrs/uuid v4.4.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM= +github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38= +github.com/kataras/i18n v0.0.8 h1:thiDRqq4fN2sQOK5CwR5Yh1yT7swP6B3wnadILhqjhk= +github.com/kataras/i18n v0.0.8/go.mod h1:M/yRAqQ3Y7z2oSpotxG/+nPrgsJLas6t0kEJfIJk98E= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/stretchr/testify v1.8.2 h1:+h33VjcLVPDHtOdpUCuF+7gSuG3yGIftsP1YvFihtJ8= +golang.org/x/exp v0.0.0-20231006140011-7918f672742d h1:jtJma62tbqLibJ5sFQz8bKtEM8rJBtfilJ2qTU199MI= +golang.org/x/exp v0.0.0-20231006140011-7918f672742d/go.mod h1:ldy0pHrwJyGW56pPQzzkH36rKxoZW1tw7ZJpeKx+hdo= +golang.org/x/net v0.9.0 h1:aWJ/m6xSmxWBx+V0XRHTlrYrPG56jKsLdTFmsSsCzOM= +golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns= +golang.org/x/text v0.9.0 h1:2sjJmO8cDvYveuX97RDLsxlyUxLl+GHoLxBiRdHllBE= +golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA= +gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -- cgit v1.3