Files
mtusi2026lab4/internal/api/auth.go
T

183 lines
4.7 KiB
Go

package api
import (
"crypto/rand"
"encoding/base64"
"encoding/hex"
"errors"
"io"
"net/http"
"strings"
"time"
"unicode/utf8"
"messenger/internal/password"
"messenger/internal/session"
"messenger/internal/store"
)
const (
basicChallenge = `Basic realm="messenger", charset="UTF-8"`
bearerChallenge = `Bearer realm="messenger"`
)
func (a *API) createSession(w http.ResponseWriter, r *http.Request) {
if !emptyBody(r) {
a.fail(w, r, http.StatusBadRequest, "invalid_request", "У входа не должно быть тела", 0)
return
}
username, plain, ok := parseBasic(r)
if !ok || !usernameRe.MatchString(username) || !validPassword(plain) {
a.unauthorized(w, r, basicChallenge)
return
}
user, hash, err := a.store.UserByUsername(r.Context(), username)
if errors.Is(err, store.ErrNotFound) {
password.Verify(plain, a.dummyHash)
a.unauthorized(w, r, basicChallenge)
return
}
if a.writeStoreErr(w, r, err) {
return
}
if !password.Verify(plain, hash) {
a.unauthorized(w, r, basicChallenge)
return
}
token, err := newToken()
if err != nil {
a.fail(w, r, http.StatusInternalServerError, "internal_error", "Внутренняя ошибка", 0)
return
}
expires := time.Now().UTC().Add(a.sessionTTL).Truncate(time.Microsecond)
if err := a.sessions.Create(r.Context(), token, user.ID, expires); a.writeStoreErr(w, r, err) {
return
}
writeJSON(w, http.StatusCreated, map[string]any{
"token": token,
"token_type": "Bearer",
"expires_at": formatTime(expires),
"user": asUser(user),
})
}
func (a *API) revokeSession(w http.ResponseWriter, r *http.Request) {
token, ok := a.bearerToken(w, r)
if !ok {
return
}
if _, _, err := a.sessions.Lookup(r.Context(), token); err != nil {
if errors.Is(err, session.ErrNotFound) {
a.unauthorized(w, r, bearerChallenge)
return
}
a.writeStoreErr(w, r, err)
return
}
if err := a.sessions.Revoke(r.Context(), token); err != nil {
if errors.Is(err, session.ErrNotFound) {
a.unauthorized(w, r, bearerChallenge)
return
}
a.writeStoreErr(w, r, err)
return
}
w.WriteHeader(http.StatusNoContent)
}
func (a *API) authenticate(w http.ResponseWriter, r *http.Request) (store.User, bool) {
token, ok := a.bearerToken(w, r)
if !ok {
return store.User{}, false
}
userID, expires, err := a.sessions.Lookup(r.Context(), token)
if errors.Is(err, session.ErrNotFound) || (err == nil && !time.Now().Before(expires)) {
if err == nil {
_ = a.sessions.Revoke(r.Context(), token)
}
a.unauthorized(w, r, bearerChallenge)
return store.User{}, false
}
if err != nil {
a.writeStoreErr(w, r, err)
return store.User{}, false
}
user, err := a.store.User(r.Context(), userID)
if errors.Is(err, store.ErrNotFound) {
a.unauthorized(w, r, bearerChallenge)
return store.User{}, false
}
if a.writeStoreErr(w, r, err) {
return store.User{}, false
}
return user, true
}
func (a *API) bearerToken(w http.ResponseWriter, r *http.Request) (string, bool) {
scheme, param, ok := splitAuth(r.Header.Get("Authorization"))
if !ok || !strings.EqualFold(scheme, "Bearer") || param == "" || len(param) > 512 || strings.Contains(param, " ") {
a.unauthorized(w, r, bearerChallenge)
return "", false
}
return param, true
}
func (a *API) unauthorized(w http.ResponseWriter, r *http.Request, challenge string) {
w.Header().Set("WWW-Authenticate", challenge)
a.fail(w, r, http.StatusUnauthorized, "unauthorized", "Нет действительной идентификации", 0)
}
func parseBasic(r *http.Request) (string, string, bool) {
scheme, param, ok := splitAuth(r.Header.Get("Authorization"))
if !ok || !strings.EqualFold(scheme, "Basic") || param == "" {
return "", "", false
}
raw, err := base64.StdEncoding.DecodeString(param)
if err != nil {
raw, err = base64.RawStdEncoding.DecodeString(param)
if err != nil {
return "", "", false
}
}
if !utf8.Valid(raw) {
return "", "", false
}
username, plain, ok := strings.Cut(string(raw), ":")
if !ok || username == "" {
return "", "", false
}
return username, plain, true
}
func splitAuth(header string) (string, string, bool) {
scheme, param, ok := strings.Cut(strings.TrimSpace(header), " ")
if !ok {
return "", "", false
}
param = strings.TrimSpace(param)
if scheme == "" || param == "" {
return "", "", false
}
return scheme, param, true
}
func emptyBody(r *http.Request) bool {
if r.Body == nil || r.ContentLength == 0 {
return true
}
buf := make([]byte, 1)
n, err := r.Body.Read(buf)
if n > 0 {
return false
}
return err == io.EOF || err == nil
}
func newToken() (string, error) {
var b [32]byte
if _, err := rand.Read(b[:]); err != nil {
return "", err
}
return hex.EncodeToString(b[:]), nil
}