forked from mtusi2026/mtusi2026lab4
112 lines
3.1 KiB
Go
112 lines
3.1 KiB
Go
package httpapi
|
|
|
|
import (
|
|
"errors"
|
|
"io"
|
|
"net/http"
|
|
"strings"
|
|
|
|
"gitea.privcloud.tech/dizi/mtusi2026lab4/internal/model"
|
|
)
|
|
|
|
func (s *Server) createSession(w http.ResponseWriter, r *http.Request) *apiError {
|
|
if r.Method != http.MethodPost {
|
|
return methodNotAllowed(w, http.MethodPost)
|
|
}
|
|
body, err := io.ReadAll(io.LimitReader(r.Body, 1))
|
|
if err != nil || len(body) != 0 {
|
|
return invalidRequest()
|
|
}
|
|
username, passwordValue, ok := singleBasicAuth(r)
|
|
if !ok {
|
|
return unauthorized()
|
|
}
|
|
credentials, err := s.userRepository.UserByUsername(r.Context(), username)
|
|
if errors.Is(err, model.ErrNotFound) {
|
|
if _, verifyErr := s.passwords.Verify(passwordValue, s.passwords.DummyHash()); verifyErr != nil {
|
|
return internalError()
|
|
}
|
|
return unauthorized()
|
|
}
|
|
if err != nil {
|
|
return unavailable()
|
|
}
|
|
verified, err := s.passwords.Verify(passwordValue, credentials.PasswordHash)
|
|
if err != nil {
|
|
return internalError()
|
|
}
|
|
if !verified {
|
|
return unauthorized()
|
|
}
|
|
token, expiresAt, err := s.sessions.Create(r.Context(), credentials.ID, s.sessionTTL)
|
|
if err != nil {
|
|
return unavailable()
|
|
}
|
|
writeJSON(w, http.StatusCreated, struct {
|
|
Token string `json:"token"`
|
|
TokenType string `json:"token_type"`
|
|
ExpiresAt string `json:"expires_at"`
|
|
User User `json:"user"`
|
|
}{token, "Bearer", model.FormatTime(expiresAt), credentials.User})
|
|
return nil
|
|
}
|
|
|
|
func singleBasicAuth(r *http.Request) (string, string, bool) {
|
|
if len(r.Header.Values("Authorization")) != 1 {
|
|
return "", "", false
|
|
}
|
|
username, passwordValue, ok := r.BasicAuth()
|
|
return username, passwordValue, ok && username != ""
|
|
}
|
|
|
|
func (s *Server) revokeSession(w http.ResponseWriter, r *http.Request) *apiError {
|
|
if r.Method != http.MethodDelete {
|
|
return methodNotAllowed(w, http.MethodDelete)
|
|
}
|
|
_, token, authErr := s.authenticate(r)
|
|
if authErr != nil {
|
|
return authErr
|
|
}
|
|
if err := s.sessions.Delete(r.Context(), token); errors.Is(err, model.ErrSessionNotFound) {
|
|
return unauthorized()
|
|
} else if err != nil {
|
|
return unavailable()
|
|
}
|
|
w.WriteHeader(http.StatusNoContent)
|
|
return nil
|
|
}
|
|
|
|
func (s *Server) authenticate(r *http.Request) (User, string, *apiError) {
|
|
values := r.Header.Values("Authorization")
|
|
if len(values) != 1 {
|
|
return User{}, "", unauthorized()
|
|
}
|
|
scheme, token, found := strings.Cut(values[0], " ")
|
|
if !found || !strings.EqualFold(scheme, "Bearer") || token == "" || strings.ContainsAny(token, " \t\r\n") {
|
|
return User{}, "", unauthorized()
|
|
}
|
|
userID, err := s.sessions.UserID(r.Context(), token)
|
|
if errors.Is(err, model.ErrSessionNotFound) || errors.Is(err, model.ErrInvalidToken) {
|
|
return User{}, "", unauthorized()
|
|
}
|
|
if err != nil {
|
|
return User{}, "", unavailable()
|
|
}
|
|
user, err := s.userRepository.UserByID(r.Context(), userID)
|
|
if errors.Is(err, model.ErrNotFound) {
|
|
_ = s.sessions.Delete(r.Context(), token)
|
|
return User{}, "", unauthorized()
|
|
}
|
|
if err != nil {
|
|
return User{}, "", unavailable()
|
|
}
|
|
return user, token, nil
|
|
}
|
|
|
|
func authenticationChallenge(r *http.Request) string {
|
|
if r.URL.Path == "/api/v1/auth/sessions" {
|
|
return `Basic realm="messenger", charset="UTF-8"`
|
|
}
|
|
return `Bearer realm="messenger"`
|
|
}
|