forked from mtusi2026/mtusi2026lab4
183 lines
4.7 KiB
Go
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
|
|
}
|