···
···
205
-
func (s *State) RegistrationKey(w http.ResponseWriter, r *http.Request) {
207
-
case http.MethodGet:
208
-
// list open registrations under this did
211
-
case http.MethodPost:
212
-
session, err := s.oauth.Stores().Get(r, oauth.SessionName)
213
-
if err != nil || session.IsNew {
214
-
log.Println("unauthorized attempt to generate registration key")
215
-
http.Error(w, "Forbidden", http.StatusUnauthorized)
219
-
did := session.Values[oauth.SessionDid].(string)
221
-
// check if domain is valid url, and strip extra bits down to just host
222
-
domain := r.FormValue("domain")
224
-
http.Error(w, "Invalid form", http.StatusBadRequest)
228
-
key, err := db.GenerateRegistrationKey(s.db, domain, did)
232
-
http.Error(w, "unable to register this domain", http.StatusNotAcceptable)
236
-
w.Write([]byte(key))
202
+
// func (s *State) RegistrationKey(w http.ResponseWriter, r *http.Request) {
203
+
// switch r.Method {
204
+
// case http.MethodGet:
205
+
// // list open registrations under this did
208
+
// case http.MethodPost:
209
+
// session, err := s.oauth.Stores().Get(r, oauth.SessionName)
210
+
// if err != nil || session.IsNew {
211
+
// log.Println("unauthorized attempt to generate registration key")
212
+
// http.Error(w, "Forbidden", http.StatusUnauthorized)
216
+
// did := session.Values[oauth.SessionDid].(string)
218
+
// // check if domain is valid url, and strip extra bits down to just host
219
+
// domain := r.FormValue("domain")
220
+
// if domain == "" {
221
+
// http.Error(w, "Invalid form", http.StatusBadRequest)
225
+
// key, err := db.GenerateRegistrationKey(s.db, domain, did)
228
+
// log.Println(err)
229
+
// http.Error(w, "unable to register this domain", http.StatusNotAcceptable)
233
+
// w.Write([]byte(key))
func (s *State) Keys(w http.ResponseWriter, r *http.Request) {
user := chi.URLParam(r, "user")
···
// create a signed request and check if a node responds to that
273
-
func (s *State) InitKnotServer(w http.ResponseWriter, r *http.Request) {
274
-
user := s.oauth.GetUser(r)
276
-
domain := chi.URLParam(r, "domain")
278
-
http.Error(w, "malformed url", http.StatusBadRequest)
281
-
log.Println("checking ", domain)
283
-
secret, err := db.GetRegistrationKey(s.db, domain)
285
-
log.Printf("no key found for domain %s: %s\n", domain, err)
289
-
client, err := knotclient.NewSignedClient(domain, secret, s.config.Core.Dev)
291
-
log.Println("failed to create client to ", domain)
294
-
resp, err := client.Init(user.Did)
296
-
w.Write([]byte("no dice"))
297
-
log.Println("domain was unreachable after 5 seconds")
301
-
if resp.StatusCode == http.StatusConflict {
302
-
log.Println("status conflict", resp.StatusCode)
303
-
w.Write([]byte("already registered, sorry!"))
307
-
if resp.StatusCode != http.StatusNoContent {
308
-
log.Println("status nok", resp.StatusCode)
309
-
w.Write([]byte("no dice"))
313
-
// verify response mac
314
-
signature := resp.Header.Get("X-Signature")
315
-
signatureBytes, err := hex.DecodeString(signature)
320
-
expectedMac := hmac.New(sha256.New, []byte(secret))
321
-
expectedMac.Write([]byte("ok"))
323
-
if !hmac.Equal(expectedMac.Sum(nil), signatureBytes) {
324
-
log.Printf("response body signature mismatch: %x\n", signatureBytes)
328
-
tx, err := s.db.BeginTx(r.Context(), nil)
330
-
log.Println("failed to start tx", err)
331
-
http.Error(w, err.Error(), http.StatusInternalServerError)
336
-
err = s.enforcer.E.LoadPolicy()
338
-
log.Println("failed to rollback policies")
342
-
// mark as registered
343
-
err = db.Register(tx, domain)
345
-
log.Println("failed to register domain", err)
346
-
http.Error(w, err.Error(), http.StatusInternalServerError)
350
-
// set permissions for this did as owner
351
-
reg, err := db.RegistrationByDomain(tx, domain)
353
-
log.Println("failed to register domain", err)
354
-
http.Error(w, err.Error(), http.StatusInternalServerError)
358
-
// add basic acls for this domain
359
-
err = s.enforcer.AddKnot(domain)
361
-
log.Println("failed to setup owner of domain", err)
362
-
http.Error(w, err.Error(), http.StatusInternalServerError)
366
-
// add this did as owner of this domain
367
-
err = s.enforcer.AddKnotOwner(domain, reg.ByDid)
369
-
log.Println("failed to setup owner of domain", err)
370
-
http.Error(w, err.Error(), http.StatusInternalServerError)
376
-
log.Println("failed to commit changes", err)
377
-
http.Error(w, err.Error(), http.StatusInternalServerError)
381
-
err = s.enforcer.E.SavePolicy()
383
-
log.Println("failed to update ACLs", err)
384
-
http.Error(w, err.Error(), http.StatusInternalServerError)
388
-
// add this knot to knotstream
389
-
go s.knotstream.AddSource(
390
-
context.Background(),
391
-
eventconsumer.NewKnotSource(domain),
394
-
w.Write([]byte("check success"))
397
-
func (s *State) KnotServerInfo(w http.ResponseWriter, r *http.Request) {
398
-
domain := chi.URLParam(r, "domain")
400
-
http.Error(w, "malformed url", http.StatusBadRequest)
404
-
user := s.oauth.GetUser(r)
405
-
reg, err := db.RegistrationByDomain(s.db, domain)
407
-
w.Write([]byte("failed to pull up registration info"))
411
-
var members []string
412
-
if reg.Registered != nil {
413
-
members, err = s.enforcer.GetUserByRole("server:member", domain)
415
-
w.Write([]byte("failed to fetch member list"))
420
-
var didsToResolve []string
421
-
for _, m := range members {
422
-
didsToResolve = append(didsToResolve, m)
424
-
didsToResolve = append(didsToResolve, reg.ByDid)
425
-
resolvedIds := s.idResolver.ResolveIdents(r.Context(), didsToResolve)
426
-
didHandleMap := make(map[string]string)
427
-
for _, identity := range resolvedIds {
428
-
if !identity.Handle.IsInvalidHandle() {
429
-
didHandleMap[identity.DID.String()] = fmt.Sprintf("@%s", identity.Handle.String())
431
-
didHandleMap[identity.DID.String()] = identity.DID.String()
435
-
ok, err := s.enforcer.IsKnotOwner(user.Did, domain)
436
-
isOwner := err == nil && ok
438
-
p := pages.KnotParams{
439
-
LoggedInUser: user,
440
-
DidHandleMap: didHandleMap,
270
+
// func (s *State) InitKnotServer(w http.ResponseWriter, r *http.Request) {
271
+
// user := s.oauth.GetUser(r)
273
+
// noticeId := "operation-error"
274
+
// defaultErr := "Failed to register spindle. Try again later."
275
+
// fail := func() {
276
+
// s.pages.Notice(w, noticeId, defaultErr)
279
+
// domain := chi.URLParam(r, "domain")
280
+
// if domain == "" {
281
+
// http.Error(w, "malformed url", http.StatusBadRequest)
284
+
// log.Println("checking ", domain)
286
+
// secret, err := db.GetRegistrationKey(s.db, domain)
288
+
// log.Printf("no key found for domain %s: %s\n", domain, err)
292
+
// client, err := knotclient.NewSignedClient(domain, secret, s.config.Core.Dev)
294
+
// log.Println("failed to create client to ", domain)
297
+
// resp, err := client.Init(user.Did)
299
+
// w.Write([]byte("no dice"))
300
+
// log.Println("domain was unreachable after 5 seconds")
304
+
// if resp.StatusCode == http.StatusConflict {
305
+
// log.Println("status conflict", resp.StatusCode)
306
+
// w.Write([]byte("already registered, sorry!"))
310
+
// if resp.StatusCode != http.StatusNoContent {
311
+
// log.Println("status nok", resp.StatusCode)
312
+
// w.Write([]byte("no dice"))
316
+
// // verify response mac
317
+
// signature := resp.Header.Get("X-Signature")
318
+
// signatureBytes, err := hex.DecodeString(signature)
323
+
// expectedMac := hmac.New(sha256.New, []byte(secret))
324
+
// expectedMac.Write([]byte("ok"))
326
+
// if !hmac.Equal(expectedMac.Sum(nil), signatureBytes) {
327
+
// log.Printf("response body signature mismatch: %x\n", signatureBytes)
331
+
// tx, err := s.db.BeginTx(r.Context(), nil)
333
+
// log.Println("failed to start tx", err)
334
+
// http.Error(w, err.Error(), http.StatusInternalServerError)
339
+
// err = s.enforcer.E.LoadPolicy()
341
+
// log.Println("failed to rollback policies")
345
+
// // mark as registered
346
+
// err = db.Register(tx, domain)
348
+
// log.Println("failed to register domain", err)
349
+
// http.Error(w, err.Error(), http.StatusInternalServerError)
353
+
// // set permissions for this did as owner
354
+
// reg, err := db.RegistrationByDomain(tx, domain)
356
+
// log.Println("failed to register domain", err)
357
+
// http.Error(w, err.Error(), http.StatusInternalServerError)
361
+
// // add basic acls for this domain
362
+
// err = s.enforcer.AddKnot(domain)
364
+
// log.Println("failed to setup owner of domain", err)
365
+
// http.Error(w, err.Error(), http.StatusInternalServerError)
369
+
// // add this did as owner of this domain
370
+
// err = s.enforcer.AddKnotOwner(domain, reg.ByDid)
372
+
// log.Println("failed to setup owner of domain", err)
373
+
// http.Error(w, err.Error(), http.StatusInternalServerError)
377
+
// err = tx.Commit()
379
+
// log.Println("failed to commit changes", err)
380
+
// http.Error(w, err.Error(), http.StatusInternalServerError)
384
+
// err = s.enforcer.E.SavePolicy()
386
+
// log.Println("failed to update ACLs", err)
387
+
// http.Error(w, err.Error(), http.StatusInternalServerError)
391
+
// // add this knot to knotstream
392
+
// go s.knotstream.AddSource(
393
+
// context.Background(),
394
+
// eventconsumer.NewKnotSource(domain),
397
+
// w.Write([]byte("check success"))
400
+
// func (s *State) KnotServerInfo(w http.ResponseWriter, r *http.Request) {
401
+
// domain := chi.URLParam(r, "domain")
402
+
// if domain == "" {
403
+
// http.Error(w, "malformed url", http.StatusBadRequest)
407
+
// user := s.oauth.GetUser(r)
408
+
// reg, err := db.RegistrationByDomain(s.db, domain)
410
+
// w.Write([]byte("failed to pull up registration info"))
414
+
// var members []string
415
+
// if reg.Registered != nil {
416
+
// members, err = s.enforcer.GetUserByRole("server:member", domain)
418
+
// w.Write([]byte("failed to fetch member list"))
423
+
// var didsToResolve []string
424
+
// for _, m := range members {
425
+
// didsToResolve = append(didsToResolve, m)
427
+
// didsToResolve = append(didsToResolve, reg.ByDid)
428
+
// resolvedIds := s.idResolver.ResolveIdents(r.Context(), didsToResolve)
429
+
// didHandleMap := make(map[string]string)
430
+
// for _, identity := range resolvedIds {
431
+
// if !identity.Handle.IsInvalidHandle() {
432
+
// didHandleMap[identity.DID.String()] = fmt.Sprintf("@%s", identity.Handle.String())
434
+
// didHandleMap[identity.DID.String()] = identity.DID.String()
438
+
// ok, err := s.enforcer.IsKnotOwner(user.Did, domain)
439
+
// isOwner := err == nil && ok
441
+
// p := pages.KnotParams{
442
+
// LoggedInUser: user,
443
+
// DidHandleMap: didHandleMap,
444
+
// Registration: reg,
445
+
// Members: members,
446
+
// IsOwner: isOwner,
449
+
// s.pages.Knot(w, p)
// get knots registered by this user
450
-
func (s *State) Knots(w http.ResponseWriter, r *http.Request) {
451
-
// for now, this is just pubkeys
452
-
user := s.oauth.GetUser(r)
453
-
registrations, err := db.RegistrationsByDid(s.db, user.Did)
458
-
s.pages.Knots(w, pages.KnotsParams{
459
-
LoggedInUser: user,
460
-
Registrations: registrations,
453
+
// func (s *State) Knots(w http.ResponseWriter, r *http.Request) {
454
+
// // for now, this is just pubkeys
455
+
// user := s.oauth.GetUser(r)
456
+
// registrations, err := db.RegistrationsByDid(s.db, user.Did)
458
+
// log.Println(err)
461
+
// s.pages.Knots(w, pages.KnotsParams{
462
+
// LoggedInUser: user,
463
+
// Registrations: registrations,
// list members of domain, requires auth and requires owner status
465
-
func (s *State) ListMembers(w http.ResponseWriter, r *http.Request) {
466
-
domain := chi.URLParam(r, "domain")
468
-
http.Error(w, "malformed url", http.StatusBadRequest)
472
-
// list all members for this domain
473
-
memberDids, err := s.enforcer.GetUserByRole("server:member", domain)
475
-
w.Write([]byte("failed to fetch member list"))
479
-
w.Write([]byte(strings.Join(memberDids, "\n")))
468
+
// func (s *State) ListMembers(w http.ResponseWriter, r *http.Request) {
469
+
// domain := chi.URLParam(r, "domain")
470
+
// if domain == "" {
471
+
// http.Error(w, "malformed url", http.StatusBadRequest)
475
+
// // list all members for this domain
476
+
// memberDids, err := s.enforcer.GetUserByRole("server:member", domain)
478
+
// w.Write([]byte("failed to fetch member list"))
482
+
// w.Write([]byte(strings.Join(memberDids, "\n")))
// add member to domain, requires auth and requires invite access
484
-
func (s *State) AddMember(w http.ResponseWriter, r *http.Request) {
485
-
domain := chi.URLParam(r, "domain")
487
-
http.Error(w, "malformed url", http.StatusBadRequest)
491
-
subjectIdentifier := r.FormValue("subject")
492
-
if subjectIdentifier == "" {
493
-
http.Error(w, "malformed form", http.StatusBadRequest)
497
-
subjectIdentity, err := s.idResolver.ResolveIdent(r.Context(), subjectIdentifier)
499
-
w.Write([]byte("failed to resolve member did to a handle"))
502
-
log.Printf("adding %s to %s\n", subjectIdentity.Handle.String(), domain)
504
-
// announce this relation into the firehose, store into owners' pds
505
-
client, err := s.oauth.AuthorizedClient(r)
507
-
http.Error(w, "failed to authorize client", http.StatusInternalServerError)
510
-
currentUser := s.oauth.GetUser(r)
511
-
createdAt := time.Now().Format(time.RFC3339)
512
-
resp, err := client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{
513
-
Collection: tangled.KnotMemberNSID,
514
-
Repo: currentUser.Did,
515
-
Rkey: appview.TID(),
516
-
Record: &lexutil.LexiconTypeDecoder{
517
-
Val: &tangled.KnotMember{
518
-
Subject: subjectIdentity.DID.String(),
520
-
CreatedAt: createdAt,
526
-
log.Printf("failed to create record: %s", err)
529
-
log.Println("created atproto record: ", resp.Uri)
531
-
secret, err := db.GetRegistrationKey(s.db, domain)
533
-
log.Printf("no key found for domain %s: %s\n", domain, err)
537
-
ksClient, err := knotclient.NewSignedClient(domain, secret, s.config.Core.Dev)
539
-
log.Println("failed to create client to ", domain)
543
-
ksResp, err := ksClient.AddMember(subjectIdentity.DID.String())
545
-
log.Printf("failed to make request to %s: %s", domain, err)
549
-
if ksResp.StatusCode != http.StatusNoContent {
550
-
w.Write([]byte(fmt.Sprint("knotserver failed to add member: ", err)))
554
-
err = s.enforcer.AddKnotMember(domain, subjectIdentity.DID.String())
556
-
w.Write([]byte(fmt.Sprint("failed to add member: ", err)))
560
-
w.Write([]byte(fmt.Sprint("added member: ", subjectIdentity.Handle.String())))
563
-
func (s *State) RemoveMember(w http.ResponseWriter, r *http.Request) {
487
+
// func (s *State) AddMember(w http.ResponseWriter, r *http.Request) {
488
+
// domain := chi.URLParam(r, "domain")
489
+
// if domain == "" {
490
+
// http.Error(w, "malformed url", http.StatusBadRequest)
494
+
// subjectIdentifier := r.FormValue("subject")
495
+
// if subjectIdentifier == "" {
496
+
// http.Error(w, "malformed form", http.StatusBadRequest)
500
+
// subjectIdentity, err := s.idResolver.ResolveIdent(r.Context(), subjectIdentifier)
502
+
// w.Write([]byte("failed to resolve member did to a handle"))
505
+
// log.Printf("adding %s to %s\n", subjectIdentity.Handle.String(), domain)
507
+
// // announce this relation into the firehose, store into owners' pds
508
+
// client, err := s.oauth.AuthorizedClient(r)
510
+
// http.Error(w, "failed to authorize client", http.StatusInternalServerError)
513
+
// currentUser := s.oauth.GetUser(r)
514
+
// createdAt := time.Now().Format(time.RFC3339)
515
+
// resp, err := client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{
516
+
// Collection: tangled.KnotMemberNSID,
517
+
// Repo: currentUser.Did,
518
+
// Rkey: appview.TID(),
519
+
// Record: &lexutil.LexiconTypeDecoder{
520
+
// Val: &tangled.KnotMember{
521
+
// Subject: subjectIdentity.DID.String(),
523
+
// CreatedAt: createdAt,
527
+
// // invalid record
529
+
// log.Printf("failed to create record: %s", err)
532
+
// log.Println("created atproto record: ", resp.Uri)
534
+
// secret, err := db.GetRegistrationKey(s.db, domain)
536
+
// log.Printf("no key found for domain %s: %s\n", domain, err)
540
+
// ksClient, err := knotclient.NewSignedClient(domain, secret, s.config.Core.Dev)
542
+
// log.Println("failed to create client to ", domain)
546
+
// ksResp, err := ksClient.AddMember(subjectIdentity.DID.String())
548
+
// log.Printf("failed to make request to %s: %s", domain, err)
552
+
// if ksResp.StatusCode != http.StatusNoContent {
553
+
// w.Write([]byte(fmt.Sprint("knotserver failed to add member: ", err)))
557
+
// err = s.enforcer.AddKnotMember(domain, subjectIdentity.DID.String())
559
+
// w.Write([]byte(fmt.Sprint("failed to add member: ", err)))
563
+
// w.Write([]byte(fmt.Sprint("added member: ", subjectIdentity.Handle.String())))
566
+
// func (s *State) RemoveMember(w http.ResponseWriter, r *http.Request) {
func validateRepoName(name string) error {
// check for path traversal attempts
oppi.li