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 }