webauthn.go 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384
  1. // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
  2. // SPDX-License-Identifier: Apache-2.0
  3. package ui // import "miniflux.app/v2/internal/ui"
  4. import (
  5. "encoding/hex"
  6. "errors"
  7. "fmt"
  8. "log/slog"
  9. "net/http"
  10. "net/url"
  11. "github.com/go-webauthn/webauthn/protocol"
  12. "github.com/go-webauthn/webauthn/webauthn"
  13. "miniflux.app/v2/internal/config"
  14. "miniflux.app/v2/internal/crypto"
  15. "miniflux.app/v2/internal/http/request"
  16. "miniflux.app/v2/internal/http/response"
  17. "miniflux.app/v2/internal/model"
  18. "miniflux.app/v2/internal/ui/form"
  19. "miniflux.app/v2/internal/ui/view"
  20. "miniflux.app/v2/internal/urllib"
  21. )
  22. type WebAuthnUser struct {
  23. User *model.User
  24. AuthnID []byte
  25. Credentials []model.WebAuthnCredential
  26. }
  27. func (u WebAuthnUser) WebAuthnID() []byte {
  28. return u.AuthnID
  29. }
  30. func (u WebAuthnUser) WebAuthnName() string {
  31. return u.User.Username
  32. }
  33. func (u WebAuthnUser) WebAuthnDisplayName() string {
  34. return u.User.Username
  35. }
  36. func (u WebAuthnUser) WebAuthnIcon() string {
  37. return ""
  38. }
  39. func (u WebAuthnUser) WebAuthnCredentials() []webauthn.Credential {
  40. creds := make([]webauthn.Credential, len(u.Credentials))
  41. for i, cred := range u.Credentials {
  42. creds[i] = cred.Credential
  43. }
  44. return creds
  45. }
  46. func newWebAuthn() (*webauthn.WebAuthn, error) {
  47. baseURL, err := url.Parse(config.Opts.BaseURL())
  48. if err != nil {
  49. return nil, err
  50. }
  51. return webauthn.New(&webauthn.Config{
  52. RPDisplayName: "Miniflux",
  53. RPID: baseURL.Hostname(),
  54. RPOrigins: []string{config.Opts.RootURL()},
  55. })
  56. }
  57. func (h *handler) beginRegistration(w http.ResponseWriter, r *http.Request) {
  58. web, err := newWebAuthn()
  59. if err != nil {
  60. response.JSONServerError(w, r, err)
  61. return
  62. }
  63. user, err := h.store.UserByID(request.UserID(r))
  64. if err != nil {
  65. response.JSONServerError(w, r, err)
  66. return
  67. }
  68. credentials, err := h.store.WebAuthnCredentialsByUserID(user.ID)
  69. if err != nil {
  70. response.JSONServerError(w, r, err)
  71. return
  72. }
  73. credentialDescriptors := make([]protocol.CredentialDescriptor, len(credentials))
  74. for i, credential := range credentials {
  75. credentialDescriptors[i] = credential.Credential.Descriptor()
  76. }
  77. options, sessionData, err := web.BeginRegistration(
  78. WebAuthnUser{
  79. User: user,
  80. AuthnID: crypto.GenerateRandomBytes(32),
  81. },
  82. webauthn.WithExclusions(credentialDescriptors),
  83. webauthn.WithResidentKeyRequirement(protocol.ResidentKeyRequirementRequired),
  84. )
  85. if err != nil {
  86. response.JSONServerError(w, r, err)
  87. return
  88. }
  89. request.WebSession(r).SetWebAuthn(sessionData)
  90. response.JSON(w, r, options)
  91. }
  92. func (h *handler) finishRegistration(w http.ResponseWriter, r *http.Request) {
  93. web, err := newWebAuthn()
  94. if err != nil {
  95. response.JSONServerError(w, r, err)
  96. return
  97. }
  98. userID := request.UserID(r)
  99. user, err := h.store.UserByID(userID)
  100. if err != nil {
  101. response.JSONServerError(w, r, err)
  102. return
  103. }
  104. sessionData := request.WebSession(r).ConsumeWebAuthnSession()
  105. if sessionData == nil {
  106. response.JSONBadRequest(w, r, errors.New("missing webauthn session data"))
  107. return
  108. }
  109. webAuthnUser := WebAuthnUser{User: user, AuthnID: sessionData.UserID}
  110. credential, err := web.FinishRegistration(webAuthnUser, *sessionData, r)
  111. if err != nil {
  112. response.JSONServerError(w, r, err)
  113. return
  114. }
  115. err = h.store.AddWebAuthnCredential(userID, sessionData.UserID, credential)
  116. if err != nil {
  117. response.JSONServerError(w, r, err)
  118. return
  119. }
  120. handleEncoded := model.WebAuthnCredential{Handle: sessionData.UserID}.HandleEncoded()
  121. redirect := h.routePath("/webauthn/%s/rename", handleEncoded)
  122. response.JSON(w, r, map[string]string{"redirect": redirect})
  123. }
  124. func (h *handler) beginLogin(w http.ResponseWriter, r *http.Request) {
  125. web, err := newWebAuthn()
  126. if err != nil {
  127. response.JSONServerError(w, r, err)
  128. return
  129. }
  130. assertion, sessionData, err := web.BeginDiscoverableLogin()
  131. if err != nil {
  132. response.JSONServerError(w, r, err)
  133. return
  134. }
  135. request.WebSession(r).SetWebAuthn(sessionData)
  136. response.JSON(w, r, assertion)
  137. }
  138. func (h *handler) finishLogin(w http.ResponseWriter, r *http.Request) {
  139. web, err := newWebAuthn()
  140. if err != nil {
  141. response.JSONServerError(w, r, err)
  142. return
  143. }
  144. parsedResponse, err := protocol.ParseCredentialRequestResponseBody(r.Body)
  145. if err != nil {
  146. response.JSONServerError(w, r, err)
  147. return
  148. }
  149. slog.Debug("WebAuthn: parsed response flags",
  150. slog.Bool("user_present", parsedResponse.Response.AuthenticatorData.Flags.HasUserPresent()),
  151. slog.Bool("user_verified", parsedResponse.Response.AuthenticatorData.Flags.HasUserVerified()),
  152. slog.Bool("has_attested_credential_data", parsedResponse.Response.AuthenticatorData.Flags.HasAttestedCredentialData()),
  153. slog.Bool("has_backup_eligible", parsedResponse.Response.AuthenticatorData.Flags.HasBackupEligible()),
  154. slog.Bool("has_backup_state", parsedResponse.Response.AuthenticatorData.Flags.HasBackupState()),
  155. )
  156. sessionData := request.WebSession(r).ConsumeWebAuthnSession()
  157. if sessionData == nil {
  158. response.JSONBadRequest(w, r, errors.New("missing webauthn session data"))
  159. return
  160. }
  161. var resolvedUser *model.User
  162. var resolvedCredential *model.WebAuthnCredential
  163. userByHandle := func(rawID, userHandle []byte) (webauthn.User, error) {
  164. userID, credential, err := h.store.WebAuthnCredentialByHandle(userHandle)
  165. if err != nil {
  166. return nil, err
  167. }
  168. if userID == 0 || credential == nil {
  169. return nil, fmt.Errorf("no user found for handle %x", userHandle)
  170. }
  171. loadedUser, err := h.store.UserByID(userID)
  172. if err != nil {
  173. return nil, err
  174. }
  175. if loadedUser == nil {
  176. return nil, fmt.Errorf("no user found for handle %x", userHandle)
  177. }
  178. // One-shot backfill for credentials registered before the
  179. // backup_eligible column was added: trust the assertion's BE
  180. // once, then persist it after successful validation.
  181. if !credential.BackupEligibleKnown {
  182. credential.Credential.Flags.BackupEligible = parsedResponse.Response.AuthenticatorData.Flags.HasBackupEligible()
  183. }
  184. resolvedUser = loadedUser
  185. resolvedCredential = credential
  186. return WebAuthnUser{
  187. User: loadedUser,
  188. AuthnID: userHandle,
  189. Credentials: []model.WebAuthnCredential{*credential},
  190. }, nil
  191. }
  192. validatedCredential, err := web.ValidateDiscoverableLogin(userByHandle, *sessionData, parsedResponse)
  193. if err != nil {
  194. slog.Warn("WebAuthn: ValidateDiscoverableLogin failed",
  195. slog.String("client_ip", request.ClientIP(r)),
  196. slog.String("user_agent", r.UserAgent()),
  197. slog.Any("error", err),
  198. )
  199. response.JSONUnauthorized(w, r)
  200. return
  201. }
  202. user := resolvedUser
  203. matchingCredential := resolvedCredential
  204. if err := h.store.WebAuthnSaveLogin(matchingCredential.Handle, validatedCredential); err != nil {
  205. slog.Warn("WebAuthn: unable to persist credential state after login",
  206. slog.Int64("user_id", user.ID),
  207. slog.Any("error", err),
  208. )
  209. }
  210. slog.Info("User authenticated successfully with webauthn",
  211. slog.Bool("authentication_successful", true),
  212. slog.String("client_ip", request.ClientIP(r)),
  213. slog.String("user_agent", r.UserAgent()),
  214. slog.Int64("user_id", user.ID),
  215. slog.String("username", user.Username),
  216. )
  217. if err := h.store.SetLastLogin(user.ID); err != nil {
  218. slog.Warn("Unable to update last login date",
  219. slog.Int64("user_id", user.ID),
  220. slog.Any("error", err),
  221. )
  222. }
  223. if err := authenticateWebSession(w, r, h.store, user); err != nil {
  224. response.JSONServerError(w, r, err)
  225. return
  226. }
  227. redirectURL := request.QueryStringParam(r, "redirect_url", "")
  228. if !urllib.IsRelativePath(redirectURL) {
  229. redirectURL = h.basePath + "/" + user.DefaultHomePage
  230. }
  231. response.JSON(w, r, map[string]string{"redirect": redirectURL})
  232. }
  233. func (h *handler) renameCredential(w http.ResponseWriter, r *http.Request) {
  234. view := view.New(h.tpl, r)
  235. user, err := h.store.UserByID(request.UserID(r))
  236. if err != nil {
  237. response.HTMLServerError(w, r, err)
  238. return
  239. }
  240. credentialHandleEncoded := request.RouteStringParam(r, "credentialHandle")
  241. credentialHandle, err := hex.DecodeString(credentialHandleEncoded)
  242. if err != nil {
  243. response.HTMLServerError(w, r, err)
  244. return
  245. }
  246. credUserID, credential, err := h.store.WebAuthnCredentialByHandle(credentialHandle)
  247. if err != nil {
  248. response.HTMLServerError(w, r, err)
  249. return
  250. }
  251. if credUserID != user.ID {
  252. response.HTMLForbidden(w, r)
  253. return
  254. }
  255. view.Set("form", form.WebauthnForm{Name: credential.Name})
  256. view.Set("cred", credential)
  257. view.Set("menu", "settings")
  258. view.Set("user", user)
  259. navMetadata, _ := h.store.GetNavMetadata(user.ID)
  260. view.Set("countUnread", navMetadata.CountUnread)
  261. view.Set("countErrorFeeds", navMetadata.CountErrorFeeds)
  262. response.HTML(w, r, view.Render("webauthn_rename"))
  263. }
  264. func (h *handler) saveCredential(w http.ResponseWriter, r *http.Request) {
  265. user, err := h.store.UserByID(request.UserID(r))
  266. if err != nil {
  267. response.HTMLServerError(w, r, err)
  268. return
  269. }
  270. credentialHandleEncoded := request.RouteStringParam(r, "credentialHandle")
  271. credentialHandle, err := hex.DecodeString(credentialHandleEncoded)
  272. if err != nil {
  273. response.HTMLServerError(w, r, err)
  274. return
  275. }
  276. credUserID, credential, err := h.store.WebAuthnCredentialByHandle(credentialHandle)
  277. if err != nil {
  278. response.HTMLServerError(w, r, err)
  279. return
  280. }
  281. if credUserID != user.ID {
  282. response.HTMLForbidden(w, r)
  283. return
  284. }
  285. webauthnForm := form.NewWebauthnForm(r)
  286. if validationErr := webauthnForm.Validate(); validationErr != nil {
  287. v := view.New(h.tpl, r)
  288. v.Set("form", webauthnForm)
  289. v.Set("cred", credential)
  290. v.Set("menu", "settings")
  291. v.Set("user", user)
  292. v.Set("errorMessage", validationErr.Translate(request.WebSession(r).Language()))
  293. navMetadata, _ := h.store.GetNavMetadata(user.ID)
  294. v.Set("countUnread", navMetadata.CountUnread)
  295. v.Set("countErrorFeeds", navMetadata.CountErrorFeeds)
  296. response.HTML(w, r, v.Render("webauthn_rename"))
  297. return
  298. }
  299. rowsAffected, err := h.store.WebAuthnUpdateName(user.ID, credentialHandle, webauthnForm.Name)
  300. if err != nil {
  301. response.HTMLServerError(w, r, err)
  302. return
  303. }
  304. if rowsAffected == 0 {
  305. response.HTMLNotFound(w, r)
  306. return
  307. }
  308. response.HTMLRedirect(w, r, h.routePath("/authentication"))
  309. }
  310. func (h *handler) deleteCredential(w http.ResponseWriter, r *http.Request) {
  311. credentialHandleEncoded := request.RouteStringParam(r, "credentialHandle")
  312. credentialHandle, err := hex.DecodeString(credentialHandleEncoded)
  313. if err != nil {
  314. response.JSONServerError(w, r, err)
  315. return
  316. }
  317. err = h.store.DeleteCredentialByHandle(request.UserID(r), credentialHandle)
  318. if err != nil {
  319. response.JSONServerError(w, r, err)
  320. return
  321. }
  322. response.NoContent(w, r)
  323. }
  324. func (h *handler) deleteAllCredentials(w http.ResponseWriter, r *http.Request) {
  325. err := h.store.DeleteAllWebAuthnCredentialsByUserID(request.UserID(r))
  326. if err != nil {
  327. response.JSONServerError(w, r, err)
  328. return
  329. }
  330. response.NoContent(w, r)
  331. }