+2

.env.example

··· 8 8 COCOON_ADMIN_PASSWORD= 9 9 # Generate with `openssl rand -hex 32` 10 10 COCOON_SESSION_SECRET= 11 11 + # Optional: Change the session cookie name (default: session) 12 12 + # COCOON_SESSION_COOKIE_KEY=cocoon_session

+31 -1

cmd/cocoon/main.go

··· 6 6 "crypto/rand" 7 7 "encoding/json" 8 8 "fmt" 9 9 + "log/slog" 9 10 "os" 11 11 + "strings" 10 12 "time" 11 13 12 14 "github.com/bluesky-social/go-util/pkg/telemetry" ··· 147 149 EnvVars: []string{"COCOON_SESSION_SECRET"}, 148 150 }, 149 151 &cli.StringFlag{ 152 152 + Name: "session-cookie-key", 153 153 + EnvVars: []string{"COCOON_SESSION_COOKIE_KEY"}, 154 154 + Value: "session", 155 155 + }, 156 156 + &cli.StringFlag{ 150 157 Name: "blockstore-variant", 151 158 EnvVars: []string{"COCOON_BLOCKSTORE_VARIANT"}, 152 159 Value: "sqlite", ··· 177 184 var runServe = &cli.Command{ 178 185 Name: "run", 179 186 Usage: "Start the cocoon PDS", 180 180 - Flags: []cli.Flag{}, 187 187 + Flags: []cli.Flag{ 188 188 + &cli.StringFlag{ 189 189 + Name: "log-level", 190 190 + Usage: "Log level: debug, info, warn, error", 191 191 + EnvVars: []string{"COCOON_LOG_LEVEL", "LOG_LEVEL"}, 192 192 + Value: "info", 193 193 + }, 194 194 + }, 181 195 Action: func(cmd *cli.Context) error { 182 196 183 197 logger := telemetry.StartLogger(cmd) 184 198 telemetry.StartMetrics(cmd) 185 199 200 200 + var level slog.Level 201 201 + switch strings.ToLower(cmd.String("log-level")) { 202 202 + case "debug": 203 203 + level = slog.LevelDebug 204 204 + case "info": 205 205 + level = slog.LevelInfo 206 206 + case "warn": 207 207 + level = slog.LevelWarn 208 208 + case "error": 209 209 + level = slog.LevelError 210 210 + default: 211 211 + level = slog.LevelInfo 212 212 + } 213 213 + 186 214 s, err := server.New(&server.Args{ 187 215 Logger: logger, 216 216 + LogLevel: level, 188 217 Addr: cmd.String("addr"), 189 218 DbName: cmd.String("db-name"), 190 219 DbType: cmd.String("db-type"), ··· 215 244 CDNUrl: cmd.String("s3-cdn-url"), 216 245 }, 217 246 SessionSecret: cmd.String("session-secret"), 247 247 + SessionCookieKey: cmd.String("session-cookie-key"), 218 248 BlockstoreVariant: server.MustReturnBlockstoreVariant(cmd.String("blockstore-variant")), 219 249 FallbackProxy: cmd.String("fallback-proxy"), 220 250 })

+7 -7

go.mod

··· 1 1 module github.com/haileyok/cocoon 2 2 3 3 - go 1.24.5 3 3 + go 1.25 4 4 5 5 require ( 6 6 github.com/Azure/go-autorest/autorest/to v0.4.1 7 7 github.com/aws/aws-sdk-go v1.55.7 8 8 github.com/bluesky-social/go-util v0.0.0-20251012040650-2ebbf57f5934 9 9 - github.com/bluesky-social/indigo v0.0.0-20251009212240-20524de167fe 9 9 + github.com/bluesky-social/indigo v0.0.0-20260203235305-a86f3ae1f8ec 10 10 github.com/btcsuite/websocket v0.0.0-20150119174127-31079b680792 11 11 github.com/domodwyer/mailyak/v3 v3.6.2 12 12 github.com/go-pkgz/expirable-cache/v3 v3.0.0 ··· 25 25 github.com/joho/godotenv v1.5.1 26 26 github.com/labstack/echo-contrib v0.17.4 27 27 github.com/labstack/echo/v4 v4.13.3 28 28 - github.com/lestrrat-go/jwx/v2 v2.0.12 28 28 + github.com/lestrrat-go/jwx/v2 v2.0.21 29 29 github.com/multiformats/go-multihash v0.2.3 30 30 github.com/prometheus/client_golang v1.23.2 31 31 github.com/samber/slog-echo v1.16.1 ··· 42 42 github.com/Azure/go-autorest v14.2.0+incompatible // indirect 43 43 github.com/RussellLuo/slidingwindow v0.0.0-20200528002341-535bb99d338b // indirect 44 44 github.com/beorn7/perks v1.0.1 // indirect 45 45 - github.com/carlmjohnson/versioninfo v0.22.5 // indirect 46 45 github.com/cespare/xxhash/v2 v2.3.0 // indirect 47 46 github.com/cpuguy83/go-md2man/v2 v2.0.5 // indirect 48 47 github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0 // indirect 48 48 + github.com/earthboundkid/versioninfo/v2 v2.24.1 // indirect 49 49 github.com/felixge/httpsnoop v1.0.4 // indirect 50 50 github.com/go-logr/logr v1.4.2 // indirect 51 51 github.com/go-logr/stdr v1.2.2 // indirect ··· 79 79 github.com/ipld/go-ipld-prime v0.21.0 // indirect 80 80 github.com/jackc/pgpassfile v1.0.0 // indirect 81 81 github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect 82 82 - github.com/jackc/pgx/v5 v5.5.0 // indirect 82 82 + github.com/jackc/pgx/v5 v5.5.4 // indirect 83 83 github.com/jackc/puddle/v2 v2.2.1 // indirect 84 84 github.com/jbenet/goprocess v0.1.4 // indirect 85 85 github.com/jinzhu/inflection v1.0.0 // indirect ··· 88 88 github.com/klauspost/cpuid/v2 v2.2.7 // indirect 89 89 github.com/labstack/gommon v0.4.2 // indirect 90 90 github.com/leodido/go-urn v1.4.0 // indirect 91 91 - github.com/lestrrat-go/blackmagic v1.0.1 // indirect 91 91 + github.com/lestrrat-go/blackmagic v1.0.2 // indirect 92 92 github.com/lestrrat-go/httpcc v1.0.1 // indirect 93 93 - github.com/lestrrat-go/httprc v1.0.4 // indirect 93 93 + github.com/lestrrat-go/httprc v1.0.5 // indirect 94 94 github.com/lestrrat-go/iter v1.0.2 // indirect 95 95 github.com/lestrrat-go/option v1.0.1 // indirect 96 96 github.com/mattn/go-colorable v0.1.14 // indirect

+12 -45

go.sum

··· 18 18 github.com/bitly/go-hostpool v0.0.0-20171023180738-a3a6125de932/go.mod h1:NOuUCSz6Q9T7+igc/hlvDOUdtWKryOrtFyIVABv/p7k= 19 19 github.com/bluesky-social/go-util v0.0.0-20251012040650-2ebbf57f5934 h1:btHMur2kTRgWEnCHn6LaI3BE9YRgsqTpwpJ1UdB7VEk= 20 20 github.com/bluesky-social/go-util v0.0.0-20251012040650-2ebbf57f5934/go.mod h1:LWamyZfbQGW7PaVc5jumFfjgrshJ5mXgDUnR6fK7+BI= 21 21 - github.com/bluesky-social/indigo v0.0.0-20251009212240-20524de167fe h1:VBhaqE5ewQgXbY5SfSWFZC/AwHFo7cHxZKFYi2ce9Yo= 22 22 - github.com/bluesky-social/indigo v0.0.0-20251009212240-20524de167fe/go.mod h1:RuQVrCGm42QNsgumKaR6se+XkFKfCPNwdCiTvqKRUck= 21 21 + github.com/bluesky-social/indigo v0.0.0-20260203235305-a86f3ae1f8ec h1:fubriMftMNEmb35sF07gDCsdUSEd0+EIDebt/+5oQRU= 22 22 + github.com/bluesky-social/indigo v0.0.0-20260203235305-a86f3ae1f8ec/go.mod h1:VG/LeqLGNI3Ew7lsYixajnZGFfWPv144qbUddh+Oyag= 23 23 github.com/bmizerany/assert v0.0.0-20160611221934-b7ed37b82869 h1:DDGfHa7BWjL4YnC6+E63dPcxHo2sUxDIu8g3QgEJdRY= 24 24 github.com/bmizerany/assert v0.0.0-20160611221934-b7ed37b82869/go.mod h1:Ekp36dRnpXw/yCqJaO+ZrUyxD+3VXMFFr56k5XYrpB4= 25 25 github.com/btcsuite/websocket v0.0.0-20150119174127-31079b680792 h1:R8vQdOQdZ9Y3SkEwmHoWBmX1DNXhXZqlTpq6s4tyJGc= 26 26 github.com/btcsuite/websocket v0.0.0-20150119174127-31079b680792/go.mod h1:ghJtEyQwv5/p4Mg4C0fgbePVuGr935/5ddU9Z3TmDRY= 27 27 - github.com/carlmjohnson/versioninfo v0.22.5 h1:O00sjOLUAFxYQjlN/bzYTuZiS0y6fWDQjMRvwtKgwwc= 28 28 - github.com/carlmjohnson/versioninfo v0.22.5/go.mod h1:QT9mph3wcVfISUKd0i9sZfVrPviHuSF+cUtLjm2WSf8= 29 27 github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= 30 28 github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= 31 29 github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU= ··· 36 34 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= 37 35 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= 38 36 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= 39 39 - github.com/decred/dcrd/crypto/blake256 v1.0.1/go.mod h1:2OfgNZ5wDpcsFmHmCK5gZTPcCXqlm2ArzUIkw9czNJo= 40 37 github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0 h1:8UrgZ3GkP4i/CLijOJx79Yu+etlyjdBU4sfcs2WYQMs= 41 38 github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0/go.mod h1:v57UDF4pDQJcEfFUCRop3lJL149eHGSe9Jvczhzjo/0= 42 39 github.com/domodwyer/mailyak/v3 v3.6.2 h1:x3tGMsyFhTCaxp6ycgR0FE/bu5QiNp+hetUuCOBXMn8= 43 40 github.com/domodwyer/mailyak/v3 v3.6.2/go.mod h1:lOm/u9CyCVWHeaAmHIdF4RiKVxKUT/H5XX10lIKAL6c= 41 41 + github.com/earthboundkid/versioninfo/v2 v2.24.1 h1:SJTMHaoUx3GzjjnUO1QzP3ZXK6Ee/nbWyCm58eY3oUg= 42 42 + github.com/earthboundkid/versioninfo/v2 v2.24.1/go.mod h1:VcWEooDEuyUJnMfbdTh0uFN4cfEIg+kHMuWB2CDCLjw= 44 43 github.com/fatih/color v1.16.0 h1:zmkK9Ngbjj+K0yRhTVONQh1p/HknKYSlNT+vZCzyokM= 45 44 github.com/fatih/color v1.16.0/go.mod h1:fL2Sau1YI5c0pdGEVCbKQbLXB6edEj1ZgiY4NijnWvE= 46 45 github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg= ··· 176 175 github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg= 177 176 github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a h1:bbPeKD0xmW/Y25WS6cokEszi5g+S0QxI/d45PkRi7Nk= 178 177 github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM= 179 179 - github.com/jackc/pgx/v5 v5.5.0 h1:NxstgwndsTRy7eq9/kqYc/BZh5w2hHJV86wjvO+1xPw= 180 180 - github.com/jackc/pgx/v5 v5.5.0/go.mod h1:Ig06C2Vu0t5qXC60W8sqIthScaEnFvojjj9dSljmHRA= 178 178 + github.com/jackc/pgx/v5 v5.5.4 h1:Xp2aQS8uXButQdnCMWNmvx6UysWQQC+u1EoizjguY+8= 179 179 + github.com/jackc/pgx/v5 v5.5.4/go.mod h1:ez9gk+OAat140fv9ErkZDYFWmXLfV+++K0uAOiwgm1A= 181 180 github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk= 182 181 github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4= 183 182 github.com/jackpal/go-nat-pmp v1.0.2 h1:KzKSgb7qkJvOUTqYl9/Hg/me3pWgBmERKrTGD7BdWus= ··· 222 221 github.com/labstack/gommon v0.4.2/go.mod h1:QlUFxVM+SNXhDL/Z7YhocGIBYOiwB0mXm1+1bAPHPyU= 223 222 github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ= 224 223 github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI= 225 225 - github.com/lestrrat-go/blackmagic v1.0.1 h1:lS5Zts+5HIC/8og6cGHb0uCcNCa3OUt1ygh3Qz2Fe80= 226 226 - github.com/lestrrat-go/blackmagic v1.0.1/go.mod h1:UrEqBzIR2U6CnzVyUtfM6oZNMt/7O7Vohk2J0OGSAtU= 224 224 + github.com/lestrrat-go/blackmagic v1.0.2 h1:Cg2gVSc9h7sz9NOByczrbUvLopQmXrfFx//N+AkAr5k= 225 225 + github.com/lestrrat-go/blackmagic v1.0.2/go.mod h1:UrEqBzIR2U6CnzVyUtfM6oZNMt/7O7Vohk2J0OGSAtU= 227 226 github.com/lestrrat-go/httpcc v1.0.1 h1:ydWCStUeJLkpYyjLDHihupbn2tYmZ7m22BGkcvZZrIE= 228 227 github.com/lestrrat-go/httpcc v1.0.1/go.mod h1:qiltp3Mt56+55GPVCbTdM9MlqhvzyuL6W/NMDA8vA5E= 229 229 - github.com/lestrrat-go/httprc v1.0.4 h1:bAZymwoZQb+Oq8MEbyipag7iSq6YIga8Wj6GOiJGdI8= 230 230 - github.com/lestrrat-go/httprc v1.0.4/go.mod h1:mwwz3JMTPBjHUkkDv/IGJ39aALInZLrhBp0X7KGUZlo= 228 228 + github.com/lestrrat-go/httprc v1.0.5 h1:bsTfiH8xaKOJPrg1R+E3iE/AWZr/x0Phj9PBTG/OLUk= 229 229 + github.com/lestrrat-go/httprc v1.0.5/go.mod h1:mwwz3JMTPBjHUkkDv/IGJ39aALInZLrhBp0X7KGUZlo= 231 230 github.com/lestrrat-go/iter v1.0.2 h1:gMXo1q4c2pHmC3dn8LzRhJfP1ceCbgSiT9lUydIzltI= 232 231 github.com/lestrrat-go/iter v1.0.2/go.mod h1:Momfcq3AnRlRjI5b5O8/G5/BvpzrhoFTZcn06fEOPt4= 233 233 - github.com/lestrrat-go/jwx/v2 v2.0.12 h1:3d589+5w/b9b7S3DneICPW16AqTyYXB7VRjgluSDWeA= 234 234 - github.com/lestrrat-go/jwx/v2 v2.0.12/go.mod h1:Mq4KN1mM7bp+5z/W5HS8aCNs5RKZ911G/0y2qUjAQuQ= 235 235 - github.com/lestrrat-go/option v1.0.0/go.mod h1:5ZHFbivi4xwXxhxY9XHDe2FHo6/Z7WWmtT7T5nBBp3I= 232 232 + github.com/lestrrat-go/jwx/v2 v2.0.21 h1:jAPKupy4uHgrHFEdjVjNkUgoBKtVDgrQPB/h55FHrR0= 233 233 + github.com/lestrrat-go/jwx/v2 v2.0.21/go.mod h1:09mLW8zto6bWL9GbwnqAli+ArLf+5M33QLQPDggkUWM= 236 234 github.com/lestrrat-go/option v1.0.1 h1:oAzP2fvZGQKWkvHa1/SAcFolBEca1oN+mQ7eooNBEYU= 237 235 github.com/lestrrat-go/option v1.0.1/go.mod h1:5ZHFbivi4xwXxhxY9XHDe2FHo6/Z7WWmtT7T5nBBp3I= 238 236 github.com/libp2p/go-buffer-pool v0.1.0 h1:oK4mSFcQz7cTQIfqbe4MIj9gLW+mnanjyFtc6cdF0Y8= ··· 325 323 github.com/spaolacci/murmur3 v1.1.0 h1:7c1g84S4BPRrfL5Xrdp6fOJ206sU9y293DDHaoy0bLI= 326 324 github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= 327 325 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= 328 328 - github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= 329 329 - github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= 330 326 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= 331 327 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= 332 328 github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= 333 329 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= 334 330 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= 335 335 - github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= 336 336 - github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= 337 331 github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= 338 332 github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= 339 333 github.com/urfave/cli v1.22.10/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0= ··· 356 350 github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= 357 351 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= 358 352 github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= 359 359 - github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= 360 353 gitlab.com/yawning/secp256k1-voi v0.0.0-20230925100816-f2616030848b h1:CzigHMRySiX3drau9C6Q5CAbNIApmLdat5jPMqChvDA= 361 354 gitlab.com/yawning/secp256k1-voi v0.0.0-20230925100816-f2616030848b/go.mod h1:/y/V339mxv2sZmYYR64O07VuCpdNZqCTwO8ZcouTMI8= 362 355 gitlab.com/yawning/tuplehash v0.0.0-20230713102510-df83abbf9a02 h1:qwDnMxjkyLmAFgcfgTnfJrmYKWhHnci3GjDqcZp1M3Q= ··· 391 384 golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= 392 385 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= 393 386 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= 394 394 - golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= 395 395 - golang.org/x/crypto v0.12.0/go.mod h1:NF0Gs7EO5K4qLn+Ylc+fih8BSTeIjAP05siRnAh98yw= 396 387 golang.org/x/crypto v0.41.0 h1:WKYxWedPGCTVVl5+WHSSrOBT0O8lx32+zxmHxijgXp4= 397 388 golang.org/x/crypto v0.41.0/go.mod h1:pO5AFd7FA68rFak7rOAGVuygIISepHftHnr8dr6+sUc= 398 389 golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa h1:FRnLl4eNAQl8hwxVVC17teOw8kdjVDVAiFMtgUdTSRQ= ··· 402 393 golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= 403 394 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= 404 395 golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= 405 405 - golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= 406 406 - golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= 407 396 golang.org/x/mod v0.26.0 h1:EGMPT//Ezu+ylkCijjPc+f4Aih7sZvaAr+O3EHBxvZg= 408 397 golang.org/x/mod v0.26.0/go.mod h1:/j6NAhSk8iQ723BGAUyoAcn7SlD7s15Dp9Nd/SfeaFQ= 409 398 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= ··· 411 400 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= 412 401 golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= 413 402 golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= 414 414 - golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= 415 403 golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= 416 416 - golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= 417 417 - golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= 418 418 - golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg= 419 404 golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE= 420 405 golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg= 421 406 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= 422 407 golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= 423 408 golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= 424 409 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= 425 425 - golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= 426 426 - golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= 427 410 golang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw= 428 411 golang.org/x/sync v0.16.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA= 429 412 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= ··· 432 415 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= 433 416 golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= 434 417 golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= 435 435 - golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= 436 418 golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= 437 437 - golang.org/x/sys v0.0.0-20220412211240-33da011f77ad/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= 438 438 - golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= 439 439 - golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= 440 419 golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= 441 420 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= 442 442 - golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= 443 443 - golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= 444 421 golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI= 445 422 golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= 446 423 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= 447 447 - golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= 448 448 - golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k= 449 449 - golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo= 450 450 - golang.org/x/term v0.11.0/go.mod h1:zC9APTIj3jG3FdV/Ons+XE1riIZXG4aZ4GTHiPZJPIU= 451 424 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= 452 425 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= 453 453 - golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= 454 454 - golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= 455 455 - golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= 456 456 - golang.org/x/text v0.12.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE= 457 426 golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng= 458 427 golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU= 459 428 golang.org/x/time v0.11.0 h1:/bpjEDfN9tkoN/ryeYHnv5hcMlc8ncjMcM4XBk5NWV0= ··· 468 437 golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= 469 438 golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= 470 439 golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= 471 471 - golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= 472 472 - golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= 473 440 golang.org/x/tools v0.35.0 h1:mBffYraMEf7aa0sB+NuKnuCy8qI/9Bughn8dC2Gu5r0= 474 441 golang.org/x/tools v0.35.0/go.mod h1:NKdj5HkL/73byiZSJjqJgKn3ep7KjFkBOkR/Hps3VPw= 475 442 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

+3 -21

internal/db/db.go

··· 2 2 3 3 import ( 4 4 "context" 5 5 - "sync" 6 5 7 6 "gorm.io/gorm" 8 7 "gorm.io/gorm/clause" ··· 10 9 11 10 type DB struct { 12 11 cli *gorm.DB 13 13 - mu sync.Mutex 14 12 } 15 13 16 14 func NewDB(cli *gorm.DB) *DB { 17 15 return &DB{ 18 16 cli: cli, 19 19 - mu: sync.Mutex{}, 20 17 } 21 18 } 22 19 23 20 func (db *DB) Create(ctx context.Context, value any, clauses []clause.Expression) *gorm.DB { 24 24 - db.mu.Lock() 25 25 - defer db.mu.Unlock() 26 21 return db.cli.WithContext(ctx).Clauses(clauses...).Create(value) 27 22 } 28 23 29 24 func (db *DB) Save(ctx context.Context, value any, clauses []clause.Expression) *gorm.DB { 30 30 - db.mu.Lock() 31 31 - defer db.mu.Unlock() 32 25 return db.cli.WithContext(ctx).Clauses(clauses...).Save(value) 33 26 } 34 27 35 28 func (db *DB) Exec(ctx context.Context, sql string, clauses []clause.Expression, values ...any) *gorm.DB { 36 36 - db.mu.Lock() 37 37 - defer db.mu.Unlock() 38 29 return db.cli.WithContext(ctx).Clauses(clauses...).Exec(sql, values...) 39 30 } 40 31 ··· 47 38 } 48 39 49 40 func (db *DB) Delete(ctx context.Context, value any, clauses []clause.Expression) *gorm.DB { 50 50 - db.mu.Lock() 51 51 - defer db.mu.Unlock() 52 41 return db.cli.WithContext(ctx).Clauses(clauses...).Delete(value) 53 42 } 54 43 ··· 56 45 return db.cli.WithContext(ctx).First(dest, conds...) 57 46 } 58 47 59 59 - // TODO: this isn't actually good. we can commit even if the db is locked here. this is probably okay for the time being, but need to figure 60 60 - // out a better solution. right now we only do this whenever we're importing a repo though so i'm mostly not worried, but it's still bad. 61 61 - // e.g. when we do apply writes we should also be using a transcation but we don't right now 62 62 - func (db *DB) BeginDangerously(ctx context.Context) *gorm.DB { 48 48 + func (db *DB) Begin(ctx context.Context) *gorm.DB { 63 49 return db.cli.WithContext(ctx).Begin() 64 50 } 65 51 66 66 - func (db *DB) Lock() { 67 67 - db.mu.Lock() 68 68 - } 69 69 - 70 70 - func (db *DB) Unlock() { 71 71 - db.mu.Unlock() 52 52 + func (db *DB) Client() *gorm.DB { 53 53 + return db.cli 72 54 }

+20 -2

models/models.go

··· 8 8 "github.com/bluesky-social/indigo/atproto/atcrypto" 9 9 ) 10 10 11 11 + type TwoFactorType string 12 12 + 13 13 + var ( 14 14 + TwoFactorTypeNone = TwoFactorType("none") 15 15 + TwoFactorTypeEmail = TwoFactorType("email") 16 16 + ) 17 17 + 11 18 type Repo struct { 12 19 Did string `gorm:"primaryKey"` 13 20 CreatedAt time.Time ··· 29 36 Root []byte 30 37 Preferences []byte 31 38 Deactivated bool 39 39 + TwoFactorCode *string 40 40 + TwoFactorCodeExpiresAt *time.Time 41 41 + TwoFactorType TwoFactorType `gorm:"default:none"` 32 42 } 33 43 34 44 func (r *Repo) SignFor(ctx context.Context, did string, msg []byte) ([]byte, error) { ··· 121 131 } 122 132 123 133 type ReservedKey struct { 124 124 - KeyDid string `gorm:"primaryKey"` 125 125 - Did *string `gorm:"index"` 134 134 + KeyDid string `gorm:"primaryKey"` 135 135 + Did *string `gorm:"index"` 126 136 PrivateKey []byte 127 137 CreatedAt time.Time `gorm:"index"` 128 138 } 139 139 + 140 140 + type EventRecord struct { 141 141 + Seq int64 `gorm:"primaryKey;autoIncrement:false"` 142 142 + CreatedAt time.Time 143 143 + Did string `gorm:"index"` 144 144 + Type string 145 145 + Data []byte 146 146 + }

+4 -4

oauth/dpop/manager.go

··· 75 75 } 76 76 77 77 proof := extractProof(headers) 78 78 - 79 78 if proof == "" { 80 79 return nil, nil 81 80 } ··· 197 196 198 197 nonce, _ := claims["nonce"].(string) 199 198 if nonce == "" { 200 200 - // WARN: this _must_ be `use_dpop_nonce` for clients know they should make another request 199 199 + // reference impl checks if self.nonce is not null before returning an error, but we always have a 200 200 + // nonce so we do not bother checking 201 201 return nil, ErrUseDpopNonce 202 202 } 203 203 204 204 if nonce != "" && !dm.nonce.Check(nonce) { 205 205 - // WARN: this _must_ be `use_dpop_nonce` so that clients will fetch a new nonce 205 205 + // dpop nonce mismatch 206 206 return nil, ErrUseDpopNonce 207 207 } 208 208 ··· 237 237 } 238 238 239 239 func extractProof(headers http.Header) string { 240 240 - dpopHeaders := headers["Dpop"] 240 240 + dpopHeaders := headers.Values("dpop") 241 241 switch len(dpopHeaders) { 242 242 case 0: 243 243 return ""

+3 -3

oauth/provider/client_auth.go

··· 19 19 } 20 20 21 21 type AuthenticateClientRequestBase struct { 22 22 - ClientID string `form:"client_id" json:"client_id" validate:"required"` 23 23 - ClientAssertionType *string `form:"client_assertion_type" json:"client_assertion_type,omitempty"` 24 24 - ClientAssertion *string `form:"client_assertion" json:"client_assertion,omitempty"` 22 22 + ClientID string `form:"client_id" json:"client_id" query:"client_id" validate:"required"` 23 23 + ClientAssertionType *string `form:"client_assertion_type" json:"client_assertion_type,omitempty" query:"client_assertion_type"` 24 24 + ClientAssertion *string `form:"client_assertion" json:"client_assertion,omitempty" query:"client_assertion"` 25 25 } 26 26 27 27 func (p *Provider) AuthenticateClient(ctx context.Context, req AuthenticateClientRequestBase, proof *dpop.Proof, opts *AuthenticateClientOptions) (*client.Client, *ClientAuth, error) {

+9 -8

oauth/provider/models.go

··· 32 32 33 33 type ParRequest struct { 34 34 AuthenticateClientRequestBase 35 35 - ResponseType string `form:"response_type" json:"response_type" validate:"required"` 36 36 - CodeChallenge *string `form:"code_challenge" json:"code_challenge" validate:"required"` 37 37 - CodeChallengeMethod string `form:"code_challenge_method" json:"code_challenge_method" validate:"required"` 38 38 - State string `form:"state" json:"state" validate:"required"` 39 39 - RedirectURI string `form:"redirect_uri" json:"redirect_uri" validate:"required"` 40 40 - Scope string `form:"scope" json:"scope" validate:"required"` 41 41 - LoginHint *string `form:"login_hint" json:"login_hint,omitempty"` 42 42 - DpopJkt *string `form:"dpop_jkt" json:"dpop_jkt,omitempty"` 35 35 + ResponseType string `form:"response_type" json:"response_type" query:"response_type" validate:"required"` 36 36 + CodeChallenge *string `form:"code_challenge" json:"code_challenge" query:"code_challenge" validate:"required"` 37 37 + CodeChallengeMethod string `form:"code_challenge_method" json:"code_challenge_method" query:"code_challenge_method" validate:"required"` 38 38 + State string `form:"state" json:"state" query:"state" validate:"required"` 39 39 + RedirectURI string `form:"redirect_uri" json:"redirect_uri" query:"redirect_uri" validate:"required"` 40 40 + Scope string `form:"scope" json:"scope" query:"scope" validate:"required"` 41 41 + LoginHint *string `form:"login_hint" query:"login_hint" json:"login_hint,omitempty"` 42 42 + DpopJkt *string `form:"dpop_jkt" query:"dpop_jkt" json:"dpop_jkt,omitempty"` 43 43 + ResponseMode *string `form:"response_mode" json:"response_mode,omitempty" query:"response_mode"` 43 44 } 44 45 45 46 func (opr *ParRequest) Scan(value any) error {

+5 -5

plc/client.go

··· 61 61 } 62 62 63 63 op := Operation{ 64 64 - Type: "plc_operation", 64 64 + Type: "plc_operation", 65 65 VerificationMethods: creds.VerificationMethods, 66 66 - RotationKeys: creds.RotationKeys, 67 67 - AlsoKnownAs: creds.AlsoKnownAs, 68 68 - Services: creds.Services, 69 69 - Prev: nil, 66 66 + RotationKeys: creds.RotationKeys, 67 67 + AlsoKnownAs: creds.AlsoKnownAs, 68 68 + Services: creds.Services, 69 69 + Prev: nil, 70 70 } 71 71 72 72 if err := c.SignOp(sigkey, &op); err != nil {

-1

plc/types.go

··· 8 8 cbg "github.com/whyrusleeping/cbor-gen" 9 9 ) 10 10 11 11 - 12 11 type DidCredentials struct { 13 12 VerificationMethods map[string]string `json:"verificationMethods"` 14 13 RotationKeys []string `json:"rotationKeys"`

+58 -11

server/handle_account_signin.go

··· 2 2 3 3 import ( 4 4 "errors" 5 5 + "fmt" 5 6 "strings" 7 7 + "time" 6 8 7 9 "github.com/bluesky-social/indigo/atproto/syntax" 8 10 "github.com/gorilla/sessions" ··· 15 17 ) 16 18 17 19 type OauthSigninInput struct { 18 18 - Username string `form:"username"` 19 19 - Password string `form:"password"` 20 20 - QueryParams string `form:"query_params"` 20 20 + Username string `form:"username"` 21 21 + Password string `form:"password"` 22 22 + AuthFactorToken string `form:"token"` 23 23 + QueryParams string `form:"query_params"` 21 24 } 22 25 23 26 func (s *Server) getSessionRepoOrErr(e echo.Context) (*models.RepoActor, *sessions.Session, error) { 24 27 ctx := e.Request().Context() 25 28 26 26 - sess, err := session.Get("session", e) 29 29 + sess, err := session.Get(s.config.SessionCookieKey, e) 27 30 if err != nil { 28 31 return nil, nil, err 29 32 } ··· 44 47 func getFlashesFromSession(e echo.Context, sess *sessions.Session) map[string]any { 45 48 defer sess.Save(e.Request(), e.Response()) 46 49 return map[string]any{ 47 47 - "errors": sess.Flashes("error"), 48 48 - "successes": sess.Flashes("success"), 50 50 + "errors": sess.Flashes("error"), 51 51 + "successes": sess.Flashes("success"), 52 52 + "tokenrequired": sess.Flashes("tokenrequired"), 49 53 } 50 54 } 51 55 ··· 71 75 return helpers.ServerError(e, nil) 72 76 } 73 77 74 74 - sess, _ := session.Get("session", e) 78 78 + sess, _ := session.Get(s.config.SessionCookieKey, e) 75 79 76 80 req.Username = strings.ToLower(req.Username) 77 81 var idtype string ··· 83 87 idtype = "email" 84 88 } 85 89 90 90 + queryParams := "" 91 91 + if req.QueryParams != "" { 92 92 + queryParams = fmt.Sprintf("?%s", req.QueryParams) 93 93 + } 94 94 + 86 95 // TODO: we should make this a helper since we do it for the base create_session as well 87 96 var repo models.RepoActor 88 97 var err error ··· 101 110 sess.AddFlash("Something went wrong!", "error") 102 111 } 103 112 sess.Save(e.Request(), e.Response()) 104 104 - return e.Redirect(303, "/account/signin") 113 113 + return e.Redirect(303, "/account/signin"+queryParams) 105 114 } 106 115 107 116 if err := bcrypt.CompareHashAndPassword([]byte(repo.Password), []byte(req.Password)); err != nil { ··· 111 120 sess.AddFlash("Something went wrong!", "error") 112 121 } 113 122 sess.Save(e.Request(), e.Response()) 114 114 - return e.Redirect(303, "/account/signin") 123 123 + return e.Redirect(303, "/account/signin"+queryParams) 124 124 + } 125 125 + 126 126 + // if repo requires 2FA token and one hasn't been provided, return error prompting for one 127 127 + if repo.TwoFactorType != models.TwoFactorTypeNone && req.AuthFactorToken == "" { 128 128 + err = s.createAndSendTwoFactorCode(ctx, repo) 129 129 + if err != nil { 130 130 + sess.AddFlash("Something went wrong!", "error") 131 131 + sess.Save(e.Request(), e.Response()) 132 132 + return e.Redirect(303, "/account/signin"+queryParams) 133 133 + } 134 134 + 135 135 + sess.AddFlash("requires 2FA token", "tokenrequired") 136 136 + sess.Save(e.Request(), e.Response()) 137 137 + return e.Redirect(303, "/account/signin"+queryParams) 138 138 + } 139 139 + 140 140 + // if 2FAis required, now check that the one provided is valid 141 141 + if repo.TwoFactorType != models.TwoFactorTypeNone { 142 142 + if repo.TwoFactorCode == nil || repo.TwoFactorCodeExpiresAt == nil { 143 143 + err = s.createAndSendTwoFactorCode(ctx, repo) 144 144 + if err != nil { 145 145 + sess.AddFlash("Something went wrong!", "error") 146 146 + sess.Save(e.Request(), e.Response()) 147 147 + return e.Redirect(303, "/account/signin"+queryParams) 148 148 + } 149 149 + 150 150 + sess.AddFlash("requires 2FA token", "tokenrequired") 151 151 + sess.Save(e.Request(), e.Response()) 152 152 + return e.Redirect(303, "/account/signin"+queryParams) 153 153 + } 154 154 + 155 155 + if *repo.TwoFactorCode != req.AuthFactorToken { 156 156 + return helpers.InvalidTokenError(e) 157 157 + } 158 158 + 159 159 + if time.Now().UTC().After(*repo.TwoFactorCodeExpiresAt) { 160 160 + return helpers.ExpiredTokenError(e) 161 161 + } 115 162 } 116 163 117 164 sess.Options = &sessions.Options{ ··· 127 174 return err 128 175 } 129 176 130 130 - if req.QueryParams != "" { 131 131 - return e.Redirect(303, "/oauth/authorize?"+req.QueryParams) 177 177 + if queryParams != "" { 178 178 + return e.Redirect(303, "/oauth/authorize"+queryParams) 132 179 } else { 133 180 return e.Redirect(303, "/account") 134 181 }

+1 -1

server/handle_account_signout.go

··· 7 7 ) 8 8 9 9 func (s *Server) handleAccountSignout(e echo.Context) error { 10 10 - sess, err := session.Get("session", e) 10 10 + sess, err := session.Get(s.config.SessionCookieKey, e) 11 11 if err != nil { 12 12 return err 13 13 }

+26

server/handle_age_assurance.go

··· 1 1 + package server 2 2 + 3 3 + import ( 4 4 + "time" 5 5 + 6 6 + "github.com/bluesky-social/indigo/util" 7 7 + "github.com/haileyok/cocoon/models" 8 8 + "github.com/labstack/echo/v4" 9 9 + ) 10 10 + 11 11 + func (s *Server) handleAgeAssurance(e echo.Context) error { 12 12 + repo := e.Get("repo").(*models.RepoActor) 13 13 + 14 14 + resp := map[string]any{ 15 15 + "state": map[string]any{ 16 16 + "status": "assured", 17 17 + "access": "full", 18 18 + "lastInitiatedAt": time.Now().Format(util.ISO8601), 19 19 + }, 20 20 + "metadata": map[string]any{ 21 21 + "accountCreatedAt": repo.CreatedAt.Format(util.ISO8601), 22 22 + }, 23 23 + } 24 24 + 25 25 + return e.JSON(200, resp) 26 26 + }

+1 -1

server/handle_import_repo.go

··· 66 66 return helpers.ServerError(e, nil) 67 67 } 68 68 69 69 - tx := s.db.BeginDangerously(ctx) 69 69 + tx := s.db.Begin(ctx) 70 70 71 71 clock := syntax.NewTIDClock(0) 72 72

+95 -19

server/handle_oauth_authorize.go

··· 1 1 package server 2 2 3 3 import ( 4 4 + "fmt" 4 5 "net/url" 5 6 "strings" 6 7 "time" ··· 8 9 "github.com/Azure/go-autorest/autorest/to" 9 10 "github.com/haileyok/cocoon/internal/helpers" 10 11 "github.com/haileyok/cocoon/oauth" 12 12 + "github.com/haileyok/cocoon/oauth/constants" 11 13 "github.com/haileyok/cocoon/oauth/provider" 12 14 "github.com/labstack/echo/v4" 13 15 ) 14 16 17 17 + type HandleOauthAuthorizeGetInput struct { 18 18 + RequestUri string `query:"request_uri"` 19 19 + } 20 20 + 15 21 func (s *Server) handleOauthAuthorizeGet(e echo.Context) error { 16 22 ctx := e.Request().Context() 17 23 18 18 - reqUri := e.QueryParam("request_uri") 19 19 - if reqUri == "" { 20 20 - // render page for logged out dev 21 21 - if s.config.Version == "dev" { 22 22 - return e.Render(200, "authorize.html", map[string]any{ 23 23 - "Scopes": []string{"atproto", "transition:generic"}, 24 24 - "AppName": "DEV MODE AUTHORIZATION PAGE", 25 25 - "Handle": "paula.cocoon.social", 26 26 - "RequestUri": "", 27 27 - }) 24 24 + logger := s.logger.With("name", "handleOauthAuthorizeGet") 25 25 + 26 26 + var input HandleOauthAuthorizeGetInput 27 27 + if err := e.Bind(&input); err != nil { 28 28 + logger.Error("error binding request", "err", err) 29 29 + return fmt.Errorf("error binding request") 30 30 + } 31 31 + 32 32 + var reqId string 33 33 + if input.RequestUri != "" { 34 34 + id, err := oauth.DecodeRequestUri(input.RequestUri) 35 35 + if err != nil { 36 36 + logger.Error("no request uri found in input", "url", e.Request().URL.String()) 37 37 + return helpers.InputError(e, to.StringPtr("no request uri")) 38 38 + } 39 39 + reqId = id 40 40 + } else { 41 41 + var parRequest provider.ParRequest 42 42 + if err := e.Bind(&parRequest); err != nil { 43 43 + s.logger.Error("error binding for standard auth request", "error", err) 44 44 + return helpers.InputError(e, to.StringPtr("InvalidRequest")) 45 45 + } 46 46 + 47 47 + if err := e.Validate(parRequest); err != nil { 48 48 + // render page for logged out dev 49 49 + if s.config.Version == "dev" && parRequest.ClientID == "" { 50 50 + return e.Render(200, "authorize.html", map[string]any{ 51 51 + "Scopes": []string{"atproto", "transition:generic"}, 52 52 + "AppName": "DEV MODE AUTHORIZATION PAGE", 53 53 + "Handle": "paula.cocoon.social", 54 54 + "RequestUri": "", 55 55 + }) 56 56 + } 57 57 + return helpers.InputError(e, to.StringPtr("no request uri and invalid parameters")) 28 58 } 29 29 - return helpers.InputError(e, to.StringPtr("no request uri")) 59 59 + 60 60 + client, clientAuth, err := s.oauthProvider.AuthenticateClient(ctx, parRequest.AuthenticateClientRequestBase, nil, &provider.AuthenticateClientOptions{ 61 61 + AllowMissingDpopProof: true, 62 62 + }) 63 63 + if err != nil { 64 64 + s.logger.Error("error authenticating client in standard request", "client_id", parRequest.ClientID, "error", err) 65 65 + return helpers.ServerError(e, to.StringPtr(err.Error())) 66 66 + } 67 67 + 68 68 + if parRequest.DpopJkt == nil { 69 69 + if client.Metadata.DpopBoundAccessTokens { 70 70 + } 71 71 + } else { 72 72 + if !client.Metadata.DpopBoundAccessTokens { 73 73 + msg := "dpop bound access tokens are not enabled for this client" 74 74 + return helpers.InputError(e, &msg) 75 75 + } 76 76 + } 77 77 + 78 78 + eat := time.Now().Add(constants.ParExpiresIn) 79 79 + id := oauth.GenerateRequestId() 80 80 + 81 81 + authRequest := &provider.OauthAuthorizationRequest{ 82 82 + RequestId: id, 83 83 + ClientId: client.Metadata.ClientID, 84 84 + ClientAuth: *clientAuth, 85 85 + Parameters: parRequest, 86 86 + ExpiresAt: eat, 87 87 + } 88 88 + 89 89 + if err := s.db.Create(ctx, authRequest, nil).Error; err != nil { 90 90 + s.logger.Error("error creating auth request in db", "error", err) 91 91 + return helpers.ServerError(e, nil) 92 92 + } 93 93 + 94 94 + input.RequestUri = oauth.EncodeRequestUri(id) 95 95 + reqId = id 96 96 + 30 97 } 31 98 32 99 repo, _, err := s.getSessionRepoOrErr(e) 33 100 if err != nil { 34 101 return e.Redirect(303, "/account/signin?"+e.QueryParams().Encode()) 35 35 - } 36 36 - 37 37 - reqId, err := oauth.DecodeRequestUri(reqUri) 38 38 - if err != nil { 39 39 - return helpers.InputError(e, to.StringPtr(err.Error())) 40 102 } 41 103 42 104 var req provider.OauthAuthorizationRequest ··· 60 122 data := map[string]any{ 61 123 "Scopes": scopes, 62 124 "AppName": appName, 63 63 - "RequestUri": reqUri, 125 125 + "RequestUri": input.RequestUri, 64 126 "QueryParams": e.QueryParams().Encode(), 65 127 "Handle": repo.Actor.Handle, 66 128 } ··· 129 191 q.Set("code", code) 130 192 131 193 hashOrQuestion := "?" 132 132 - if authReq.ClientAuth.Method != "private_key_jwt" { 133 133 - hashOrQuestion = "#" 194 194 + if authReq.Parameters.ResponseMode != nil { 195 195 + switch *authReq.Parameters.ResponseMode { 196 196 + case "fragment": 197 197 + hashOrQuestion = "#" 198 198 + case "query": 199 199 + // do nothing 200 200 + break 201 201 + default: 202 202 + if authReq.Parameters.ResponseType != "code" { 203 203 + hashOrQuestion = "#" 204 204 + } 205 205 + } 206 206 + } else { 207 207 + if authReq.Parameters.ResponseType != "code" { 208 208 + hashOrQuestion = "#" 209 209 + } 134 210 } 135 211 136 212 return e.Redirect(303, authReq.Parameters.RedirectURI+hashOrQuestion+q.Encode())

+1

server/handle_oauth_par.go

··· 42 42 e.Response().Header().Set("DPoP-Nonce", nonce) 43 43 e.Response().Header().Add("access-control-expose-headers", "DPoP-Nonce") 44 44 } 45 45 + logger.Error("nonce error: use_dpop_nonce", "headers", e.Request().Header) 45 46 return e.JSON(400, map[string]string{ 46 47 "error": "use_dpop_nonce", 47 48 })

+54 -1

server/handle_server_create_session.go

··· 1 1 package server 2 2 3 3 import ( 4 4 + "context" 4 5 "errors" 6 6 + "fmt" 5 7 "strings" 8 8 + "time" 6 9 7 10 "github.com/Azure/go-autorest/autorest/to" 8 11 "github.com/bluesky-social/indigo/atproto/syntax" ··· 91 94 return helpers.InputError(e, to.StringPtr("InvalidRequest")) 92 95 } 93 96 97 97 + // if repo requires 2FA token and one hasn't been provided, return error prompting for one 98 98 + if repo.TwoFactorType != models.TwoFactorTypeNone && (req.AuthFactorToken == nil || *req.AuthFactorToken == "") { 99 99 + err = s.createAndSendTwoFactorCode(ctx, repo) 100 100 + if err != nil { 101 101 + logger.Error("sending 2FA code", "error", err) 102 102 + return helpers.ServerError(e, nil) 103 103 + } 104 104 + 105 105 + return helpers.InputError(e, to.StringPtr("AuthFactorTokenRequired")) 106 106 + } 107 107 + 108 108 + // if 2FA is required, now check that the one provided is valid 109 109 + if repo.TwoFactorType != models.TwoFactorTypeNone { 110 110 + if repo.TwoFactorCode == nil || repo.TwoFactorCodeExpiresAt == nil { 111 111 + err = s.createAndSendTwoFactorCode(ctx, repo) 112 112 + if err != nil { 113 113 + logger.Error("sending 2FA code", "error", err) 114 114 + return helpers.ServerError(e, nil) 115 115 + } 116 116 + 117 117 + return helpers.InputError(e, to.StringPtr("AuthFactorTokenRequired")) 118 118 + } 119 119 + 120 120 + if *repo.TwoFactorCode != *req.AuthFactorToken { 121 121 + return helpers.InvalidTokenError(e) 122 122 + } 123 123 + 124 124 + if time.Now().UTC().After(*repo.TwoFactorCodeExpiresAt) { 125 125 + return helpers.ExpiredTokenError(e) 126 126 + } 127 127 + } 128 128 + 94 129 sess, err := s.createSession(ctx, &repo.Repo) 95 130 if err != nil { 96 131 logger.Error("error creating session", "error", err) ··· 104 139 Did: repo.Repo.Did, 105 140 Email: repo.Email, 106 141 EmailConfirmed: repo.EmailConfirmedAt != nil, 107 107 - EmailAuthFactor: false, 142 142 + EmailAuthFactor: repo.TwoFactorType != models.TwoFactorTypeNone, 108 143 Active: repo.Active(), 109 144 Status: repo.Status(), 110 145 }) 111 146 } 147 147 + 148 148 + func (s *Server) createAndSendTwoFactorCode(ctx context.Context, repo models.RepoActor) error { 149 149 + // TODO: when implementing a new type of 2FA there should be some logic in here to send the 150 150 + // right type of code 151 151 + 152 152 + code := fmt.Sprintf("%s-%s", helpers.RandomVarchar(5), helpers.RandomVarchar(5)) 153 153 + eat := time.Now().Add(10 * time.Minute).UTC() 154 154 + 155 155 + if err := s.db.Exec(ctx, "UPDATE repos SET two_factor_code = ?, two_factor_code_expires_at = ? WHERE did = ?", nil, code, eat, repo.Repo.Did).Error; err != nil { 156 156 + return fmt.Errorf("updating repo: %w", err) 157 157 + } 158 158 + 159 159 + if err := s.sendTwoFactorCode(repo.Email, repo.Handle, code); err != nil { 160 160 + return fmt.Errorf("sending email: %w", err) 161 161 + } 162 162 + 163 163 + return nil 164 164 + }

+11 -11

server/handle_server_delete_account.go

··· 69 69 }) 70 70 } 71 71 72 72 - tx := s.db.BeginDangerously(ctx) 72 72 + tx := s.db.Begin(ctx) 73 73 if tx.Error != nil { 74 74 logger.Error("error starting transaction", "error", tx.Error) 75 75 return helpers.ServerError(e, nil) 76 76 } 77 77 78 78 status := "error" 79 79 - func() { 79 79 + defer func() { 80 80 if status == "error" { 81 81 if err := tx.Rollback().Error; err != nil { 82 82 logger.Error("error rolling back after delete failure", "err", err) ··· 84 84 } 85 85 }() 86 86 87 87 - if err := tx.Exec("DELETE FROM blocks WHERE did = ?", nil, req.Did).Error; err != nil { 87 87 + if err := tx.Exec("DELETE FROM blocks WHERE did = ?", req.Did).Error; err != nil { 88 88 logger.Error("error deleting blocks", "error", err) 89 89 return helpers.ServerError(e, nil) 90 90 } 91 91 92 92 - if err := tx.Exec("DELETE FROM records WHERE did = ?", nil, req.Did).Error; err != nil { 92 92 + if err := tx.Exec("DELETE FROM records WHERE did = ?", req.Did).Error; err != nil { 93 93 logger.Error("error deleting records", "error", err) 94 94 return helpers.ServerError(e, nil) 95 95 } 96 96 97 97 - if err := tx.Exec("DELETE FROM blobs WHERE did = ?", nil, req.Did).Error; err != nil { 97 97 + if err := tx.Exec("DELETE FROM blobs WHERE did = ?", req.Did).Error; err != nil { 98 98 logger.Error("error deleting blobs", "error", err) 99 99 return helpers.ServerError(e, nil) 100 100 } 101 101 102 102 - if err := tx.Exec("DELETE FROM tokens WHERE did = ?", nil, req.Did).Error; err != nil { 102 102 + if err := tx.Exec("DELETE FROM tokens WHERE did = ?", req.Did).Error; err != nil { 103 103 logger.Error("error deleting tokens", "error", err) 104 104 return helpers.ServerError(e, nil) 105 105 } 106 106 107 107 - if err := tx.Exec("DELETE FROM refresh_tokens WHERE did = ?", nil, req.Did).Error; err != nil { 107 107 + if err := tx.Exec("DELETE FROM refresh_tokens WHERE did = ?", req.Did).Error; err != nil { 108 108 logger.Error("error deleting refresh tokens", "error", err) 109 109 return helpers.ServerError(e, nil) 110 110 } 111 111 112 112 - if err := tx.Exec("DELETE FROM reserved_keys WHERE did = ?", nil, req.Did).Error; err != nil { 112 112 + if err := tx.Exec("DELETE FROM reserved_keys WHERE did = ?", req.Did).Error; err != nil { 113 113 logger.Error("error deleting reserved keys", "error", err) 114 114 return helpers.ServerError(e, nil) 115 115 } 116 116 117 117 - if err := tx.Exec("DELETE FROM invite_codes WHERE did = ?", nil, req.Did).Error; err != nil { 117 117 + if err := tx.Exec("DELETE FROM invite_codes WHERE did = ?", req.Did).Error; err != nil { 118 118 logger.Error("error deleting invite codes", "error", err) 119 119 return helpers.ServerError(e, nil) 120 120 } 121 121 122 122 - if err := tx.Exec("DELETE FROM actors WHERE did = ?", nil, req.Did).Error; err != nil { 122 122 + if err := tx.Exec("DELETE FROM actors WHERE did = ?", req.Did).Error; err != nil { 123 123 logger.Error("error deleting actor", "error", err) 124 124 return helpers.ServerError(e, nil) 125 125 } 126 126 127 127 - if err := tx.Exec("DELETE FROM repos WHERE did = ?", nil, req.Did).Error; err != nil { 127 127 + if err := tx.Exec("DELETE FROM repos WHERE did = ?", req.Did).Error; err != nil { 128 128 logger.Error("error deleting repo", "error", err) 129 129 return helpers.ServerError(e, nil) 130 130 }

+1 -1

server/handle_server_get_session.go

··· 23 23 Did: repo.Repo.Did, 24 24 Email: repo.Email, 25 25 EmailConfirmed: repo.EmailConfirmedAt != nil, 26 26 - EmailAuthFactor: false, // TODO: todo todo 26 26 + EmailAuthFactor: repo.TwoFactorType != models.TwoFactorTypeNone, 27 27 Active: repo.Active(), 28 28 Status: repo.Status(), 29 29 })

+29 -7

server/handle_server_update_email.go

··· 11 11 type ComAtprotoServerUpdateEmailRequest struct { 12 12 Email string `json:"email" validate:"required"` 13 13 EmailAuthFactor bool `json:"emailAuthFactor"` 14 14 - Token string `json:"token" validate:"required"` 14 14 + Token string `json:"token"` 15 15 } 16 16 17 17 func (s *Server) handleServerUpdateEmail(e echo.Context) error { ··· 30 30 return helpers.InputError(e, nil) 31 31 } 32 32 33 33 - if urepo.EmailUpdateCode == nil || urepo.EmailUpdateCodeExpiresAt == nil { 33 33 + // To disable email auth factor a token is required. 34 34 + // To enable email auth factor a token is not required. 35 35 + // If updating an email address, a token will be sent anyway 36 36 + if urepo.TwoFactorType != models.TwoFactorTypeNone && req.EmailAuthFactor == false && req.Token == "" { 34 37 return helpers.InvalidTokenError(e) 35 38 } 36 39 37 37 - if *urepo.EmailUpdateCode != req.Token { 38 38 - return helpers.InvalidTokenError(e) 40 40 + if req.Token != "" { 41 41 + if urepo.EmailUpdateCode == nil || urepo.EmailUpdateCodeExpiresAt == nil { 42 42 + return helpers.InvalidTokenError(e) 43 43 + } 44 44 + 45 45 + if *urepo.EmailUpdateCode != req.Token { 46 46 + return helpers.InvalidTokenError(e) 47 47 + } 48 48 + 49 49 + if time.Now().UTC().After(*urepo.EmailUpdateCodeExpiresAt) { 50 50 + return helpers.ExpiredTokenError(e) 51 51 + } 39 52 } 40 53 41 41 - if time.Now().UTC().After(*urepo.EmailUpdateCodeExpiresAt) { 42 42 - return helpers.ExpiredTokenError(e) 54 54 + twoFactorType := models.TwoFactorTypeNone 55 55 + if req.EmailAuthFactor { 56 56 + twoFactorType = models.TwoFactorTypeEmail 43 57 } 44 58 45 45 - if err := s.db.Exec(ctx, "UPDATE repos SET email_update_code = NULL, email_update_code_expires_at = NULL, email_confirmed_at = NULL, email = ? WHERE did = ?", nil, req.Email, urepo.Repo.Did).Error; err != nil { 59 59 + query := "UPDATE repos SET email_update_code = NULL, email_update_code_expires_at = NULL, two_factor_type = ?, email = ?" 60 60 + 61 61 + if urepo.Email != req.Email { 62 62 + query += ",email_confirmed_at = NULL" 63 63 + } 64 64 + 65 65 + query += " WHERE did = ?" 66 66 + 67 67 + if err := s.db.Exec(ctx, query, nil, twoFactorType, req.Email, urepo.Repo.Did).Error; err != nil { 46 68 logger.Error("error updating repo", "error", err) 47 69 return helpers.ServerError(e, nil) 48 70 }

+5 -1

server/handle_sync_list_blobs.go

··· 59 59 60 60 var cstrs []string 61 61 for _, b := range blobs { 62 62 + if len(b.Cid) == 0 { 63 63 + logger.Error("empty cid found", "blob", b) 64 64 + continue 65 65 + } 62 66 c, err := cid.Cast(b.Cid) 63 67 if err != nil { 64 68 logger.Error("error casting cid", "error", err) 65 65 - return helpers.ServerError(e, nil) 69 69 + continue 66 70 } 67 71 cstrs = append(cstrs, c.String()) 68 72 }

+41 -9

server/handle_sync_subscribe_repos.go

··· 2 2 3 3 import ( 4 4 "context" 5 5 + "strconv" 5 6 "time" 6 7 7 8 "github.com/bluesky-social/indigo/events" ··· 12 13 ) 13 14 14 15 func (s *Server) handleSyncSubscribeRepos(e echo.Context) error { 15 15 - ctx := e.Request().Context() 16 16 + ctx, cancel := context.WithCancel(e.Request().Context()) 17 17 + defer cancel() 18 18 + 16 19 logger := s.logger.With("component", "subscribe-repos-websocket") 17 20 18 21 conn, err := websocket.Upgrade(e.Response().Writer, e.Request(), e.Response().Header(), 1<<10, 1<<10) ··· 25 28 logger = logger.With("ident", ident) 26 29 logger.Info("new connection established") 27 30 31 31 + var since *int64 32 32 + if cursorStr := e.QueryParam("cursor"); cursorStr != "" { 33 33 + cursor, err := strconv.ParseInt(cursorStr, 10, 64) 34 34 + if err != nil { 35 35 + logger.Warn("invalid cursor parameter", "cursor", cursorStr, "err", err) 36 36 + } else { 37 37 + since = &cursor 38 38 + logger.Info("subscribing with cursor", "cursor", cursor) 39 39 + } 40 40 + } 41 41 + 28 42 metrics.RelaysConnected.WithLabelValues(ident).Inc() 29 43 defer func() { 30 44 metrics.RelaysConnected.WithLabelValues(ident).Dec() 31 45 }() 32 46 33 33 - evts, cancel, err := s.evtman.Subscribe(ctx, ident, func(evt *events.XRPCStreamEvent) bool { 47 47 + evts, evtManCancel, err := s.evtman.Subscribe(ctx, ident, func(evt *events.XRPCStreamEvent) bool { 34 48 return true 35 35 - }, nil) 49 49 + }, since) 36 50 if err != nil { 37 51 return err 38 52 } 39 39 - defer cancel() 53 53 + defer evtManCancel() 54 54 + 55 55 + // drop the connection whenever a subscriber disconnects from the socket, we should get errors 56 56 + go func() { 57 57 + for { 58 58 + select { 59 59 + case <-ctx.Done(): 60 60 + return 61 61 + default: 62 62 + if _, _, err := conn.ReadMessage(); err != nil { 63 63 + logger.Warn("websocket error", "err", err) 64 64 + cancel() 65 65 + return 66 66 + } 67 67 + } 68 68 + } 69 69 + }() 40 70 41 71 header := events.EventHeader{Op: events.EvtKindMessage} 42 72 for evt := range evts { ··· 97 127 98 128 // we should tell the relay to request a new crawl at this point if we got disconnected 99 129 // use a new context since the old one might be cancelled at this point 100 100 - ctx, cancel = context.WithTimeout(context.Background(), 10*time.Second) 101 101 - defer cancel() 102 102 - if err := s.requestCrawl(ctx); err != nil { 103 103 - logger.Error("error requesting crawls", "err", err) 104 104 - } 130 130 + go func() { 131 131 + retryCtx, retryCancel := context.WithTimeout(context.Background(), 10*time.Second) 132 132 + defer retryCancel() 133 133 + if err := s.requestCrawl(retryCtx); err != nil { 134 134 + logger.Error("error requesting crawls", "err", err) 135 135 + } 136 136 + }() 105 137 106 138 return nil 107 139 }

+19

server/mail.go

··· 96 96 97 97 return nil 98 98 } 99 99 + 100 100 + func (s *Server) sendTwoFactorCode(email, handle, code string) error { 101 101 + if s.mail == nil { 102 102 + return nil 103 103 + } 104 104 + 105 105 + s.mailLk.Lock() 106 106 + defer s.mailLk.Unlock() 107 107 + 108 108 + s.mail.To(email) 109 109 + s.mail.Subject("2FA code for " + s.config.Hostname) 110 110 + s.mail.Plain().Set(fmt.Sprintf("Hello %s. Your 2FA code is %s. This code will expire in ten minutes.", handle, code)) 111 111 + 112 112 + if err := s.mail.Send(); err != nil { 113 113 + return err 114 114 + } 115 115 + 116 116 + return nil 117 117 + }

+243

server/persist.go

··· 1 1 + package server 2 2 + 3 3 + import ( 4 4 + "bytes" 5 5 + "context" 6 6 + "fmt" 7 7 + "sync" 8 8 + "time" 9 9 + 10 10 + "github.com/bluesky-social/indigo/api/atproto" 11 11 + "github.com/bluesky-social/indigo/events" 12 12 + indigomodels "github.com/bluesky-social/indigo/models" 13 13 + cbg "github.com/whyrusleeping/cbor-gen" 14 14 + "gorm.io/gorm" 15 15 + 16 16 + "github.com/haileyok/cocoon/models" 17 17 + ) 18 18 + 19 19 + type DbPersister struct { 20 20 + Db *gorm.DB 21 21 + 22 22 + Lk sync.Mutex 23 23 + Seq int64 24 24 + 25 25 + Broadcast func(*events.XRPCStreamEvent) 26 26 + 27 27 + // how long do we actually want to keep these things around 28 28 + Retention time.Duration 29 29 + } 30 30 + 31 31 + func NewDbPersister(db *gorm.DB, retention time.Duration) (*DbPersister, error) { 32 32 + if err := db.AutoMigrate(&models.EventRecord{}); err != nil { 33 33 + return nil, fmt.Errorf("failed to migrate EventRecord: %w", err) 34 34 + } 35 35 + 36 36 + if retention == 0 { 37 37 + retention = 72 * time.Hour 38 38 + } 39 39 + 40 40 + p := &DbPersister{ 41 41 + Db: db, 42 42 + Retention: retention, 43 43 + } 44 44 + 45 45 + // kind of hacky. we will try and get the latest one from the db, but if it doesn't exist...well we have a problem 46 46 + // because the relay will already have _some_ value > 0 set as a cursor, we'll want to just set this to some high value 47 47 + // we'll just grab a current unix timestamp and set that as the cursor 48 48 + var lastEvent models.EventRecord 49 49 + if err := db.Order("seq desc").Limit(1).First(&lastEvent).Error; err != nil { 50 50 + if err != gorm.ErrRecordNotFound { 51 51 + return nil, fmt.Errorf("failed to get last event seq: %w", err) 52 52 + } 53 53 + p.Seq = time.Now().Unix() 54 54 + } else { 55 55 + p.Seq = lastEvent.Seq 56 56 + } 57 57 + 58 58 + go p.cleanupRoutine() 59 59 + 60 60 + return p, nil 61 61 + } 62 62 + 63 63 + func (p *DbPersister) SetEventBroadcaster(brc func(*events.XRPCStreamEvent)) { 64 64 + p.Broadcast = brc 65 65 + } 66 66 + 67 67 + func (p *DbPersister) Persist(ctx context.Context, e *events.XRPCStreamEvent) error { 68 68 + p.Lk.Lock() 69 69 + defer p.Lk.Unlock() 70 70 + 71 71 + p.Seq++ 72 72 + seq := p.Seq 73 73 + 74 74 + var did string 75 75 + var evtType string 76 76 + 77 77 + switch { 78 78 + case e.RepoCommit != nil: 79 79 + e.RepoCommit.Seq = seq 80 80 + did = e.RepoCommit.Repo 81 81 + evtType = "commit" 82 82 + case e.RepoSync != nil: 83 83 + e.RepoSync.Seq = seq 84 84 + did = e.RepoSync.Did 85 85 + evtType = "sync" 86 86 + case e.RepoIdentity != nil: 87 87 + e.RepoIdentity.Seq = seq 88 88 + did = e.RepoIdentity.Did 89 89 + evtType = "identity" 90 90 + case e.RepoAccount != nil: 91 91 + e.RepoAccount.Seq = seq 92 92 + did = e.RepoAccount.Did 93 93 + evtType = "account" 94 94 + default: 95 95 + return fmt.Errorf("unknown event type") 96 96 + } 97 97 + 98 98 + data, err := serializeEvent(e) 99 99 + if err != nil { 100 100 + return fmt.Errorf("failed to serialize event: %w", err) 101 101 + } 102 102 + 103 103 + rec := &models.EventRecord{ 104 104 + Seq: seq, 105 105 + CreatedAt: time.Now(), 106 106 + Did: did, 107 107 + Type: evtType, 108 108 + Data: data, 109 109 + } 110 110 + 111 111 + if err := p.Db.Create(rec).Error; err != nil { 112 112 + return fmt.Errorf("failed to persist event: %w", err) 113 113 + } 114 114 + 115 115 + if p.Broadcast != nil { 116 116 + p.Broadcast(e) 117 117 + } 118 118 + 119 119 + return nil 120 120 + } 121 121 + 122 122 + func (p *DbPersister) Playback(ctx context.Context, since int64, cb func(*events.XRPCStreamEvent) error) error { 123 123 + const pageSize = 500 124 124 + 125 125 + cursor := since 126 126 + for { 127 127 + var records []models.EventRecord 128 128 + if err := p.Db.WithContext(ctx). 129 129 + Where("seq > ?", cursor). 130 130 + Order("seq asc"). 131 131 + Limit(pageSize). 132 132 + Find(&records).Error; err != nil { 133 133 + return fmt.Errorf("failed to query events: %w", err) 134 134 + } 135 135 + 136 136 + if len(records) == 0 { 137 137 + return nil 138 138 + } 139 139 + 140 140 + for _, rec := range records { 141 141 + evt, err := deserializeEvent(rec.Type, rec.Data) 142 142 + if err != nil { 143 143 + return fmt.Errorf("failed to deserialize event %d: %w", rec.Seq, err) 144 144 + } 145 145 + 146 146 + if err := cb(evt); err != nil { 147 147 + return err 148 148 + } 149 149 + 150 150 + cursor = rec.Seq 151 151 + } 152 152 + 153 153 + if len(records) < pageSize { 154 154 + return nil 155 155 + } 156 156 + } 157 157 + } 158 158 + 159 159 + func (p *DbPersister) TakeDownRepo(ctx context.Context, uid indigomodels.Uid) error { 160 160 + return nil 161 161 + } 162 162 + 163 163 + func (p *DbPersister) Flush(ctx context.Context) error { 164 164 + return nil 165 165 + } 166 166 + 167 167 + func (p *DbPersister) Shutdown(ctx context.Context) error { 168 168 + return nil 169 169 + } 170 170 + 171 171 + func (p *DbPersister) cleanupRoutine() { 172 172 + ticker := time.NewTicker(time.Hour) 173 173 + defer ticker.Stop() 174 174 + 175 175 + for range ticker.C { 176 176 + cutoff := time.Now().Add(-p.Retention) 177 177 + if err := p.Db.Where("created_at < ?", cutoff).Delete(&models.EventRecord{}).Error; err != nil { 178 178 + continue 179 179 + } 180 180 + } 181 181 + } 182 182 + 183 183 + func serializeEvent(e *events.XRPCStreamEvent) ([]byte, error) { 184 184 + buf := new(bytes.Buffer) 185 185 + cw := cbg.NewCborWriter(buf) 186 186 + 187 187 + switch { 188 188 + case e.RepoCommit != nil: 189 189 + if err := e.RepoCommit.MarshalCBOR(cw); err != nil { 190 190 + return nil, err 191 191 + } 192 192 + case e.RepoSync != nil: 193 193 + if err := e.RepoSync.MarshalCBOR(cw); err != nil { 194 194 + return nil, err 195 195 + } 196 196 + case e.RepoIdentity != nil: 197 197 + if err := e.RepoIdentity.MarshalCBOR(cw); err != nil { 198 198 + return nil, err 199 199 + } 200 200 + case e.RepoAccount != nil: 201 201 + if err := e.RepoAccount.MarshalCBOR(cw); err != nil { 202 202 + return nil, err 203 203 + } 204 204 + default: 205 205 + return nil, fmt.Errorf("unknown event type") 206 206 + } 207 207 + 208 208 + return buf.Bytes(), nil 209 209 + } 210 210 + 211 211 + func deserializeEvent(evtType string, data []byte) (*events.XRPCStreamEvent, error) { 212 212 + r := bytes.NewReader(data) 213 213 + cr := cbg.NewCborReader(r) 214 214 + 215 215 + switch evtType { 216 216 + case "commit": 217 217 + evt := &atproto.SyncSubscribeRepos_Commit{} 218 218 + if err := evt.UnmarshalCBOR(cr); err != nil { 219 219 + return nil, err 220 220 + } 221 221 + return &events.XRPCStreamEvent{RepoCommit: evt}, nil 222 222 + case "sync": 223 223 + evt := &atproto.SyncSubscribeRepos_Sync{} 224 224 + if err := evt.UnmarshalCBOR(cr); err != nil { 225 225 + return nil, err 226 226 + } 227 227 + return &events.XRPCStreamEvent{RepoSync: evt}, nil 228 228 + case "identity": 229 229 + evt := &atproto.SyncSubscribeRepos_Identity{} 230 230 + if err := evt.UnmarshalCBOR(cr); err != nil { 231 231 + return nil, err 232 232 + } 233 233 + return &events.XRPCStreamEvent{RepoIdentity: evt}, nil 234 234 + case "account": 235 235 + evt := &atproto.SyncSubscribeRepos_Account{} 236 236 + if err := evt.UnmarshalCBOR(cr); err != nil { 237 237 + return nil, err 238 238 + } 239 239 + return &events.XRPCStreamEvent{RepoAccount: evt}, nil 240 240 + default: 241 241 + return nil, fmt.Errorf("unknown event type: %s", evtType) 242 242 + } 243 243 + }

+1 -1

server/repo.go

··· 39 39 return &RepoMan{ 40 40 s: s, 41 41 db: s.db, 42 42 - clock: &clock, 42 42 + clock: clock, 43 43 } 44 44 } 45 45

+82 -53

server/server.go

··· 92 92 type Args struct { 93 93 Logger *slog.Logger 94 94 95 95 + LogLevel slog.Level 95 96 Addr string 96 97 DbName string 97 98 DbType string ··· 115 116 116 117 S3Config *S3Config 117 118 118 118 - SessionSecret string 119 119 + SessionSecret string 120 120 + SessionCookieKey string 119 121 120 122 BlockstoreVariant BlockstoreVariant 121 123 FallbackProxy string 122 124 } 123 125 124 126 type config struct { 127 127 + LogLevel slog.Level 125 128 Version string 126 129 Did string 127 130 Hostname string ··· 132 135 RequireInvite bool 133 136 SmtpEmail string 134 137 SmtpName string 138 138 + SessionCookieKey string 135 139 BlockstoreVariant BlockstoreVariant 136 140 FallbackProxy string 137 141 } ··· 210 214 return t.templates.ExecuteTemplate(w, name, data) 211 215 } 212 216 217 217 + type filteredHandler struct { 218 218 + level slog.Level 219 219 + handler slog.Handler 220 220 + } 221 221 + 222 222 + func (h *filteredHandler) Enabled(ctx context.Context, level slog.Level) bool { 223 223 + return level >= h.level && h.handler.Enabled(ctx, level) 224 224 + } 225 225 + 226 226 + func (h *filteredHandler) Handle(ctx context.Context, r slog.Record) error { 227 227 + return h.handler.Handle(ctx, r) 228 228 + } 229 229 + 230 230 + func (h *filteredHandler) WithAttrs(attrs []slog.Attr) slog.Handler { 231 231 + return &filteredHandler{level: h.level, handler: h.handler.WithAttrs(attrs)} 232 232 + } 233 233 + 234 234 + func (h *filteredHandler) WithGroup(name string) slog.Handler { 235 235 + return &filteredHandler{level: h.level, handler: h.handler.WithGroup(name)} 236 236 + } 237 237 + 213 238 func New(args *Args) (*Server, error) { 214 239 if args.Logger == nil { 215 240 args.Logger = slog.Default() 241 241 + } 242 242 + 243 243 + if args.LogLevel != 0 { 244 244 + args.Logger = slog.New(&filteredHandler{ 245 245 + level: args.LogLevel, 246 246 + handler: args.Logger.Handler(), 247 247 + }) 216 248 } 217 249 218 250 logger := args.Logger.With("name", "New") ··· 322 354 if err != nil { 323 355 return nil, fmt.Errorf("failed to open sqlite database: %w", err) 324 356 } 357 357 + gdb.Exec("PRAGMA journal_mode=WAL") 358 358 + gdb.Exec("PRAGMA synchronous=NORMAL") 359 359 + 325 360 logger.Info("connected to SQLite database", "path", args.DbName) 326 361 } 327 362 dbw := db.NewDB(gdb) ··· 370 405 nonceSecret = maybeSecret 371 406 } 372 407 408 408 + evtPersister, err := NewDbPersister(gdb, 72*time.Hour) 409 409 + if err != nil { 410 410 + return nil, fmt.Errorf("failed to create event persister: %w", err) 411 411 + } 412 412 + 373 413 s := &Server{ 374 414 http: h, 375 415 httpd: httpd, ··· 379 419 plcClient: plcClient, 380 420 privateKey: &pkey, 381 421 config: &config{ 422 422 + LogLevel: args.LogLevel, 382 423 Version: args.Version, 383 424 Did: args.Did, 384 425 Hostname: args.Hostname, ··· 389 430 RequireInvite: args.RequireInvite, 390 431 SmtpName: args.SmtpName, 391 432 SmtpEmail: args.SmtpEmail, 433 433 + SessionCookieKey: args.SessionCookieKey, 392 434 BlockstoreVariant: args.BlockstoreVariant, 393 435 FallbackProxy: args.FallbackProxy, 394 436 }, 395 395 - evtman: events.NewEventManager(events.NewMemPersister()), 437 437 + evtman: events.NewEventManager(evtPersister), 396 438 passport: identity.NewPassport(h, identity.NewMemCache(10_000)), 397 439 398 440 dbName: args.DbName, ··· 529 571 s.echo.GET("/xrpc/app.bsky.actor.getPreferences", s.handleActorGetPreferences, s.handleLegacySessionMiddleware, s.handleOauthSessionMiddleware) 530 572 s.echo.POST("/xrpc/app.bsky.actor.putPreferences", s.handleActorPutPreferences, s.handleLegacySessionMiddleware, s.handleOauthSessionMiddleware) 531 573 s.echo.GET("/xrpc/app.bsky.feed.getFeed", s.handleProxyBskyFeedGetFeed, s.handleLegacySessionMiddleware, s.handleOauthSessionMiddleware) 532 532 - 574 574 + s.echo.GET("/xrpc/app.bsky.ageassurance.getState", s.handleAgeAssurance, s.handleLegacySessionMiddleware, s.handleOauthSessionMiddleware) 533 575 // admin routes 534 576 s.echo.POST("/xrpc/com.atproto.server.createInviteCode", s.handleCreateInviteCode, s.handleAdminMiddleware) 535 577 s.echo.POST("/xrpc/com.atproto.server.createInviteCodes", s.handleCreateInviteCodes, s.handleAdminMiddleware) ··· 625 667 626 668 logger.Info("beginning backup to s3...") 627 669 628 628 - var buf bytes.Buffer 629 629 - if err := func() error { 630 630 - logger.Info("reading database bytes...") 631 631 - s.db.Lock() 632 632 - defer s.db.Unlock() 670 670 + tmpFile := fmt.Sprintf("/tmp/cocoon-backup-%s.db", time.Now().Format(time.RFC3339Nano)) 671 671 + defer os.Remove(tmpFile) 633 672 634 634 - sf, err := os.Open(s.dbName) 635 635 - if err != nil { 636 636 - return fmt.Errorf("error opening database for backup: %w", err) 637 637 - } 638 638 - defer sf.Close() 673 673 + if err := s.db.Client().Exec(fmt.Sprintf("VACUUM INTO '%s'", tmpFile)).Error; err != nil { 674 674 + logger.Error("error creating tmp backup file", "err", err) 675 675 + return 676 676 + } 639 677 640 640 - if _, err := io.Copy(&buf, sf); err != nil { 641 641 - return fmt.Errorf("error reading bytes of backup db: %w", err) 642 642 - } 643 643 - 644 644 - return nil 645 645 - }(); err != nil { 646 646 - logger.Error("error backing up database", "error", err) 678 678 + backupData, err := os.ReadFile(tmpFile) 679 679 + if err != nil { 680 680 + logger.Error("error reading tmp backup file", "err", err) 647 681 return 648 682 } 649 683 650 650 - if err := func() error { 651 651 - logger.Info("sending to s3...") 684 684 + logger.Info("sending to s3...") 652 685 653 653 - currTime := time.Now().Format("2006-01-02_15-04-05") 654 654 - key := "cocoon-backup-" + currTime + ".db" 686 686 + currTime := time.Now().Format("2006-01-02_15-04-05") 687 687 + key := "cocoon-backup-" + currTime + ".db" 655 688 656 656 - config := &aws.Config{ 657 657 - Region: aws.String(s.s3Config.Region), 658 658 - Credentials: credentials.NewStaticCredentials(s.s3Config.AccessKey, s.s3Config.SecretKey, ""), 659 659 - } 689 689 + config := &aws.Config{ 690 690 + Region: aws.String(s.s3Config.Region), 691 691 + Credentials: credentials.NewStaticCredentials(s.s3Config.AccessKey, s.s3Config.SecretKey, ""), 692 692 + } 660 693 661 661 - if s.s3Config.Endpoint != "" { 662 662 - config.Endpoint = aws.String(s.s3Config.Endpoint) 663 663 - config.S3ForcePathStyle = aws.Bool(true) 664 664 - } 694 694 + if s.s3Config.Endpoint != "" { 695 695 + config.Endpoint = aws.String(s.s3Config.Endpoint) 696 696 + config.S3ForcePathStyle = aws.Bool(true) 697 697 + } 665 698 666 666 - sess, err := session.NewSession(config) 667 667 - if err != nil { 668 668 - return err 669 669 - } 699 699 + sess, err := session.NewSession(config) 700 700 + if err != nil { 701 701 + logger.Error("error creating s3 session", "err", err) 702 702 + return 703 703 + } 670 704 671 671 - svc := s3.New(sess) 705 705 + svc := s3.New(sess) 672 706 673 673 - if _, err := svc.PutObject(&s3.PutObjectInput{ 674 674 - Bucket: aws.String(s.s3Config.Bucket), 675 675 - Key: aws.String(key), 676 676 - Body: bytes.NewReader(buf.Bytes()), 677 677 - }); err != nil { 678 678 - return fmt.Errorf("error uploading file to s3: %w", err) 679 679 - } 680 680 - 681 681 - logger.Info("finished uploading backup to s3", "key", key, "duration", time.Now().Sub(start).Seconds()) 682 682 - 683 683 - return nil 684 684 - }(); err != nil { 685 685 - logger.Error("error uploading database backup", "error", err) 707 707 + if _, err := svc.PutObject(&s3.PutObjectInput{ 708 708 + Bucket: aws.String(s.s3Config.Bucket), 709 709 + Key: aws.String(key), 710 710 + Body: bytes.NewReader(backupData), 711 711 + }); err != nil { 712 712 + logger.Error("error uploading file to s3", "err", err) 686 713 return 687 714 } 688 715 689 689 - os.WriteFile("last-backup.txt", []byte(time.Now().String()), 0644) 716 716 + logger.Info("finished uploading backup to s3", "key", key, "duration", time.Since(start).Seconds()) 717 717 + 718 718 + os.WriteFile("last-backup.txt", []byte(time.Now().Format(time.RFC3339Nano)), 0644) 690 719 } 691 720 692 721 func (s *Server) backupRoutine() { ··· 721 750 if err != nil { 722 751 shouldBackupNow = true 723 752 } else { 724 724 - lastBackup, err := time.Parse("2006-01-02 15:04:05.999999999 -0700 MST", string(lastBackupStr)) 753 753 + lastBackup, err := time.Parse(time.RFC3339Nano, string(lastBackupStr)) 725 754 if err != nil { 726 755 shouldBackupNow = true 727 727 - } else if time.Now().Sub(lastBackup).Seconds() > 3600 { 756 756 + } else if time.Since(lastBackup).Seconds() > 3600 { 728 757 shouldBackupNow = true 729 758 } 730 759 }

+10 -10

server/service_auth.go

··· 44 44 45 45 parsedToken, err := jwt.ParseWithClaims(token, jwt.MapClaims{}, func(token *jwt.Token) (interface{}, error) { 46 46 did := syntax.DID(token.Claims.(jwt.MapClaims)["iss"].(string)) 47 47 - didDoc, err := s.passport.FetchDoc(ctx, did.String()); 47 47 + didDoc, err := s.passport.FetchDoc(ctx, did.String()) 48 48 if err != nil { 49 49 return nil, fmt.Errorf("unable to resolve did %s: %s", did, err) 50 50 } ··· 52 52 verificationMethods := make([]atproto_identity.DocVerificationMethod, len(didDoc.VerificationMethods)) 53 53 for i, verificationMethod := range didDoc.VerificationMethods { 54 54 verificationMethods[i] = atproto_identity.DocVerificationMethod{ 55 55 - ID: verificationMethod.Id, 56 56 - Type: verificationMethod.Type, 55 55 + ID: verificationMethod.Id, 56 56 + Type: verificationMethod.Type, 57 57 PublicKeyMultibase: verificationMethod.PublicKeyMultibase, 58 58 - Controller: verificationMethod.Controller, 58 58 + Controller: verificationMethod.Controller, 59 59 } 60 60 } 61 61 services := make([]atproto_identity.DocService, len(didDoc.Service)) 62 62 for i, service := range didDoc.Service { 63 63 services[i] = atproto_identity.DocService{ 64 64 - ID: service.Id, 65 65 - Type: service.Type, 64 64 + ID: service.Id, 65 65 + Type: service.Type, 66 66 ServiceEndpoint: service.ServiceEndpoint, 67 67 } 68 68 } 69 69 parsedIdentity := atproto_identity.ParseIdentity(&identity.DIDDocument{ 70 70 - DID: did, 71 71 - AlsoKnownAs: didDoc.AlsoKnownAs, 70 70 + DID: did, 71 71 + AlsoKnownAs: didDoc.AlsoKnownAs, 72 72 VerificationMethod: verificationMethods, 73 73 - Service: services, 73 73 + Service: services, 74 74 }) 75 75 76 76 key, err := parsedIdentity.PublicKey() ··· 88 88 return "", fmt.Errorf("bad jwt lexicon method (\"lxm\"). must match: %s", nsid) 89 89 } 90 90 return claims["iss"].(string), nil 91 91 - } 91 91 + }

+4

server/templates/signin.html

··· 26 26 type="password" 27 27 placeholder="Password" 28 28 /> 29 29 + {{ if .flashes.tokenrequired }} 30 30 + <br /> 31 31 + <input name="token" id="token" placeholder="Enter your 2FA token" /> 32 32 + {{ end }} 29 33 <input name="query_params" type="hidden" value="{{ .QueryParams }}" /> 30 34 <button class="primary" type="submit" value="Login">Login</button> 31 35 </form>

+1 -1

sqlite_blockstore/sqlite_blockstore.go

··· 94 94 } 95 95 96 96 func (bs *SqliteBlockstore) PutMany(ctx context.Context, blocks []blocks.Block) error { 97 97 - tx := bs.db.BeginDangerously(ctx) 97 97 + tx := bs.db.Begin(ctx) 98 98 99 99 for _, block := range blocks { 100 100 bs.inserts[block.Cid()] = block