-
10 | {{range .Flashes}}
11 |
- {{.Message}} 14 | {{end}} 15 |
10 |
12 | Error #{{.StatusCode}} - {{.Status}}
11 |
13 |
20 | {{end}}
--------------------------------------------------------------------------------
/internal/randutil/string.go:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | package randutil
6 |
7 | import "math/rand"
8 |
9 | var alphabet = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")
10 |
11 | // String returns a random string of length n, using the alphnum character set (a-z, A-Z, 0-9)
12 | func String(n int) string {
13 | s := make([]rune, n)
14 |
15 | for i := range s {
16 | s[i] = alphabet[rand.Intn(len(alphabet))]
17 | }
18 |
19 | return string(s)
20 | }
21 |
--------------------------------------------------------------------------------
/web/embedded_dev.go:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | // +build dev
6 |
7 | package web
8 |
9 | import (
10 | "net/http"
11 | "path/filepath"
12 |
13 | "go.mindeco.de/goutils"
14 | )
15 |
16 | const Production = false
17 |
18 | // absolute path of where this package is located
19 | var pkgDir = goutils.MustLocatePackage("github.com/ssbc/go-ssb-room/v2/web")
20 |
21 | var Templates = http.Dir(filepath.Join(pkgDir, "templates"))
22 |
23 | var Assets = http.Dir(filepath.Join(pkgDir, "assets"))
24 |
--------------------------------------------------------------------------------
/roomdb/sqlite/migrations.go:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | package sqlite
6 |
7 | import (
8 | "embed"
9 |
10 | migrate "github.com/rubenv/sql-migrate"
11 | )
12 |
13 | // migrations is an embedded filesystem containing the sqlite migration files
14 | //go:embed migrations/*
15 | var migrations embed.FS
16 |
17 | // needs https://github.com/rubenv/sql-migrate/pull/189 merged, using my branch until then
18 | var migrationSource = &migrate.EmbedFileSystemMigrationSource{
19 | FileSystem: migrations,
20 | Root: "migrations",
21 | }
22 |
--------------------------------------------------------------------------------
/internal/maybemod/multierror/multierr.go:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | package multierror
6 |
7 | import (
8 | "fmt"
9 | "strings"
10 | )
11 |
12 | // List contains a list of errors
13 | type List struct{ Errs []error }
14 |
15 | func (el List) Error() string {
16 | var str strings.Builder
17 |
18 | if n := len(el.Errs); n > 0 {
19 | fmt.Fprintf(&str, "multiple errors(%d): ", n)
20 | }
21 | for i, err := range el.Errs {
22 | fmt.Fprintf(&str, "(%d): ", i)
23 | str.WriteString(err.Error() + " - ")
24 | }
25 |
26 | return str.String()
27 | }
28 |
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | # SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | #
3 | # SPDX-License-Identifier: Unlicense
4 |
5 | # vim
6 | .*.sw[a-z]
7 |
8 | # the binaries
9 | cmd/server/server
10 | cmd/insert-user/insert-user
11 |
12 | # testrun contains repos that were use for tests
13 | muxrpc/test/go/testrun
14 | muxrpc/test/nodejs/testrun
15 | web/handlers/testrun
16 | web/handlers/admin/testrun
17 | roomdb/sqlite/testrun
18 | web/i18n/i18ntesting/testrun/
19 |
20 | # build artifacts from node.js project web/styles
21 | node_modules
22 |
23 | # goreleaser output
24 | dist/
25 |
26 | # secrets and config
27 | ssb-go-room-secrets/
28 | .env
29 |
--------------------------------------------------------------------------------
/muxrpc/test/nodejs/testscripts/secretstack_testplugin.js:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | /*
6 | this testing plugin supplies a very simple method to see if the other side is working
7 | */
8 | module.exports = {
9 | name: 'testing',
10 | version: '1.0.0',
11 | manifest: {
12 | working: 'async'
13 | },
14 | permissions: {
15 | anonymous: { allow: ['working'] },
16 | },
17 | init(ssb) {
18 | return {
19 | working(cb) {
20 | cb(null, true)
21 | }
22 | };
23 | },
24 | };
--------------------------------------------------------------------------------
/internal/repo/repo.go:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | package repo
6 |
7 | import "path/filepath"
8 |
9 | type Interface interface {
10 | GetPath(...string) string
11 | }
12 |
13 | var _ Interface = repo{}
14 |
15 | // New creates a new repository value, it opens the keypair and database from basePath if it is already existing
16 | func New(basePath string) Interface {
17 | return repo{basePath: basePath}
18 | }
19 |
20 | type repo struct {
21 | basePath string
22 | }
23 |
24 | func (r repo) GetPath(rel ...string) string {
25 | return filepath.Join(append([]string{r.basePath}, rel...)...)
26 | }
27 |
--------------------------------------------------------------------------------
/muxrpc/test/nodejs/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "go-ssb-rooms-tests",
3 | "version": "1.0.1",
4 | "description": "tests between go and ssb-js",
5 | "main": "sbot_client.js",
6 | "scripts": {
7 | "test": "go test"
8 | },
9 | "author": "cryptix",
10 | "dependencies": {
11 | "run-parallel": "^1.1.9",
12 | "run-series": "^1.1.9",
13 | "secret-stack": "^6.3.2",
14 | "sodium-native": "^3.2.0",
15 | "ssb-config": "^3.4.5",
16 | "ssb-conn": "^2.1.0",
17 | "ssb-db2": "^1.18.5",
18 | "ssb-keys": "^8.1.0",
19 | "ssb-replicate": "^1.3.2",
20 | "ssb-room": "^1.3.0",
21 | "ssb-room-client": "^0.13.0",
22 | "tap-spec": "^5.0.0",
23 | "tape": "^5.2.2"
24 | }
25 | }
26 |
--------------------------------------------------------------------------------
/internal/network/errors.go:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | package network
6 |
7 | import (
8 | "errors"
9 | "net"
10 | "os"
11 | "syscall"
12 | )
13 |
14 | func isConnBrokenErr(err error) bool {
15 | netErr := new(net.OpError)
16 | if errors.As(err, &netErr) {
17 | var sysCallErr = new(os.SyscallError)
18 | if errors.As(netErr.Err, &sysCallErr) {
19 | action := sysCallErr.Unwrap()
20 | if action == syscall.ECONNRESET || action == syscall.EPIPE {
21 | return true
22 | }
23 | }
24 | if netErr.Err.Error() == "use of closed network connection" {
25 | return true
26 | }
27 | }
28 | return false
29 | }
30 |
--------------------------------------------------------------------------------
/roomdb/sqlite/new_test.go:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | package sqlite
6 |
7 | import (
8 | "os"
9 | "path/filepath"
10 | "testing"
11 |
12 | "github.com/stretchr/testify/require"
13 | _ "modernc.org/sqlite"
14 |
15 | "github.com/ssbc/go-ssb-room/v2/internal/repo"
16 | )
17 |
18 | // verify the database opens and migrates successfully from zero state
19 | func TestSchema(t *testing.T) {
20 | testRepo := filepath.Join("testrun", t.Name())
21 | os.RemoveAll(testRepo)
22 |
23 | tr := repo.New(testRepo)
24 |
25 | db, err := Open(tr)
26 | require.NoError(t, err)
27 |
28 | err = db.Close()
29 | require.NoError(t, err)
30 | }
31 |
--------------------------------------------------------------------------------
/internal/maybemod/testutils/mergeErrChans.go:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | package testutils
6 |
7 | import (
8 | "sync"
9 | )
10 |
11 | // MergeErrorChans is a simple Fan-In for async errors
12 | // TODO: should be replaced with x/sync/errgroup
13 | func MergeErrorChans(cs ...<-chan error) <-chan error {
14 | var wg sync.WaitGroup
15 | out := make(chan error, 1)
16 |
17 | output := func(c <-chan error) {
18 | for a := range c {
19 | out <- a
20 | }
21 | wg.Done()
22 | }
23 |
24 | wg.Add(len(cs))
25 | for _, c := range cs {
26 | go output(c)
27 | }
28 |
29 | go func() {
30 | wg.Wait()
31 | close(out)
32 | }()
33 | return out
34 | }
35 |
--------------------------------------------------------------------------------
/internal/aliases/names_test.go:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | package aliases
6 |
7 | import (
8 | "testing"
9 |
10 | "github.com/stretchr/testify/assert"
11 | )
12 |
13 | func TestIsValid(t *testing.T) {
14 | a := assert.New(t)
15 |
16 | cases := []struct {
17 | alias string
18 | valid bool
19 | }{
20 | {"basic", true},
21 | {"no spaces", false},
22 | {"no.dots", false},
23 | {"#*!(! nope", false},
24 |
25 | {"NoUpperCase", false},
26 |
27 | // too long
28 | {"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", false},
29 | }
30 |
31 | for i, tc := range cases {
32 | yes := IsValid(tc.alias)
33 | a.Equal(tc.valid, yes, "wrong for %d: %s", i, tc.alias)
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/roomdb/sqlite/generate_models.sh:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 |
3 | # SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
4 | #
5 | # SPDX-License-Identifier: CC0-1.0
6 |
7 | set -e
8 |
9 | # ensure tools are installed
10 | go install github.com/volatiletech/sqlboiler/v4@latest
11 | go install github.com/volatiletech/sqlboiler/v4/drivers/sqlboiler-sqlite3@latest
12 |
13 | # make sure we are in the correct directory
14 | cd "$(dirname $0)"
15 |
16 | # run the migrations (creates testrun/TestSchema/roomdb)
17 | go test -run Schema
18 |
19 | # make sure the sqlite file was created
20 | test -f testrun/TestSchema/roomdb || {
21 | echo 'roomdb file missing'
22 | exit 1
23 | }
24 |
25 | # generate the models package
26 | sqlboiler sqlite3 --wipe --no-tests
27 |
28 | echo "all done. models updated!"
29 |
--------------------------------------------------------------------------------
/roomdb/sqlite/migrations/03-siwssb-tokens.sql:
--------------------------------------------------------------------------------
1 | -- SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | --
3 | -- SPDX-License-Identifier: CC0-1.0
4 |
5 | -- +migrate Up
6 | -- SIWSSB stands for sign-in with ssb
7 | CREATE TABLE SIWSSB_sessions (
8 | id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
9 | token TEXT UNIQUE NOT NULL,
10 | member_id INTEGER NOT NULL,
11 | created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
12 |
13 | FOREIGN KEY ( member_id ) REFERENCES members( "id" ) ON DELETE CASCADE
14 | );
15 | CREATE UNIQUE INDEX SIWSSB_by_token ON SIWSSB_sessions(token);
16 | CREATE INDEX SIWSSB_by_member ON SIWSSB_sessions(member_id);
17 |
18 | -- +migrate Down
19 | DROP INDEX SIWSSB_by_token;
20 | DROP INDEX SIWSSB_by_member;
21 | DROP TABLE SIWSSB_sessions;
--------------------------------------------------------------------------------
/web/assets/invite-uri.js:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | let hasFocus = true;
6 | window.addEventListener('blur', () => {
7 | hasFocus = false;
8 | });
9 | window.addEventListener('focus', () => {
10 | hasFocus = true;
11 | });
12 |
13 | const waitingElem = document.getElementById('waiting');
14 | const anchorElem = document.getElementById('claim-invite-uri');
15 | anchorElem.onclick = function handleURI(ev) {
16 | ev.preventDefault();
17 | const ssbUri = anchorElem.href;
18 | const fallbackUrl = anchorElem.dataset.hrefFallback;
19 | waitingElem.classList.remove('hidden');
20 | setTimeout(function () {
21 | if (hasFocus) window.location.replace(fallbackUrl);
22 | }, 5000);
23 | window.location.replace(ssbUri);
24 | };
25 |
--------------------------------------------------------------------------------
/internal/netwraputil/spoof_test.go:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | package netwraputil
6 |
7 | import (
8 | "net"
9 | "testing"
10 |
11 | "github.com/ssbc/go-ssb-room/v2/internal/maybemod/keys"
12 | "github.com/ssbc/go-ssb-room/v2/internal/network"
13 | "github.com/stretchr/testify/require"
14 | )
15 |
16 | func TestSpoof(t *testing.T) {
17 | r := require.New(t)
18 |
19 | rc, wc := net.Pipe()
20 |
21 | kp, err := keys.NewKeyPair(nil)
22 | r.NoError(err)
23 |
24 | wrap := SpoofRemoteAddress(kp.Feed.PubKey())
25 |
26 | wrapped, err := wrap(wc)
27 | r.NoError(err)
28 |
29 | ref, err := network.GetFeedRefFromAddr(wrapped.RemoteAddr())
30 | r.NoError(err)
31 | r.True(ref.Equal(kp.Feed))
32 |
33 | wc.Close()
34 | rc.Close()
35 | }
36 |
--------------------------------------------------------------------------------
/web/i18n/i18ntesting/i18n_helper_test.go:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | package i18ntesting
6 |
7 | import (
8 | "path/filepath"
9 | "testing"
10 |
11 | "github.com/stretchr/testify/assert"
12 |
13 | "github.com/ssbc/go-ssb-room/v2/internal/repo"
14 | "github.com/ssbc/go-ssb-room/v2/roomdb/mockdb"
15 | "github.com/ssbc/go-ssb-room/v2/web/i18n"
16 | )
17 |
18 | func TestListLanguages(t *testing.T) {
19 | configDB := new(mockdb.FakeRoomConfig)
20 | configDB.GetDefaultLanguageReturns("en", nil)
21 | r := repo.New(filepath.Join("testrun", t.Name()))
22 | a := assert.New(t)
23 | helper, err := i18n.New(r, configDB)
24 | a.NoError(err)
25 | t.Log(helper)
26 | translation := helper.ChooseTranslation("en")
27 | a.Equal(translation, "English")
28 | }
29 |
--------------------------------------------------------------------------------
/docs/files/example-systemd.service:
--------------------------------------------------------------------------------
1 | # SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | #
3 | # SPDX-License-Identifier: Unlicense
4 |
5 | [Unit]
6 | Description="The showcase v2 room"
7 | After=network.target
8 | # Uncomment these if you are using it with nginx
9 | # After=nginx.target
10 | # Wants=nginx.target
11 |
12 | [Service]
13 | # you need to change your -https-domain here. replace 'my-example-room.somewhere' with what you are using.
14 | # if you are using a different http configuration, you might also need to change value behind -lishttp.
15 | ExecStart=/usr/local/bin/go-ssb-room -repo /var/lib/go-ssb-room -lishttp localhost:8899 -https-domain my-example-room.somewhere
16 | WorkingDirectory=/var/lib/go-ssb-room
17 | Restart=always
18 | SyslogIdentifier=gossbroom
19 | User=go-ssb-room
20 |
21 | [Install]
22 | WantedBy=multi-user.target
23 |
--------------------------------------------------------------------------------
/web/handlers/language_template.go:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | package handlers
6 |
7 | import "html/template"
8 |
9 | type changeLanguageTemplateData struct {
10 | PostRoute string
11 | CSRFElement template.HTML
12 | LangTag string
13 | RedirectPage string
14 | Translation string
15 | ClassList string
16 | }
17 |
18 | var changeLanguageTemplate = template.Must(template.New("changeLanguageForm").Parse(`
19 | `))
32 |
--------------------------------------------------------------------------------
/roomdb/role_string.go:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | // Code generated by "stringer -type=Role"; DO NOT EDIT.
6 |
7 | package roomdb
8 |
9 | import "strconv"
10 |
11 | func _() {
12 | // An "invalid array index" compiler error signifies that the constant values have changed.
13 | // Re-run the stringer command to generate them again.
14 | var x [1]struct{}
15 | _ = x[RoleUnknown-0]
16 | _ = x[RoleMember-1]
17 | _ = x[RoleModerator-2]
18 | _ = x[RoleAdmin-3]
19 | }
20 |
21 | const _Role_name = "RoleUnknownRoleMemberRoleModeratorRoleAdmin"
22 |
23 | var _Role_index = [...]uint8{0, 11, 21, 34, 43}
24 |
25 | func (i Role) String() string {
26 | if i >= Role(len(_Role_index)-1) {
27 | return "Role(" + strconv.FormatInt(int64(i), 10) + ")"
28 | }
29 | return _Role_name[_Role_index[i]:_Role_index[i+1]]
30 | }
31 |
--------------------------------------------------------------------------------
/web/templates/notice/show.tmpl:
--------------------------------------------------------------------------------
1 |
6 |
7 | {{ define "title" }}{{.Title}}{{ end }}
8 | {{ define "content" }}
9 |
10 | {{ template "flashes" . }}
11 |
12 |
14 |
19 | {{.Err}}
15 |16 | Back 17 |
18 |{{.Title}}
15 | 16 |
17 | {{.Content}}
18 |
19 |
20 |
21 | {{if and is_logged_in member_is_elevated }}
22 | {{i18n "NoticeEditTitle"}}
27 | {{end}}
28 | {{end}}
29 |
--------------------------------------------------------------------------------
/web/templates/landing/index.tmpl:
--------------------------------------------------------------------------------
1 |
6 |
7 | {{ define "title" }}{{.Title}}{{ end }}
8 | {{ define "content" }}
9 | {{.Title}}
12 | 13 |
14 | {{.Content}}
15 |
16 |
17 |
18 | {{if and is_logged_in member_is_elevated }}
19 | {{i18n "NoticeEditTitle"}}
24 | {{end}}
25 | {{end}}
26 |
--------------------------------------------------------------------------------
/muxrpc/test/nodejs/testscripts/modern_aliases.js:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | const secretStackPlugins = require('./secretstack-modern')
6 | const before = require('./minimal-before-setup')
7 |
8 | module.exports = {
9 | secretStackPlugins,
10 | before,
11 | after: (t, sbot, rpc, exit) => {
12 |
13 | // give ssb-conn a moment to settle
14 | setTimeout(() => {
15 |
16 | sbot.roomClient.registerAlias(rpc.id, "alice", (err, ret) => {
17 | t.error(err, 'registerAlias')
18 | t.ok(ret)
19 | t.equals(typeof ret, 'string')
20 | t.ok(new URL(ret))
21 |
22 | sbot.roomClient.revokeAlias(rpc.id, "alice", (err, ret) => {
23 | t.error(err, 'revokeAlias')
24 | t.comment(`revokeAlias value: ${ret}`)
25 | exit()
26 | })
27 | })
28 |
29 | }, 1000)
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/web/members/testing.go:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | package members
6 |
7 | import (
8 | "context"
9 | "net/http"
10 |
11 | "github.com/ssbc/go-ssb-room/v2/roomdb"
12 | )
13 |
14 | // MiddlewareForTests gives us a way to inject _test members_. It should not be used in production.
15 | // This is part of testing.go because we need to use roomMemberContextKey, which shouldn't be exported either.
16 | // TODO: could be protected with an extra build tag.
17 | // (Sadly +build test does not exist https://github.com/golang/go/issues/21360 )
18 | func MiddlewareForTests(m *roomdb.Member) func(http.Handler) http.Handler {
19 | return func(next http.Handler) http.Handler {
20 | return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
21 | ctx := context.WithValue(req.Context(), roomMemberContextKey, m)
22 | next.ServeHTTP(w, req.WithContext(ctx))
23 | })
24 | }
25 | }
26 |
--------------------------------------------------------------------------------
/roomdb/privacymode_string.go:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | // Code generated by "stringer -type=PrivacyMode"; DO NOT EDIT.
6 |
7 | package roomdb
8 |
9 | import "strconv"
10 |
11 | func _() {
12 | // An "invalid array index" compiler error signifies that the constant values have changed.
13 | // Re-run the stringer command to generate them again.
14 | var x [1]struct{}
15 | _ = x[ModeUnknown-0]
16 | _ = x[ModeOpen-1]
17 | _ = x[ModeCommunity-2]
18 | _ = x[ModeRestricted-3]
19 | }
20 |
21 | const _PrivacyMode_name = "ModeUnknownModeOpenModeCommunityModeRestricted"
22 |
23 | var _PrivacyMode_index = [...]uint8{0, 11, 19, 32, 46}
24 |
25 | func (i PrivacyMode) String() string {
26 | if i >= PrivacyMode(len(_PrivacyMode_index)-1) {
27 | return "PrivacyMode(" + strconv.FormatInt(int64(i), 10) + ")"
28 | }
29 | return _PrivacyMode_name[_PrivacyMode_index[i]:_PrivacyMode_index[i+1]]
30 | }
31 |
--------------------------------------------------------------------------------
/muxrpc/handlers/whoami/whoami.go:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | package whoami
6 |
7 | import (
8 | "context"
9 |
10 | "github.com/ssbc/go-muxrpc/v2/typemux"
11 |
12 | "github.com/ssbc/go-muxrpc/v2"
13 | kitlog "go.mindeco.de/log"
14 | "go.mindeco.de/log/level"
15 |
16 | refs "github.com/ssbc/go-ssb-refs"
17 | )
18 |
19 | var (
20 | method = muxrpc.Method{"whoami"}
21 | )
22 |
23 | func checkAndLog(log kitlog.Logger, err error) {
24 | if err != nil {
25 | level.Warn(log).Log("event", "faild to write panic file", "err", err)
26 | }
27 | }
28 |
29 | func New(id refs.FeedRef) typemux.AsyncHandler {
30 | return handler{id: id}
31 | }
32 |
33 | type handler struct {
34 | id refs.FeedRef
35 | }
36 |
37 | func (h handler) HandleAsync(ctx context.Context, req *muxrpc.Request) (interface{}, error) {
38 | type ret struct {
39 | ID string `json:"id"`
40 | }
41 |
42 | return ret{h.id.String()}, nil
43 | }
44 |
--------------------------------------------------------------------------------
/web/embedded_prod.go:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | // +build !dev
6 |
7 | package web
8 |
9 | import (
10 | "embed"
11 | "io/fs"
12 | "log"
13 | "net/http"
14 | )
15 |
16 | // Production can be used to determain different aspects at compile time (like hot template reloading)
17 | const Production = true
18 |
19 | var (
20 | Assets http.FileSystem
21 | Templates http.FileSystem
22 | )
23 |
24 | // correct the paths by stripping their prefixes
25 | func init() {
26 | var err error
27 |
28 | prefixedAssets, err := fs.Sub(embedAssets, "assets")
29 | if err != nil {
30 | log.Fatal(err)
31 | }
32 | Assets = http.FS(prefixedAssets)
33 |
34 | prefixedTemplates, err := fs.Sub(embedTemplates, "templates")
35 | if err != nil {
36 | log.Fatal(err)
37 | }
38 | Templates = http.FS(prefixedTemplates)
39 | }
40 |
41 | //go:embed templates/*
42 | var embedTemplates embed.FS
43 |
44 | //go:embed assets/*
45 | var embedAssets embed.FS
46 |
--------------------------------------------------------------------------------
/internal/maybemod/multicloser/multicloser.go:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | package multicloser
6 |
7 | import (
8 | "fmt"
9 | "io"
10 | "sync"
11 |
12 | "github.com/ssbc/go-ssb-room/v2/internal/maybemod/multierror"
13 | )
14 |
15 | type Closer struct {
16 | cs []io.Closer
17 | l sync.Mutex
18 | }
19 |
20 | func (mc *Closer) Add(c io.Closer) {
21 | mc.l.Lock()
22 | defer mc.l.Unlock()
23 |
24 | mc.cs = append(mc.cs, c)
25 | }
26 |
27 | var _ io.Closer = (*Closer)(nil)
28 |
29 | func (mc *Closer) Close() error {
30 | mc.l.Lock()
31 | defer mc.l.Unlock()
32 |
33 | var (
34 | hasErrs bool
35 | errs []error
36 | )
37 |
38 | for i, c := range mc.cs {
39 | if cerr := c.Close(); cerr != nil {
40 | cerr = fmt.Errorf("Closer: c%d failed: %w", i, cerr)
41 | errs = append(errs, cerr)
42 | hasErrs = true
43 | }
44 | }
45 |
46 | if !hasErrs {
47 | return nil
48 | }
49 |
50 | return multierror.List{Errs: errs}
51 | }
52 |
--------------------------------------------------------------------------------
/roomdb/sqlite/sqlboiler.toml:
--------------------------------------------------------------------------------
1 | # SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | #
3 | # SPDX-License-Identifier: CC0-1.0
4 |
5 | [sqlite3]
6 | # go test in the roomdb/sqlite package will create this
7 | dbname = "testrun/TestSchema/roomdb"
8 | blacklist = ["gorp_migrations"]
9 |
10 | # marshal pub_key strings ala @asdjjasd as feed references.
11 | [[types]]
12 | [types.match]
13 | type = "string"
14 | #tables = ['fallback_auth']
15 | name = "pub_key"
16 | nullable = false
17 |
18 | [types.replace]
19 | type = "roomdb.DBFeedRef"
20 |
21 | [types.imports]
22 | third_party = ['"github.com/ssbc/go-ssb-room/v2/roomdb"']
23 |
24 | # convert from database-stored integers to the type roomdb.RoomConfig
25 | [[types]]
26 | [types.match]
27 | name = "privacyMode"
28 | tables = ['config']
29 | type = "int64"
30 | nullable = false
31 |
32 | [types.replace]
33 | type = "roomdb.PrivacyMode"
34 |
35 | [types.imports]
36 | third_party = ['"github.com/ssbc/go-ssb-room/v2/roomdb"']
37 |
--------------------------------------------------------------------------------
/roomdb/sqlite/models/boil_table_names.go:
--------------------------------------------------------------------------------
1 | // Code generated by SQLBoiler 4.14.2 (https://github.com/volatiletech/sqlboiler). DO NOT EDIT.
2 | // This file is meant to be re-generated in place and/or deleted at any time.
3 |
4 | package models
5 |
6 | var TableNames = struct {
7 | SIWSSBSessions string
8 | Aliases string
9 | Config string
10 | DeniedKeys string
11 | FallbackPasswords string
12 | FallbackResetTokens string
13 | Invites string
14 | Members string
15 | Notices string
16 | PinNotices string
17 | Pins string
18 | }{
19 | SIWSSBSessions: "SIWSSB_sessions",
20 | Aliases: "aliases",
21 | Config: "config",
22 | DeniedKeys: "denied_keys",
23 | FallbackPasswords: "fallback_passwords",
24 | FallbackResetTokens: "fallback_reset_tokens",
25 | Invites: "invites",
26 | Members: "members",
27 | Notices: "notices",
28 | PinNotices: "pin_notices",
29 | Pins: "pins",
30 | }
31 |
--------------------------------------------------------------------------------
/web/templates/admin/invite-created.tmpl:
--------------------------------------------------------------------------------
1 |
6 |
7 | {{ define "title" }}{{i18n "AdminInviteCreatedTitle"}}{{ end }}
8 | {{ define "content" }}
9 |
10 |
13 |
14 | {{i18n "AdminInviteCreatedTitle"}}
{{i18n "AdminInviteCreatedInstruct"}} 18 | 19 | {{.FacadeURL}} 24 |
25 | {{end}}
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | Copyright 2021 SSB NGI-Pointer Team {{i18n "AdminInviteCreatedInstruct"}} 18 | 19 | {{.FacadeURL}} 24 |
10 |
13 |
14 | {{i18n "AdminMemberPasswordResetLinkCreatedTitle"}}
{{i18n "AdminMemberPasswordResetLinkCreatedInstruct"}} 18 | 19 | {{.ResetLinkURL}} 24 |
25 | {{end}}
--------------------------------------------------------------------------------
/internal/aliases/names.go:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | package aliases
6 |
7 | // IsValid decides whether an alias is okay for use or not.
8 | // The room spec defines it as _labels valid under RFC 1035_ ( https://ssbc.github.io/rooms2/#alias-string )
9 | // but that can be mostly any string since DNS is a 8bit binary protocol,
10 | // as long as it's shorter then 63 charachters.
11 | //
12 | // Right now it's pretty basic set of characters (a-z, 0-9).
13 | // In theory we could be more liberal but there is a bunch of stuff to figure out,
14 | // like homograph attacks (https://en.wikipedia.org/wiki/IDN_homograph_attack),
15 | // if we would decide to allow full utf8 unicode.
16 | func IsValid(alias string) bool {
17 | if len(alias) > 63 {
18 | return false
19 | }
20 |
21 | var valid = true
22 | for _, char := range alias {
23 | if char >= '0' && char <= '9' { // is an ASCII number
24 | continue
25 | }
26 |
27 | if char >= 'a' && char <= 'z' { // is an ASCII char between a and z
28 | continue
29 | }
30 |
31 | valid = false
32 | break
33 | }
34 | return valid
35 | }
36 |
--------------------------------------------------------------------------------
/LICENSES/Unlicense.txt:
--------------------------------------------------------------------------------
1 | This is free and unencumbered software released into the public domain.
2 |
3 | Anyone is free to copy, modify, publish, use, compile, sell, or distribute this software, either in source code form or as a compiled binary, for any purpose, commercial or non-commercial, and by any means.
4 |
5 | In jurisdictions that recognize copyright laws, the author or authors of this software dedicate any and all copyright interest in the software to the public domain. We make this dedication for the benefit of the public at large and to the detriment of our heirs and
6 | successors. We intend this dedication to be an overt act of relinquishment in perpetuity of all present and future rights to this software under copyright law.
7 |
8 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
9 |
10 | For more information, please refer to {{i18n "AdminMemberPasswordResetLinkCreatedInstruct"}} 18 | 19 | {{.ResetLinkURL}} 24 |
10 | {{i18n "InviteInsertWelcome"}}
11 |
12 |
32 |
33 | {{ end }}
34 |
--------------------------------------------------------------------------------
/web/templates/notice/list.tmpl:
--------------------------------------------------------------------------------
1 |
6 |
7 | {{ define "title" }}{{i18n "NoticeList"}}{{ end }}
8 | {{ define "content" }}
9 |
10 |
38 | {{end}}
39 |
--------------------------------------------------------------------------------
/internal/signinwithssb/simple_test.go:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | package signinwithssb
6 |
7 | import (
8 | "bytes"
9 | "testing"
10 |
11 | "github.com/stretchr/testify/assert"
12 | "github.com/stretchr/testify/require"
13 |
14 | refs "github.com/ssbc/go-ssb-refs"
15 | )
16 |
17 | func TestPayloadString(t *testing.T) {
18 |
19 | server, err := refs.NewFeedRefFromBytes(bytes.Repeat([]byte{1}, 32), refs.RefAlgoFeedSSB1)
20 | if err != nil {
21 | t.Error(err)
22 | }
23 |
24 | client, err := refs.NewFeedRefFromBytes(bytes.Repeat([]byte{2}, 32), refs.RefAlgoFeedSSB1)
25 | if err != nil {
26 | t.Error(err)
27 | }
28 |
29 | var req ClientPayload
30 |
31 | req.ServerID = server
32 | req.ClientID = client
33 |
34 | req.ServerChallenge = "fooo"
35 | req.ClientChallenge = "barr"
36 |
37 | want := "=http-auth-sign-in:@AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQE=.ed25519:@AgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI=.ed25519:fooo:barr"
38 |
39 | got := req.createMessage()
40 | assert.Equal(t, want, string(got))
41 | }
42 |
43 | func TestGenerateAndDecode(t *testing.T) {
44 | r := require.New(t)
45 |
46 | b, err := DecodeChallengeString(GenerateChallenge())
47 | r.NoError(err)
48 | r.Len(b, challengeLength)
49 |
50 | b, err = DecodeChallengeString("toshort")
51 | r.Error(err)
52 | r.Nil(b)
53 | }
54 |
--------------------------------------------------------------------------------
/web/templates/invite/facade.tmpl:
--------------------------------------------------------------------------------
1 |
6 |
7 | {{ define "title" }}{{ i18n "InviteFacadeTitle" }}{{ end }}
8 | {{ define "content" }}
9 | {{i18n "NoticeList"}}
13 | 14 |{{i18n "NoticeListWelcome"}}
15 | 16 | {{ template "flashes" . }} 17 | 18 | {{range .AllNotices}} 19 |
20 |
36 | {{end}}
37 | {{i18n .Name.String}}
21 | 22 | {{range .Notices}} 23 | {{.Language}} 27 | {{end}} 28 | 29 | {{if and is_logged_in member_is_elevated }} 30 | {{i18n "NoticeAddTranslation"}} 34 | {{end}} 35 |
10 |
23 | 24 | {{i18n "InviteFacadeInstructQR"}} 25 | 26 |
34 |
35 |
36 |
37 | {{ end }}
--------------------------------------------------------------------------------
/roomsrv/manifest.go:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | package roomsrv
6 |
7 | import (
8 | "context"
9 | "encoding/json"
10 | "fmt"
11 |
12 | "github.com/ssbc/go-muxrpc/v2"
13 | )
14 |
15 | type manifestHandler string
16 |
17 | func (h manifestHandler) HandleAsync(ctx context.Context, req *muxrpc.Request) (interface{}, error) {
18 | return json.RawMessage(h), nil
19 | }
20 |
21 | func init() {
22 | if !json.Valid([]byte(manifest)) {
23 | manifestMap := make(map[string]interface{})
24 | err := json.Unmarshal([]byte(manifest), &manifestMap)
25 | fmt.Println(err)
26 | panic("manifest blob is broken json")
27 | }
28 | }
29 |
30 | // this is a very simple hardcoded manifest.json dump which oasis' ssb-client expects to do it's magic.
31 | const manifest manifestHandler = `
32 | {
33 | "manifest": "sync",
34 |
35 | "whoami":"async",
36 |
37 | "gossip": {
38 | "ping": "duplex"
39 | },
40 |
41 | "room": {
42 | "registerAlias": "async",
43 | "revokeAlias": "async",
44 | "listAliases": "async",
45 |
46 | "connect": "duplex",
47 | "attendants": "source",
48 | "members": "source",
49 | "metadata": "async",
50 | "ping": "sync"
51 | },
52 |
53 | "tunnel": {
54 | "announce": "sync",
55 | "leave": "sync",
56 | "connect": "duplex",
57 | "endpoints": "source",
58 | "isRoom": "async",
59 | "ping": "sync"
60 | }
61 | }`
62 |
--------------------------------------------------------------------------------
/.github/workflows/go.yml:
--------------------------------------------------------------------------------
1 | # SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | #
3 | # SPDX-License-Identifier: CC0-1.0
4 |
5 | name: Go
6 |
7 | on:
8 | push:
9 | branches: [ master ]
10 | pull_request:
11 | branches: [ master ]
12 |
13 | jobs:
14 |
15 | build:
16 | runs-on: ubuntu-latest
17 | steps:
18 | - uses: actions/checkout@v2
19 |
20 | - name: Set up Node (for interop testing)
21 | uses: actions/setup-node@v1
22 | with:
23 | node-version: 14.x
24 |
25 | - name: Set up Go
26 | uses: actions/setup-go@v2
27 | with:
28 | go-version: 1.20.5
29 |
30 | - name: Get dependencies
31 | run: go get -v -t -d ./...
32 |
33 | - name: Build smoke test
34 | run: go build ./cmd/...
35 |
36 | - name: Build dev smoke test
37 | run: go build -tags dev ./cmd/...
38 |
39 | - name: install node ssb-stack
40 | run: |
41 | pushd muxrpc/test/nodejs
42 | npm ci
43 | popd
44 |
45 | - name: All the Test
46 | run: go test ./...
47 |
48 | - name: update style.css
49 | run: |
50 | pushd web/styles
51 | npm ci
52 | npm run compile-prod
53 | popd
54 |
55 | - name: push updated style.css
56 | uses: stefanzweifel/git-auto-commit-action@v4
57 | with:
58 | commit_message: update production style.css
59 | file_pattern: web/assets/style.css
60 |
--------------------------------------------------------------------------------
/web/templates/auth/fallback_sign_in.tmpl:
--------------------------------------------------------------------------------
1 |
6 |
7 | {{ define "title" }}{{i18n "AuthTitle"}}{{ end }}
8 | {{ define "content" }}
9 | {{i18nWithData "InviteFacadeWelcome" "RoomTitle" .RoomTitle}}
11 |{{i18n "InviteFacadeInstruct"}}
12 | 13 | {{i18n "InviteFacadeJoin"}} 19 | 20 |{{i18n "SSBURIOpening"}}
21 | 22 |23 | 24 | {{i18n "InviteFacadeInstructQR"}} 25 | 26 |
10 | {{i18n "AuthFallbackWelcome"}}
11 |
12 | {{ template "flashes" . }}
13 |
14 |
32 |
33 | {{end}}
--------------------------------------------------------------------------------
/web/templates/invite/consumed.tmpl:
--------------------------------------------------------------------------------
1 |
6 |
7 | {{ define "title" }}{{i18n "InviteConsumedTitle"}}{{ end }}
8 | {{ define "content" }}
9 |
10 |
13 |
14 | {{i18n "InviteConsumedTitle"}}
{{i18n "InviteConsumedWelcome"}} 18 | 19 | {{.MultiserverAddress}} 22 | 23 | {{i18n "InviteConsumedSetPassword" }}
26 | 27 | {{i18n "InviteConsumedSetPasswordButton" }} 33 |
34 | {{end}}
35 |
--------------------------------------------------------------------------------
/docs/architecture.md:
--------------------------------------------------------------------------------
1 |
6 |
7 | # Architecture
8 |
9 | ## Invite flow
10 |
11 | This implementation of Rooms 2.0 is compliant with the [Rooms 2.0
12 | specification](https://github.com/ssbc/rooms2), but we add a few additional features
13 | and pages in order to improve user experience when their SSB app does not support [SSB
14 | URIs](https://github.com/ssbc/ssb-uri-spec).
15 |
16 | A summary can be seen in the following chart:
17 |
18 | 
19 |
20 | When the browser and operating system detects no support for opening SSB URIs, we redirect to a
21 | fallback page which presents the user with two broad options: (1) install an SSB app that
22 | supports SSB URIs, (2) link to another page where the user can manually input the user's SSB ID
23 | in a form.
24 |
25 | ## Sign-in flow
26 |
27 | This implementation is compliant with [SSB HTTP
28 | Authentication](https://github.com/ssbc/ssb-http-auth-spec), but we add a few
29 | additional features and pages in order to improve user experience. For instance, besides
30 | conventional SSB HTTP Auth, we also render a QR code to sign-in with a remote SSB app (an SSB
31 | identity not on the device that has the browser open). We also support sign-in with
32 | username/password, what we call "fallback authentication".
33 |
34 | A summary can be seen in the following chart:
35 |
36 | 
37 |
--------------------------------------------------------------------------------
/web/templates/admin/members-remove-confirm.tmpl:
--------------------------------------------------------------------------------
1 |
6 |
7 | {{ define "title" }}{{i18n "AdminMembersRemoveConfirmTitle"}}{{ end }}
8 | {{ define "content" }}
9 | {{i18n "InviteConsumedWelcome"}} 18 | 19 | {{.MultiserverAddress}} 22 | 23 | {{i18n "InviteConsumedSetPassword" }}
26 | 27 | {{i18n "InviteConsumedSetPasswordButton" }} 33 |
10 |
11 | {{i18n "AdminMembersRemoveConfirmWelcome"}}
15 |
16 |
37 | {{end}}
38 |
--------------------------------------------------------------------------------
/web/templates/admin/aliases-revoke-confirm.tmpl:
--------------------------------------------------------------------------------
1 |
6 |
7 | {{ define "title" }}{{i18n "AdminAliasesRevokeConfirmTitle"}}{{ end }}
8 | {{ define "content" }}
9 | {{.Entry.PubKey.String}}
20 |
21 |
36 |
10 |
11 | {{i18n "AdminAliasesRevokeConfirmWelcome"}}
15 |
16 |
37 | {{end}}
38 |
--------------------------------------------------------------------------------
/muxrpc/test/nodejs/testscripts/template.js:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | /*
6 | this is a tempalte for a script to be used in the go<>js tests.
7 |
8 | all the setup of the peers is done in sbot_client and sbot_server js.
9 |
10 | warning: only log to stderr (console.warn)
11 | DONT log to stdout (console.log) as this is connected to the go test process for initialization
12 |
13 | TODO: pass the tape instance into the module, so that t.error and it's other helpers can be used.
14 | proably by turning the exported object into an init function which returns the {before, after} object.
15 | */
16 |
17 | // const pull = require('pull-stream')
18 |
19 | module.exports = {
20 | secretStackPlugins: ['ssb-blobs', 'ssb-what-ever-you-need'],
21 |
22 | // t is the tape instance for assertions
23 | // sbot is the local sbot api
24 | // ready is a function to signal that preperation is done
25 | before: (t, sbot, ready) => {
26 | console.warn('before connect...')
27 | setTimeout(ready, 1000)
28 | },
29 |
30 | // t and sbot are same as above
31 | // clientRpc is the muxrpc client to the other remote (i.e a rpc handle for the room the client is connected to)
32 | // exit() is a function that needs to be called to halt the process and exit (it also calls t.end())
33 | after: (t, sbot, clientRpc, exit) => {
34 | console.warn('after connect...')
35 |
36 | setTimeout(exit, 5000)
37 | }
38 | }
--------------------------------------------------------------------------------
/roomdb/sqlite/models/boil_types.go:
--------------------------------------------------------------------------------
1 | // Code generated by SQLBoiler 4.14.2 (https://github.com/volatiletech/sqlboiler). DO NOT EDIT.
2 | // This file is meant to be re-generated in place and/or deleted at any time.
3 |
4 | package models
5 |
6 | import (
7 | "strconv"
8 |
9 | "github.com/friendsofgo/errors"
10 | "github.com/volatiletech/sqlboiler/v4/boil"
11 | "github.com/volatiletech/strmangle"
12 | )
13 |
14 | // M type is for providing columns and column values to UpdateAll.
15 | type M map[string]interface{}
16 |
17 | // ErrSyncFail occurs during insert when the record could not be retrieved in
18 | // order to populate default value information. This usually happens when LastInsertId
19 | // fails or there was a primary key configuration that was not resolvable.
20 | var ErrSyncFail = errors.New("models: failed to synchronize data after insert")
21 |
22 | type insertCache struct {
23 | query string
24 | retQuery string
25 | valueMapping []uint64
26 | retMapping []uint64
27 | }
28 |
29 | type updateCache struct {
30 | query string
31 | valueMapping []uint64
32 | }
33 |
34 | func makeCacheKey(cols boil.Columns, nzDefaults []string) string {
35 | buf := strmangle.GetBuffer()
36 |
37 | buf.WriteString(strconv.Itoa(cols.Kind))
38 | for _, w := range cols.Cols {
39 | buf.WriteString(w)
40 | }
41 |
42 | if len(nzDefaults) != 0 {
43 | buf.WriteByte('.')
44 | }
45 | for _, nz := range nzDefaults {
46 | buf.WriteString(nz)
47 | }
48 |
49 | str := buf.String()
50 | strmangle.PutBuffer(buf)
51 | return str
52 | }
53 |
--------------------------------------------------------------------------------
/muxrpc/handlers/tunnel/server/members.go:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | package server
6 |
7 | import (
8 | "context"
9 | "encoding/json"
10 | "fmt"
11 |
12 | "github.com/ssbc/go-muxrpc/v2"
13 | refs "github.com/ssbc/go-ssb-refs"
14 | "github.com/ssbc/go-ssb-room/v2/internal/network"
15 | "github.com/ssbc/go-ssb-room/v2/roomdb"
16 | )
17 |
18 | type Member struct {
19 | ID refs.FeedRef `json:"id"`
20 | }
21 |
22 | func (h *Handler) members(ctx context.Context, req *muxrpc.Request, snk *muxrpc.ByteSink) error {
23 | peer, err := network.GetFeedRefFromAddr(req.RemoteAddr())
24 | if err != nil {
25 | return err
26 | }
27 |
28 | pm, err := h.config.GetPrivacyMode(ctx)
29 | if err != nil {
30 | return fmt.Errorf("running with unknown privacy mode: %w", err)
31 | }
32 |
33 | if pm == roomdb.ModeCommunity || pm == roomdb.ModeRestricted {
34 | _, err := h.membersdb.GetByFeed(ctx, peer)
35 | if err != nil {
36 | return fmt.Errorf("external users are not allowed to list members: %w", err)
37 | }
38 | }
39 |
40 | members, err := h.membersdb.List(ctx)
41 | if err != nil {
42 | return fmt.Errorf("error listing members: %w", err)
43 | }
44 |
45 | snk.SetEncoding(muxrpc.TypeJSON)
46 |
47 | for _, member := range members {
48 | if err = json.NewEncoder(snk).Encode([]Member{
49 | {
50 | ID: member.PubKey,
51 | },
52 | }); err != nil {
53 | return fmt.Errorf("encoder error: %w", err)
54 | }
55 | }
56 |
57 | return snk.Close()
58 | }
59 |
--------------------------------------------------------------------------------
/web/templates/alias.tmpl:
--------------------------------------------------------------------------------
1 |
6 |
7 | {{ define "title" }}{{.Alias.Name}}{{ end }}
8 | {{ define "content" }}
9 | {{.Entry.Feed.String}}
20 |
21 |
36 |
10 |
34 | {{end}}
--------------------------------------------------------------------------------
/internal/maybemuxrpc/plugin.go:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | package maybemuxrpc
6 |
7 | import (
8 | "net"
9 | "sync"
10 |
11 | "github.com/ssbc/go-muxrpc/v2"
12 | )
13 |
14 | type Authorizer interface {
15 | Authorize(net.Conn) bool
16 | }
17 |
18 | type Plugin interface {
19 | // Name returns the name and version of the plugin.
20 | // format: name-1.0.2
21 | Name() string
22 |
23 | // Method returns the preferred method of the call
24 | Method() muxrpc.Method
25 |
26 | // Handler returns the muxrpc handler for the plugin
27 | Handler() muxrpc.Handler
28 |
29 | Authorizer
30 | }
31 |
32 | type PluginManager interface {
33 | Register(Plugin)
34 | MakeHandler(conn net.Conn) (muxrpc.Handler, error)
35 | }
36 |
37 | type pluginManager struct {
38 | regLock sync.Mutex // protects the map
39 | plugins map[string]Plugin
40 | }
41 |
42 | func NewPluginManager() PluginManager {
43 | return &pluginManager{
44 | plugins: make(map[string]Plugin),
45 | }
46 | }
47 |
48 | func (pmgr *pluginManager) Register(p Plugin) {
49 | // access race
50 | pmgr.regLock.Lock()
51 | defer pmgr.regLock.Unlock()
52 | pmgr.plugins[p.Method().String()] = p
53 | }
54 |
55 | func (pmgr *pluginManager) MakeHandler(conn net.Conn) (muxrpc.Handler, error) {
56 |
57 | pmgr.regLock.Lock()
58 | defer pmgr.regLock.Unlock()
59 |
60 | h := muxrpc.HandlerMux{}
61 |
62 | for _, p := range pmgr.plugins {
63 | if !p.Authorize(conn) {
64 | continue
65 | }
66 |
67 | h.Register(p.Method(), p.Handler())
68 | }
69 |
70 | return &h, nil
71 | }
72 |
--------------------------------------------------------------------------------
/muxrpc/test/nodejs/testscripts/client.js:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | const pull = require('pull-stream')
6 | const path = require("path")
7 | const scriptname = path.basename(__filename)
8 |
9 | module.exports = (t, sbot, rpc, exit) => {
10 | // shadow t.comment to include file making the comment
11 | function comment (msg) {
12 | t.comment(`[${scriptname}] ${msg}`)
13 | }
14 | // this waits for a new incoming connection _after_ the room server is connected already
15 | // so it will be an incomming tunnel client.
16 | // since this calls exit() - if no client connects it will not exit
17 | sbot.on("rpc:connect", (remote, isClient) => {
18 | comment("tunneled connection to simple client!")
19 |
20 | // leave after 3 seconds (give the other party time to call `testing.working()`)
21 | setTimeout(() => {
22 | rpc.tunnel.leave((err, ret) => {
23 | t.error(err, 'tunnel.leave')
24 | comment(`tunnel error: ${err}`)
25 | comment(`leave value: ${ret}`)
26 | comment('left, exiting in 3s')
27 | setTimeout(exit, 3000)
28 | })
29 | }, 1000)
30 | })
31 |
32 | // announce ourselves to the room/tunnel
33 | rpc.tunnel.announce((err, ret) => {
34 | t.error(err, 'tunnel.announce')
35 | comment(`announce error: ${err}`)
36 | comment(`announce value: ${ret}`)
37 | comment('announced!')
38 | })
39 |
40 | // log all new endpoints
41 | pull(
42 | rpc.tunnel.endpoints(),
43 | pull.drain(el => {
44 | comment(`from roomsrv: ${el}`)
45 | }, (err) => {
46 | t.comment('endpoints closed', err)
47 | })
48 | )
49 | }
50 |
--------------------------------------------------------------------------------
/docs/files/debian-postinstall.sh:
--------------------------------------------------------------------------------
1 | # SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | #
3 | # SPDX-License-Identifier: CC0-1.0
4 |
5 | # create a user to run the server as
6 | adduser --system --home /var/lib/go-ssb-room go-ssb-room
7 | chown go-ssb-room /var/lib/go-ssb-room
8 |
9 | # welcome message
10 | cat <{{.Alias.Name}} is a member of this SSB room server.
11 |{{i18n "AliasResolutionInstruct"}}
12 | 13 | {{i18n "AliasResolutionConnect"}} {{.Alias.Name}} 18 | 19 |{{i18n "SSBURIOpening"}}
20 | 21 |
22 |
30 |
31 |
32 |
33 | {{i18n "SSBURIFailureWelcome"}}
23 |
24 | {{i18n "SSBURIFailureInstallManyverse"}}
28 |
29 |
10 | {{i18n "AuthWithSSBWelcome"}}
11 |
12 | {{i18n "AuthWithSSBTitle"}}
17 |
18 |
24 | 25 | {{i18n "AuthWithSSBInstructQR"}} 26 | 27 |
35 | {{else}}
36 |
37 | {{end}}
38 |
39 |
40 | {{if not .IsSolvingRemotely}}
41 |
42 |
43 | {{end}}
44 | {{end}}
--------------------------------------------------------------------------------
/web/templates/admin/invite-revoke-confirm.tmpl:
--------------------------------------------------------------------------------
1 |
6 |
7 | {{ define "title" }}{{i18n "AdminInviteRevokeConfirmTitle"}}{{ end }}
8 | {{ define "content" }}
9 | Waiting for confirmation
19 | 20 |{{i18n "AuthWithSSBError"}}
21 | 22 | {{if not .IsSolvingRemotely}} 23 |24 | 25 | {{i18n "AuthWithSSBInstructQR"}} 26 | 27 |
10 |
11 | {{i18n "AdminInviteRevokeConfirmWelcome"}}
15 |
16 | {{$creator := .Invite.CreatedBy.PubKey.String}}
17 | {{range $index, $alias := .Invite.CreatedBy.Aliases}}
18 | {{if eq $index 0}}
19 | {{$creator = $alias.Name}}
20 | {{end}}
21 | {{end}}
22 |
42 | {{end}}
43 |
--------------------------------------------------------------------------------
/web/handlers/admin/set_language_test.go:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | package admin
6 |
7 | import (
8 | "net/http"
9 | "strings"
10 | "testing"
11 |
12 | "github.com/ssbc/go-ssb-room/v2/roomdb"
13 | "github.com/ssbc/go-ssb-room/v2/web/router"
14 | "github.com/stretchr/testify/assert"
15 | )
16 |
17 | /* can't test English atm due to web/i18n/i18ntesting/testing.go:justTheKeys, which generates translations that are just
18 | * translationLabel = "translationLabel"
19 | */
20 | // func TestLanguageSetDefaultLanguageEnglish(t *testing.T) {
21 | // ts := newSession(t)
22 | // a := assert.New(t)
23 | //
24 | // ts.ConfigDB.GetDefaultLanguageReturns("en", nil)
25 | //
26 | // u := ts.URLTo(router.AdminSettings)
27 | // html, resp := ts.Client.GetHTML(u)
28 | // a.Equal(http.StatusOK, resp.Code, "Wrong HTTP status code")
29 | //
30 | // fmt.Println(html.Html())
31 | // summaryElement := html.Find("#language-summary")
32 | // summaryText := strings.TrimSpace(summaryElement.Text())
33 | // a.Equal("English", summaryText, "summary language should display english translation of language name")
34 | // }
35 |
36 | func TestLanguageSetDefaultLanguage(t *testing.T) {
37 | ts := newSession(t)
38 | a := assert.New(t)
39 |
40 | ts.ConfigDB.GetDefaultLanguageReturns("de", nil)
41 | ts.User = roomdb.Member{
42 | ID: 1234,
43 | Role: roomdb.RoleAdmin,
44 | }
45 |
46 | u := ts.URLTo(router.AdminSettings)
47 | html, resp := ts.Client.GetHTML(u)
48 | a.Equal(http.StatusOK, resp.Code, "Wrong HTTP status code")
49 |
50 | summaryElement := html.Find("#language-summary")
51 | summaryText := strings.TrimSpace(summaryElement.Text())
52 | a.Equal("Deutsch", summaryText, "summary language should display german translation of language name")
53 | }
54 |
--------------------------------------------------------------------------------
/web/styles/input.css:
--------------------------------------------------------------------------------
1 | /*
2 | * SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
3 | *
4 | * SPDX-License-Identifier: CC-BY-4.0
5 | */
6 |
7 | @tailwind base;
8 | @tailwind components;
9 | @tailwind utilities;
10 |
11 | /* Fix Flash-of-unstyled-content */
12 | html {
13 | visibility: visible;
14 | opacity: 1;
15 | }
16 |
17 | /* custom tooltips from https://github.com/Cosbgn/tailwindcss-tooltips */
18 | .tooltip {
19 | @apply invisible absolute;
20 | }
21 |
22 | .has-tooltip:hover .tooltip {
23 | @apply visible z-50 p-1 rounded border border-gray-200 bg-gray-100 text-gray-600 shadow-lg ml-4 text-sm;
24 | }
25 |
26 | /* custom markdown styling */
27 | .markdown h1 {
28 | @apply text-3xl tracking-tight font-black text-black mt-2 mb-4;
29 | }
30 |
31 | .markdown h2 {
32 | @apply text-2xl tracking-tight font-black text-black mt-2 mb-3;
33 | }
34 |
35 | .markdown h3 {
36 | @apply text-xl tracking-tight font-black text-black mt-2 mb-3;
37 | }
38 |
39 | .markdown h4 {
40 | @apply text-lg tracking-tight font-black text-black mt-2 mb-3;
41 | }
42 |
43 | .markdown h5 {
44 | @apply text-base tracking-tight font-black text-black mt-2 mb-3;
45 | }
46 |
47 | .markdown h6 {
48 | @apply text-sm tracking-tight font-black text-black mt-2 mb-3;
49 | }
50 |
51 | .markdown p {
52 | @apply my-3;
53 | }
54 |
55 | .markdown a {
56 | @apply text-pink-600 underline;
57 | }
58 |
59 | .markdown ul {
60 | @apply my-3 list-disc ml-6;
61 | }
62 |
63 | .markdown ul ul {
64 | @apply my-0;
65 | }
66 |
67 | .markdown ol {
68 | @apply my-3 list-decimal ml-6;
69 | }
70 |
71 | .markdown ol ol {
72 | @apply my-0;
73 | }
74 |
75 | .markdown blockquote {
76 | @apply my-3 rounded-r-3xl px-3 py-1 bg-gray-100 text-gray-600;
77 | }
78 |
79 | .markdown hr {
80 | @apply my-5;
81 | }
82 |
83 | .markdown code {
84 | @apply break-all;
85 | }
86 |
--------------------------------------------------------------------------------
/web/assets/auth-withssb-uri.js:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | const ssbUriLink = document.querySelector('#start-auth-uri');
6 | const waitingElem = document.querySelector('#waiting');
7 | const errorElem = document.querySelector('#failed');
8 | const challengeElem = document.querySelector('#challenge');
9 |
10 | const sc = challengeElem.dataset.sc;
11 | const evtSource = new EventSource(`/withssb/events?sc=${sc}`);
12 | let otherTab;
13 |
14 | ssbUriLink.onclick = function handleURI(ev) {
15 | ev.preventDefault();
16 | const ssbUri = ssbUriLink.href;
17 | waitingElem.classList.remove('hidden');
18 | otherTab = window.open(ssbUri, '_blank');
19 | };
20 |
21 | evtSource.onerror = (e) => {
22 | waitingElem.classList.add('hidden');
23 | errorElem.classList.remove('hidden');
24 | console.error(e.data);
25 | if (otherTab) otherTab.close();
26 | };
27 |
28 | evtSource.addEventListener('failed', (e) => {
29 | waitingElem.classList.add('hidden');
30 | errorElem.classList.remove('hidden');
31 | console.error(e.data);
32 | if (otherTab) otherTab.close();
33 | });
34 |
35 | // prepare for the case that the success event happens while the browser is not on screen.
36 | let hasFocus = true;
37 | window.addEventListener('blur', () => {
38 | hasFocus = false;
39 | });
40 |
41 | evtSource.addEventListener('success', (e) => {
42 | waitingElem.classList.add('hidden');
43 | evtSource.close();
44 | if (otherTab) otherTab.close();
45 | const redirectTo = `/withssb/finalize?token=${e.data}`;
46 | if (hasFocus) {
47 | window.location.replace(redirectTo);
48 | } else {
49 | // wait for the browser to be back in focus and redirect then
50 | window.addEventListener('focus', () => {
51 | window.location.replace(redirectTo);
52 | });
53 | }
54 | });
55 |
--------------------------------------------------------------------------------
/roomdb/sqlite/models/sqlite_upsert.go:
--------------------------------------------------------------------------------
1 | // Code generated by SQLBoiler 4.14.2 (https://github.com/volatiletech/sqlboiler). DO NOT EDIT.
2 | // This file is meant to be re-generated in place and/or deleted at any time.
3 |
4 | package models
5 |
6 | import (
7 | "fmt"
8 | "strings"
9 |
10 | "github.com/volatiletech/sqlboiler/v4/drivers"
11 | "github.com/volatiletech/strmangle"
12 | )
13 |
14 | // buildUpsertQuerySQLite builds a SQL statement string using the upsertData provided.
15 | func buildUpsertQuerySQLite(dia drivers.Dialect, tableName string, updateOnConflict bool, ret, update, conflict, whitelist []string) string {
16 | conflict = strmangle.IdentQuoteSlice(dia.LQ, dia.RQ, conflict)
17 | whitelist = strmangle.IdentQuoteSlice(dia.LQ, dia.RQ, whitelist)
18 | ret = strmangle.IdentQuoteSlice(dia.LQ, dia.RQ, ret)
19 |
20 | buf := strmangle.GetBuffer()
21 | defer strmangle.PutBuffer(buf)
22 |
23 | columns := "DEFAULT VALUES"
24 | if len(whitelist) != 0 {
25 | columns = fmt.Sprintf("(%s) VALUES (%s)",
26 | strings.Join(whitelist, ", "),
27 | strmangle.Placeholders(dia.UseIndexPlaceholders, len(whitelist), 1, 1))
28 | }
29 |
30 | fmt.Fprintf(
31 | buf,
32 | "INSERT INTO %s %s ON CONFLICT ",
33 | tableName,
34 | columns,
35 | )
36 |
37 | if !updateOnConflict || len(update) == 0 {
38 | buf.WriteString("DO NOTHING")
39 | } else {
40 | buf.WriteByte('(')
41 | buf.WriteString(strings.Join(conflict, ", "))
42 | buf.WriteString(") DO UPDATE SET ")
43 |
44 | for i, v := range update {
45 | if i != 0 {
46 | buf.WriteByte(',')
47 | }
48 | quoted := strmangle.IdentQuote(dia.LQ, dia.RQ, v)
49 | buf.WriteString(quoted)
50 | buf.WriteString(" = EXCLUDED.")
51 | buf.WriteString(quoted)
52 | }
53 | }
54 |
55 | if len(ret) != 0 {
56 | buf.WriteString(" RETURNING ")
57 | buf.WriteString(strings.Join(ret, ", "))
58 | }
59 |
60 | return buf.String()
61 | }
62 |
--------------------------------------------------------------------------------
/internal/aliases/confirm.go:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | // Package aliases implements the validation and signing features of https://ssbc.github.io/rooms2/#alias
6 | package aliases
7 |
8 | import (
9 | "bytes"
10 |
11 | "golang.org/x/crypto/ed25519"
12 |
13 | refs "github.com/ssbc/go-ssb-refs"
14 | )
15 |
16 | // Registration ties an alias to the ID of the user and the RoomID it should be registered on
17 | type Registration struct {
18 | Alias string
19 | UserID refs.FeedRef
20 | RoomID refs.FeedRef
21 | }
22 |
23 | // Sign takes the public key (belonging to UserID) and returns the signed confirmation
24 | func (r Registration) Sign(privKey ed25519.PrivateKey) Confirmation {
25 | var conf Confirmation
26 | conf.Registration = r
27 | msg := r.createRegistrationMessage()
28 | conf.Signature = ed25519.Sign(privKey, msg)
29 | return conf
30 | }
31 |
32 | // createRegistrationMessage returns the string of bytes that should be signed
33 | func (r Registration) createRegistrationMessage() []byte {
34 | var message bytes.Buffer
35 | message.WriteString("=room-alias-registration:")
36 | message.WriteString(r.RoomID.String())
37 | message.WriteString(":")
38 | message.WriteString(r.UserID.String())
39 | message.WriteString(":")
40 | message.WriteString(r.Alias)
41 | return message.Bytes()
42 | }
43 |
44 | // Confirmation combines a registration with the corresponding signature
45 | type Confirmation struct {
46 | Registration
47 |
48 | Signature []byte
49 | }
50 |
51 | // Verify checks that the confirmation is for the expected room and from the expected feed
52 | func (c Confirmation) Verify() bool {
53 | // re-construct the registration
54 | message := c.createRegistrationMessage()
55 |
56 | // check the signature matches
57 | return ed25519.Verify(c.UserID.PubKey(), message, c.Signature)
58 | }
59 |
--------------------------------------------------------------------------------
/web/templates/admin/denied-keys-remove-confirm.tmpl:
--------------------------------------------------------------------------------
1 |
6 |
7 | {{ define "title" }}{{i18n "AdminDeniedKeysRemoveConfirmTitle"}}{{ end }}
8 | {{ define "content" }}
9 | {{.Invite.CreatedAt.Format "2006-01-02T15:04:05.00"}} ({{$creator}})
25 |
26 |
41 |
10 |
11 | {{i18n "AdminDeniedKeysRemoveConfirmWelcome"}}
15 |
16 |
48 | {{end}}
49 |
--------------------------------------------------------------------------------
/internal/network/conntracker_acceptAll.go:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | package network
6 |
7 | import (
8 | "context"
9 | "net"
10 | "sync"
11 | "time"
12 | )
13 |
14 | // This just keeps a count and doesn't actually track anything
15 | func NewAcceptAllTracker() ConnTracker {
16 | return &acceptAllTracker{}
17 | }
18 |
19 | type acceptAllTracker struct {
20 | countLock sync.Mutex
21 | conns []net.Conn
22 | }
23 |
24 | func (ct *acceptAllTracker) CloseAll() {
25 | ct.countLock.Lock()
26 | defer ct.countLock.Unlock()
27 | for _, c := range ct.conns {
28 | c.Close()
29 | }
30 | ct.conns = []net.Conn{}
31 | }
32 |
33 | func (ct *acceptAllTracker) Count() uint {
34 | ct.countLock.Lock()
35 | defer ct.countLock.Unlock()
36 | return uint(len(ct.conns))
37 | }
38 |
39 | func (ct *acceptAllTracker) Active(a net.Addr) (bool, time.Duration) {
40 | ct.countLock.Lock()
41 | defer ct.countLock.Unlock()
42 | for _, c := range ct.conns {
43 | if sameByRemote(c, a) {
44 | return true, 0
45 | }
46 | }
47 | return false, 0
48 | }
49 |
50 | func (ct *acceptAllTracker) OnAccept(ctx context.Context, conn net.Conn) (bool, context.Context) {
51 | ct.countLock.Lock()
52 | defer ct.countLock.Unlock()
53 | ct.conns = append(ct.conns, conn)
54 | return true, ctx
55 | }
56 |
57 | func (ct *acceptAllTracker) OnClose(conn net.Conn) time.Duration {
58 | ct.countLock.Lock()
59 | defer ct.countLock.Unlock()
60 | for i, c := range ct.conns {
61 |
62 | if sameByRemote(c, conn.RemoteAddr()) {
63 | // remove from array, replace style
64 | ct.conns[i] = ct.conns[len(ct.conns)-1]
65 | ct.conns[len(ct.conns)-1] = nil
66 | ct.conns = ct.conns[:len(ct.conns)-1]
67 | return 1
68 | }
69 |
70 | }
71 |
72 | return 0
73 | }
74 |
75 | func sameByRemote(a net.Conn, b net.Addr) bool {
76 | return a.RemoteAddr().String() == b.String()
77 | }
78 |
--------------------------------------------------------------------------------
/web/templates/invite/facade-fallback.tmpl:
--------------------------------------------------------------------------------
1 |
6 |
7 | {{ define "title" }}{{ i18n "InviteFacadeTitle" }}{{ end }}
8 | {{ define "content" }}
9 | {{.Entry.PubKey.String}}
20 |
21 |
22 | {{human_time .Entry.CreatedAt}}
23 | {{.Entry.CreatedAt.Format "2006-01-02T15:04:05.00"}}
24 |
25 |
26 | {{i18n "AdminDeniedKeysCommentDescription"}}
30 | {{.Entry.Comment}}
31 | 32 | 47 |
10 |
20 | 21 |
30 | {{ end }}
--------------------------------------------------------------------------------
/internal/signinwithssb/bridge_test.go:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | package signinwithssb
6 |
7 | import (
8 | "fmt"
9 | "testing"
10 | "time"
11 |
12 | "github.com/stretchr/testify/assert"
13 | )
14 |
15 | func TestBridgeWorked(t *testing.T) {
16 | t.Parallel()
17 |
18 | a := assert.New(t)
19 |
20 | sb := NewSignalBridge()
21 |
22 | // try to use a non-existant session
23 | err := sb.SessionWorked("nope", "just a test")
24 | a.Error(err)
25 |
26 | // make a new session
27 | sc := sb.RegisterSession()
28 |
29 | b, err := DecodeChallengeString(sc)
30 | a.NoError(err)
31 | a.Len(b, challengeLength)
32 |
33 | updates, has := sb.GetEventChannel(sc)
34 | a.True(has)
35 |
36 | go func() {
37 | err := sb.SessionWorked(sc, "a token")
38 | a.NoError(err)
39 | }()
40 |
41 | time.Sleep(time.Second / 4)
42 |
43 | select {
44 | case evt := <-updates:
45 | a.True(evt.Worked)
46 | a.Equal("a token", evt.Token)
47 | a.Nil(evt.Reason)
48 | default:
49 | t.Error("no updates")
50 | }
51 | }
52 |
53 | func TestBridgeFailed(t *testing.T) {
54 | t.Parallel()
55 |
56 | a := assert.New(t)
57 |
58 | sb := NewSignalBridge()
59 |
60 | // try to use a non-existant session
61 | testReason := fmt.Errorf("just an error")
62 | err := sb.SessionFailed("nope", testReason)
63 | a.Error(err)
64 |
65 | // make a new session
66 | sc := sb.RegisterSession()
67 |
68 | b, err := DecodeChallengeString(sc)
69 | a.NoError(err)
70 | a.Len(b, challengeLength)
71 |
72 | updates, has := sb.GetEventChannel(sc)
73 | a.True(has)
74 |
75 | go func() {
76 | err := sb.SessionFailed(sc, testReason)
77 | a.NoError(err)
78 | }()
79 |
80 | time.Sleep(time.Second / 4)
81 |
82 | select {
83 | case evt := <-updates:
84 | a.False(evt.Worked)
85 | a.Equal("", evt.Token)
86 | a.EqualError(testReason, evt.Reason.Error())
87 | default:
88 | t.Error("no updates")
89 | }
90 | }
91 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 |
6 |
7 | # Go-SSB Room
8 | [](https://api.reuse.software/info/github.com/ssbc/go-ssb-room)
9 |
10 | This repository implements the [Room (v1+v2) server spec](https://github.com/ssbc/rooms2), in Go.
11 |
12 | It includes:
13 | * secret-handshake+boxstream network transport, sometimes referred to as SHS, using [secretstream](https://github.com/ssbc/go-secretstream)
14 | * muxrpc handlers for tunneling connections
15 | * a fully embedded HTTP server & HTML frontend, for administering the room
16 |
17 | 
18 |
19 | See [this project](https://github.com/orgs/ssbc/projects/2) for current focus.
20 |
21 | ## :star: Features
22 |
23 | * Rooms v1 (`tunnel.connect`, `tunnel.endpoints`, etc.)
24 | * User management (allow- & denylisting + moderator & administrator roles), all administered via the web dashboard
25 | * Multiple [privacy modes](https://ssbc.github.io/rooms2/#privacy-modes)
26 | * [Sign-in with SSB](https://ssbc.github.io/ssb-http-auth-spec/)
27 | * [HTTP Invites](https://github.com/ssbc/ssb-http-invite-spec)
28 | * Alias management
29 |
30 | For a comprehensive introduction to rooms 2.0, 🎥 [watch this video](https://www.youtube.com/watch?v=W5p0y_MWwDE).
31 | For a description of MuxRPC APIs see https://github.com/ssbc/rooms2
32 |
33 | ## :rocket: Deployment
34 |
35 | If you want to deploy a room server yourself, follow our [deployment.md](./docs/deployment.md) docs.
36 |
37 | ## :wrench: Development
38 |
39 | For an in-depth codebase walkthrough, see the [development.md](./docs/development.md) file in the `docs` folder of this repository.
40 |
41 | ## :people_holding_hands: Authors
42 |
43 | * [cryptix](https://github.com/cryptix) (`@p13zSAiOpguI9nsawkGijsnMfWmFd5rlUNpzekEE+vI=.ed25519`)
44 | * [staltz](https://github.com/staltz)
45 | * [cblgh](https://github.com/cblgh)
46 |
47 | ## License
48 |
49 | MIT
50 |
--------------------------------------------------------------------------------
/muxrpc/test/nodejs/aliases_test.go:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | package nodejs_test
6 |
7 | import (
8 | "testing"
9 | "time"
10 |
11 | "github.com/stretchr/testify/assert"
12 | "github.com/stretchr/testify/require"
13 |
14 | "github.com/ssbc/go-ssb-room/v2/internal/aliases"
15 | "github.com/ssbc/go-ssb-room/v2/roomdb"
16 | "github.com/ssbc/go-ssb-room/v2/roomdb/mockdb"
17 | )
18 |
19 | func TestGoServerJSClientAliases(t *testing.T) {
20 | a := assert.New(t)
21 | r := require.New(t)
22 |
23 | ts := newRandomSession(t)
24 | // ts := newSession(t, nil)
25 |
26 | var membersDB = &mockdb.FakeMembersService{}
27 | var aliasesDB = &mockdb.FakeAliasesService{}
28 | srv := ts.startGoServer(membersDB, aliasesDB)
29 | // allow all peers (there arent any we dont want to allow)
30 | membersDB.GetByFeedReturns(roomdb.Member{ID: 1234}, nil)
31 |
32 | // setup mocks for this test
33 | aliasesDB.RegisterReturns(nil)
34 |
35 | alice := ts.startJSClient("alice", "./testscripts/modern_aliases.js",
36 | srv.Network.GetListenAddr(),
37 | srv.Whoami(),
38 | )
39 |
40 | // the revoke call checks who the alias belongs to
41 | aliasesDB.ResolveReturns(roomdb.Alias{
42 | Name: "alice",
43 | Feed: alice,
44 | }, nil)
45 |
46 | time.Sleep(5 * time.Second)
47 |
48 | // wait for both to exit
49 | ts.wait()
50 |
51 | r.Equal(1, aliasesDB.RegisterCallCount(), "register call count")
52 | _, name, ref, signature := aliasesDB.RegisterArgsForCall(0)
53 | a.Equal("alice", name, "wrong alias registered")
54 | a.Equal(alice.String(), ref.String())
55 |
56 | var aliasReq aliases.Confirmation
57 | aliasReq.Alias = name
58 | aliasReq.Signature = signature
59 | aliasReq.UserID = alice
60 | aliasReq.RoomID = srv.Whoami()
61 |
62 | a.True(aliasReq.Verify(), "signature validation")
63 |
64 | r.Equal(1, aliasesDB.RevokeCallCount(), "revoke call count")
65 | _, name = aliasesDB.RevokeArgsForCall(0)
66 | a.Equal("alice", name, "wrong alias revoked")
67 |
68 | }
69 |
--------------------------------------------------------------------------------
/web/templates/change-member-password.tmpl:
--------------------------------------------------------------------------------
1 |
6 |
7 | {{ define "title" }}{{ i18n "AuthFallbackPasswordChangeFormTitle" }}{{ end }}
8 | {{ define "content" }}
9 | {{i18n "SSBURIFailureWelcome"}}
11 | 12 |
13 | {{i18n "SSBURIFailureInstallManyverse"}}
17 |
18 |
19 | 20 | 21 |
Or if you already have an SSB app (such as Patchwork, Patchbay, Patchfoo, Oasis, Planetary) and it couldn't process the link for whatever reason, you can manually input your identifier here:
24 | 25 | {{i18n "InviteFacadeFallbackInsertID"}} 29 |
10 | {{i18n "AuthFallbackPasswordChangeWelcome"}}
11 |
12 | {{ template "flashes" . }}
13 |
14 |
52 |
53 | {{ end }}
54 |
--------------------------------------------------------------------------------
/web/router/complete.go:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | package router
6 |
7 | import (
8 | "github.com/gorilla/mux"
9 | )
10 |
11 | // constant names for the named routes
12 | const (
13 | CompleteIndex = "complete:index"
14 |
15 | CompleteNoticeShow = "complete:notice:show"
16 | CompleteNoticeList = "complete:notice:list"
17 |
18 | CompleteSetLanguage = "complete:set-language"
19 |
20 | CompleteAliasResolve = "complete:alias:resolve"
21 |
22 | CompleteInviteFacade = "complete:invite:accept"
23 | CompleteInviteFacadeFallback = "complete:invite:accept:fallback"
24 | CompleteInviteInsertID = "complete:invite:insert-id"
25 | CompleteInviteConsume = "complete:invite:consume"
26 |
27 | MembersChangePasswordForm = "members:change-password:form"
28 | MembersChangePassword = "members:change-password"
29 |
30 | OpenModeCreateInvite = "open:invites:create"
31 | )
32 |
33 | // CompleteApp constructs a mux.Router containing the routes for batch Complete html frontend
34 | func CompleteApp() *mux.Router {
35 | m := mux.NewRouter()
36 |
37 | Auth(m)
38 | Admin(m.PathPrefix("/admin").Subrouter())
39 |
40 | m.Path("/").Methods("GET").Name(CompleteIndex)
41 |
42 | m.Path("/alias/{alias}").Methods("GET").Name(CompleteAliasResolve)
43 |
44 | m.Path("/members/change-password").Methods("GET").Name(MembersChangePasswordForm)
45 | m.Path("/members/change-password").Methods("POST").Name(MembersChangePassword)
46 |
47 | m.Path("/create-invite").Methods("GET", "POST").Name(OpenModeCreateInvite)
48 | m.Path("/join").Methods("GET").Name(CompleteInviteFacade)
49 | m.Path("/join-fallback").Methods("GET").Name(CompleteInviteFacadeFallback)
50 | m.Path("/join-manually").Methods("GET").Name(CompleteInviteInsertID)
51 | m.Path("/invite/consume").Methods("POST").Name(CompleteInviteConsume)
52 |
53 | m.Path("/notice/show").Methods("GET").Name(CompleteNoticeShow)
54 | m.Path("/notice/list").Methods("GET").Name(CompleteNoticeList)
55 |
56 | m.Path("/set-language").Methods("POST").Name(CompleteSetLanguage)
57 |
58 | return m
59 | }
60 |
--------------------------------------------------------------------------------
/roomdb/sqlite/migrations/04-overhaul-fallback-auth.sql:
--------------------------------------------------------------------------------
1 | -- SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | --
3 | -- SPDX-License-Identifier: CC0-1.0
4 |
5 | -- +migrate Up
6 |
7 | -- drop login column from fallback pw
8 | -- ==================================
9 |
10 | -- this is sqlite style ALTER TABLE abc DROP COLUMN
11 | -- See 5) in https://www.sqlite.org/lang_altertable.html
12 | -- and https://www.sqlitetutorial.net/sqlite-alter-table/
13 |
14 | -- drop obsolete index
15 | DROP INDEX fallback_passwords_by_login;
16 |
17 | -- create new schema table (without 'login' column)
18 | CREATE TABLE updated_passwords_table (
19 | id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
20 | password_hash BLOB NOT NULL,
21 |
22 | member_id INTEGER UNIQUE NOT NULL,
23 |
24 | FOREIGN KEY ( member_id ) REFERENCES members( "id" ) ON DELETE CASCADE
25 | );
26 |
27 | -- copy existing values from original table into new
28 | INSERT INTO updated_passwords_table(id, password_hash, member_id)
29 | SELECT id, password_hash, member_id
30 | FROM fallback_passwords;
31 |
32 | -- rename the new to the original table name
33 | DROP TABLE fallback_passwords;
34 | ALTER TABLE updated_passwords_table RENAME TO fallback_passwords;
35 |
36 | -- create new lookup index by member id
37 | CREATE INDEX fallback_passwords_by_member ON fallback_passwords(member_id);
38 |
39 | -- add new table for password reset tokens
40 | --========================================
41 | CREATE TABLE fallback_reset_tokens (
42 | id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
43 | hashed_token TEXT UNIQUE NOT NULL,
44 | created_by INTEGER NOT NULL,
45 | created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
46 |
47 | for_member INTEGER NOT NULL,
48 |
49 | active boolean NOT NULL DEFAULT TRUE,
50 |
51 | FOREIGN KEY ( created_by ) REFERENCES members( "id" ) ON DELETE CASCADE
52 | FOREIGN KEY ( for_member ) REFERENCES members( "id" ) ON DELETE CASCADE
53 | );
54 | CREATE INDEX fallback_reset_tokens_by_token ON fallback_reset_tokens(hashed_token);
55 |
56 | -- +migrate Down
57 | DROP INDEX fallback_passwords_by_member;
58 | DROP TABLE fallback_passwords;
59 |
60 | DROP TABLE fallback_reset_tokens;
--------------------------------------------------------------------------------
/internal/network/isserver_test.go:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | package network_test
6 |
7 | import (
8 | "context"
9 | "crypto/rand"
10 | "net"
11 | "os"
12 | "testing"
13 |
14 | "github.com/ssbc/go-ssb-room/v2/internal/maybemod/keys"
15 | "github.com/ssbc/go-ssb-room/v2/internal/network"
16 | "go.mindeco.de/log"
17 |
18 | "github.com/ssbc/go-muxrpc/v2"
19 |
20 | "github.com/stretchr/testify/require"
21 | )
22 |
23 | func TestIsServer(t *testing.T) {
24 | r := require.New(t)
25 |
26 | ctx := context.Background()
27 |
28 | var appkey = make([]byte, 32)
29 | rand.Read(appkey)
30 |
31 | logger := log.NewLogfmtLogger(os.Stderr)
32 |
33 | kpClient, err := keys.NewKeyPair(nil)
34 | r.NoError(err)
35 |
36 | kpServ, err := keys.NewKeyPair(nil)
37 | r.NoError(err)
38 |
39 | client, err := network.New(network.Options{
40 | Logger: logger,
41 | AppKey: appkey,
42 | KeyPair: kpClient,
43 |
44 | MakeHandler: makeServerHandler(t, true),
45 | })
46 | r.NoError(err)
47 |
48 | server, err := network.New(network.Options{
49 | Logger: logger,
50 | AppKey: appkey,
51 | KeyPair: kpServ,
52 |
53 | ListenAddr: &net.TCPAddr{Port: 0}, // any random port
54 |
55 | MakeHandler: makeServerHandler(t, false),
56 | })
57 | r.NoError(err)
58 |
59 | go func() {
60 | err = server.Serve(ctx)
61 | if err != nil {
62 | panic(err)
63 | }
64 | }()
65 |
66 | err = client.Connect(ctx, server.GetListenAddr())
67 | r.NoError(err)
68 |
69 | client.Close()
70 | server.Close()
71 | }
72 |
73 | type testHandler struct {
74 | t *testing.T
75 | wantServer bool
76 | }
77 |
78 | func (testHandler) Handled(muxrpc.Method) bool { return true }
79 |
80 | func (th testHandler) HandleConnect(ctx context.Context, e muxrpc.Endpoint) {
81 | require.Equal(th.t, th.wantServer, muxrpc.IsServer(e), "server assertion failed")
82 | }
83 |
84 | func (th testHandler) HandleCall(ctx context.Context, req *muxrpc.Request) {}
85 |
86 | func makeServerHandler(t *testing.T, wantServer bool) func(net.Conn) (muxrpc.Handler, error) {
87 | return func(_ net.Conn) (muxrpc.Handler, error) {
88 | return testHandler{t, wantServer}, nil
89 | }
90 | }
91 |
--------------------------------------------------------------------------------
/roomsrv/init_network.go:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | package roomsrv
6 |
7 | import (
8 | "fmt"
9 | "net"
10 |
11 | "github.com/ssbc/go-muxrpc/v2"
12 |
13 | "github.com/ssbc/go-ssb-room/v2/internal/network"
14 | "github.com/ssbc/go-ssb-room/v2/roomdb"
15 | )
16 |
17 | // opens the shs listener for TCP connections
18 | func (s *Server) initNetwork() error {
19 | // muxrpc handler creation and authoratization decider
20 | mkHandler := func(conn net.Conn) (muxrpc.Handler, error) {
21 | s.closedMu.Lock()
22 | defer s.closedMu.Unlock()
23 |
24 | remote, err := network.GetFeedRefFromAddr(conn.RemoteAddr())
25 | if err != nil {
26 | return nil, fmt.Errorf("sbot: expected an address containing an shs-bs addr: %w", err)
27 | }
28 |
29 | if s.keyPair.Feed.Equal(remote) {
30 | return &s.master, nil
31 | }
32 |
33 | pm, err := s.Config.GetPrivacyMode(s.rootCtx)
34 | if err != nil {
35 | return nil, fmt.Errorf("running with unknown privacy mode")
36 | }
37 |
38 | // if privacy mode is restricted, deny connections from non-members
39 | if pm == roomdb.ModeRestricted {
40 | if _, err := s.Members.GetByFeed(s.rootCtx, remote); err != nil {
41 | return nil, fmt.Errorf("access restricted to members")
42 | }
43 | }
44 |
45 | // if feed is in the deny list, deny their connection
46 | if s.DeniedKeys.HasFeed(s.rootCtx, remote) {
47 | return nil, fmt.Errorf("this key has been banned")
48 | }
49 |
50 | // for community + open modes, allow all connections
51 | return &s.public, nil
52 | }
53 |
54 | // tcp+shs
55 | opts := network.Options{
56 | Logger: s.logger,
57 | Dialer: s.dialer,
58 | ListenAddr: s.listenAddr,
59 | KeyPair: s.keyPair,
60 | AppKey: s.appKey[:],
61 | MakeHandler: mkHandler,
62 | ConnTracker: s.networkConnTracker,
63 | BefreCryptoWrappers: s.preSecureWrappers,
64 | AfterSecureWrappers: s.postSecureWrappers,
65 | }
66 |
67 | var err error
68 | s.Network, err = network.New(opts)
69 | if err != nil {
70 | return fmt.Errorf("failed to create network node: %w", err)
71 | }
72 |
73 | return nil
74 | }
75 |
--------------------------------------------------------------------------------
/muxrpc/handlers/tunnel/server/plugin.go:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | package server
6 |
7 | import (
8 | "github.com/ssbc/go-muxrpc/v2"
9 | "github.com/ssbc/go-muxrpc/v2/typemux"
10 | kitlog "go.mindeco.de/log"
11 |
12 | "github.com/ssbc/go-ssb-room/v2/internal/network"
13 | "github.com/ssbc/go-ssb-room/v2/roomdb"
14 | "github.com/ssbc/go-ssb-room/v2/roomstate"
15 | )
16 |
17 | /* manifest:
18 | {
19 | "announce": "sync",
20 | "leave": "sync",
21 | "connect": "duplex",
22 | "endpoints": "source",
23 | "isRoom": "async",
24 | "ping": "sync",
25 | }
26 | */
27 |
28 | func New(log kitlog.Logger, netInfo network.ServerEndpointDetails, m *roomstate.Manager, members roomdb.MembersService, config roomdb.RoomConfig) *Handler {
29 | var h = new(Handler)
30 | h.netInfo = netInfo
31 | h.logger = log
32 | h.state = m
33 | h.membersdb = members
34 | h.config = config
35 |
36 | return h
37 | }
38 |
39 | func (h *Handler) RegisterTunnel(mux typemux.HandlerMux) {
40 | var namespace = muxrpc.Method{"tunnel"}
41 | mux.RegisterAsync(append(namespace, "isRoom"), typemux.AsyncFunc(h.metadata))
42 | mux.RegisterAsync(append(namespace, "ping"), typemux.AsyncFunc(h.ping))
43 |
44 | mux.RegisterAsync(append(namespace, "announce"), typemux.AsyncFunc(h.announce))
45 | mux.RegisterAsync(append(namespace, "leave"), typemux.AsyncFunc(h.leave))
46 |
47 | mux.RegisterSource(append(namespace, "endpoints"), typemux.SourceFunc(h.endpoints))
48 |
49 | mux.RegisterDuplex(append(namespace, "connect"), connectHandler{
50 | logger: h.logger,
51 | self: h.netInfo.RoomID,
52 | state: h.state,
53 | })
54 | }
55 |
56 | func (h *Handler) RegisterRoom(mux typemux.HandlerMux) {
57 | var namespace = muxrpc.Method{"room"}
58 | mux.RegisterAsync(append(namespace, "metadata"), typemux.AsyncFunc(h.metadata))
59 | mux.RegisterAsync(append(namespace, "ping"), typemux.AsyncFunc(h.ping))
60 |
61 | mux.RegisterSource(append(namespace, "attendants"), typemux.SourceFunc(h.attendants))
62 | mux.RegisterSource(append(namespace, "members"), typemux.SourceFunc(h.members))
63 |
64 | mux.RegisterDuplex(append(namespace, "connect"), connectHandler{
65 | logger: h.logger,
66 | self: h.netInfo.RoomID,
67 | state: h.state,
68 | })
69 | }
70 |
--------------------------------------------------------------------------------
/web/templates/admin/notice-edit.tmpl:
--------------------------------------------------------------------------------
1 |
6 |
7 | {{ define "title" }}{{i18n "NoticeEditTitle"}}{{ end }}
8 | {{ define "content" }}
9 |
10 | {{ template "flashes" . }}
11 |
12 |
64 | {{end}}
--------------------------------------------------------------------------------
/web/errors/badrequest.go:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | // Package errors defines some well defined errors, like incomplete/wrong request data or object not found(404), for the purpose of internationalization.
6 | package errors
7 |
8 | import (
9 | "errors"
10 | "fmt"
11 | )
12 |
13 | var (
14 | ErrNotAuthorized = errors.New("rooms/web: not authorized")
15 |
16 | ErrDenied = errors.New("rooms: this key has been banned")
17 | )
18 |
19 | // ErrGenericLocalized is used for one-off errors that primarily are presented for the user.
20 | // The contained label is passed to the i18n engine for translation.
21 | type ErrGenericLocalized struct{ Label string }
22 |
23 | func (err ErrGenericLocalized) Error() string {
24 | return fmt.Sprintf("rooms/web: localized error (%s)", err.Label)
25 | }
26 |
27 | type ErrNotFound struct{ What string }
28 |
29 | func (nf ErrNotFound) Error() string {
30 | return fmt.Sprintf("rooms/web: item not found: %s", nf.What)
31 | }
32 |
33 | type ErrBadRequest struct {
34 | Where string
35 | Details error
36 | }
37 |
38 | func (err ErrBadRequest) Unwrap() error {
39 | return err.Details
40 | }
41 |
42 | func (br ErrBadRequest) Error() string {
43 | return fmt.Sprintf("rooms/web: bad request error: %s", br.Details)
44 | }
45 |
46 | type ErrForbidden struct{ Details error }
47 |
48 | func (f ErrForbidden) Error() string {
49 | return fmt.Sprintf("rooms/web: access denied: %s", f.Details)
50 | }
51 |
52 | // ErrRedirect is used when the controller decides to not render a page
53 | type ErrRedirect struct {
54 | Path string
55 |
56 | // reason will be added as a flash error
57 | Reason error
58 | }
59 |
60 | func (err ErrRedirect) Unwrap() error {
61 | return err.Reason
62 | }
63 |
64 | func (err ErrRedirect) Error() string {
65 | return fmt.Sprintf("rooms/web: redirecting to: %s (reason: %s)", err.Path, err.Reason)
66 | }
67 |
68 | type PageNotFound struct{ Path string }
69 |
70 | func (e PageNotFound) Error() string {
71 | return fmt.Sprintf("rooms/web: page not found: %s", e.Path)
72 | }
73 |
74 | type DatabaseError struct{ Reason error }
75 |
76 | func (e DatabaseError) Error() string {
77 | return fmt.Sprintf("rooms/web: database failed to complete query: %s", e.Reason.Error())
78 | }
79 |
--------------------------------------------------------------------------------
/muxrpc/test/nodejs/testscripts/client-opening-tunnel.js:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | const pull = require('pull-stream')
6 | const { readFileSync } = require('fs')
7 | const path = require("path")
8 | const scriptname = path.basename(__filename)
9 |
10 | let newConnections = 0
11 |
12 | module.exports = (t, client, roomrpc, exit) => {
13 | // shadow t.comment to include file making the comment
14 | function comment (msg) {
15 | t.comment(`[${scriptname}] ${msg}`)
16 | }
17 | newConnections++
18 | comment(`new connection: ${roomrpc.id}`)
19 | comment(`total connections: ${newConnections}`)
20 |
21 | if (newConnections > 1) {
22 | comment('more than two connnections, not doing anything')
23 | return
24 | }
25 |
26 | // we are now connected to the room server.
27 | // log all new endpoints
28 | pull(
29 | roomrpc.tunnel.endpoints(),
30 | pull.drain(el => {
31 | comment(`from roomsrv: ${JSON.stringify(el)}`)
32 | }, (err) => {
33 | t.comment('endpoints closed', err)
34 | })
35 | )
36 |
37 | // give the room time to start
38 | setTimeout(() => {
39 | // announce ourselves to the room/tunnel
40 | roomrpc.tunnel.announce((err, ret) => {
41 | t.error(err, 'announce on server')
42 | comment('announced!')
43 |
44 | // put there by the go test process
45 | let roomHandle = readFileSync('endpoint_through_room.txt').toString()
46 | comment(`connecting to room handle: ${roomHandle}`)
47 |
48 | client.conn.connect(roomHandle, (err, tunneledrpc) => {
49 | t.error(err, 'connect through room')
50 | comment(`got a tunnel to: ${tunneledrpc.id}`)
51 |
52 | // check the tunnel connection works
53 | tunneledrpc.testing.working((err, ok) => {
54 | t.error(err, 'testing.working didnt error')
55 | t.true(ok, 'testing.working is true')
56 |
57 | // start leaving after 2s
58 | setTimeout(() => {
59 | roomrpc.tunnel.leave((err, ret) => {
60 | t.error(err, 'tunnel.leave')
61 | comment('left room... exiting in 1s')
62 | setTimeout(exit, 1000)
63 | })
64 | }, 2000)
65 | })
66 | })
67 | })
68 | }, 5000)
69 | }
70 |
--------------------------------------------------------------------------------
/internal/aliases/confirm_test.go:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | package aliases
6 |
7 | import (
8 | "bytes"
9 | "testing"
10 |
11 | refs "github.com/ssbc/go-ssb-refs"
12 | "github.com/ssbc/go-ssb-room/v2/internal/maybemod/keys"
13 | "github.com/stretchr/testify/require"
14 | )
15 |
16 | func TestConfirmation(t *testing.T) {
17 | r := require.New(t)
18 |
19 | // this is our room, it's not a valid feed but thats fine for this test
20 | roomID, err := refs.NewFeedRefFromBytes(bytes.Repeat([]byte("test"), 8), refs.RefAlgoFeedSSB1)
21 | if err != nil {
22 | r.Error(err)
23 | }
24 |
25 | // to make the test deterministic, decided by fair dice roll.
26 | seed := bytes.Repeat([]byte("yeah"), 8)
27 | // our user, who will sign the registration
28 | userKeyPair, err := keys.NewKeyPair(bytes.NewReader(seed))
29 | r.NoError(err)
30 |
31 | // create and fill out the registration for an alias (in this case the name of the test)
32 | var valid Registration
33 | valid.RoomID = roomID
34 | valid.UserID = userKeyPair.Feed
35 | valid.Alias = t.Name()
36 |
37 | // internal function to create the registration string
38 | msg := valid.createRegistrationMessage()
39 | want := "=room-alias-registration:@dGVzdHRlc3R0ZXN0dGVzdHRlc3R0ZXN0dGVzdHRlc3Q=.ed25519:@Rt2aJrtOqWXhBZ5/vlfzeWQ9Bj/z6iT8CMhlr2WWlG4=.ed25519:TestConfirmation"
40 | r.Equal(want, string(msg))
41 |
42 | // create the signed confirmation
43 | confirmation := valid.Sign(userKeyPair.Pair.Secret)
44 |
45 | yes := confirmation.Verify()
46 | r.True(yes, "should be valid for this room and feed")
47 |
48 | // make up another id for the invalid test(s)
49 | otherID, err := refs.NewFeedRefFromBytes(bytes.Repeat([]byte("nope"), 8), refs.RefAlgoFeedSSB1)
50 | if err != nil {
51 | r.Error(err)
52 | }
53 |
54 | confirmation.RoomID = otherID
55 | yes = confirmation.Verify()
56 | r.False(yes, "should not be valid for another room")
57 |
58 | confirmation.RoomID = roomID // restore
59 | confirmation.UserID = otherID
60 | yes = confirmation.Verify()
61 | r.False(yes, "should not be valid for this room but another feed")
62 |
63 | // puncture the signature to emulate an invalid one
64 | confirmation.Signature[0] = confirmation.Signature[0] ^ 1
65 |
66 | yes = confirmation.Verify()
67 | r.False(yes, "should not be valid anymore")
68 |
69 | }
70 |
--------------------------------------------------------------------------------
/web/i18n/i18ntesting/testing.go:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | package i18ntesting
6 |
7 | import (
8 | "bytes"
9 | "fmt"
10 | "io/ioutil"
11 | "os"
12 | "path/filepath"
13 | "testing"
14 |
15 | "github.com/BurntSushi/toml"
16 |
17 | "github.com/ssbc/go-ssb-room/v2/internal/repo"
18 | "github.com/ssbc/go-ssb-room/v2/web/i18n"
19 | )
20 |
21 | // justTheKeys auto generates from the defaults a list of Label = "Label"
22 | // must keep order of input intact
23 | // (at least all the globals before starting with nested plurals)
24 | // also replaces 'one' and 'other' in plurals
25 | func justTheKeys(t *testing.T) []byte {
26 | f, err := i18n.Defaults.Open("active.en.toml")
27 | if err != nil {
28 | t.Fatal(err)
29 | }
30 | justAMap := make(map[string]interface{})
31 | md, err := toml.DecodeReader(f, &justAMap)
32 | if err != nil {
33 | t.Fatal(err)
34 | }
35 |
36 | var buf = &bytes.Buffer{}
37 |
38 | // if we don't produce the same order as the input
39 | // (in go maps are ALWAYS random access when ranged over)
40 | // nested keys (such as plural form) will mess up the global level...
41 | for _, k := range md.Keys() {
42 | key := k.String()
43 | val, has := justAMap[key]
44 | if !has {
45 | // fmt.Println("i18n test warning:", key, "not unmarshaled")
46 | continue
47 | }
48 |
49 | switch tv := val.(type) {
50 |
51 | case string:
52 | fmt.Fprintf(buf, "%s = \"%s\"\n", key, key)
53 |
54 | case map[string]interface{}:
55 | // fmt.Println("i18n test warning: custom map for ", key)
56 |
57 | fmt.Fprintf(buf, "\n[%s]\n", key)
58 | // replace "one" and "other" keys
59 | // with Label and LabelPlural
60 | tv["one"] = key + "Singular"
61 | tv["other"] = key + "Plural"
62 | toml.NewEncoder(buf).Encode(tv)
63 | fmt.Fprintln(buf)
64 |
65 | default:
66 | t.Fatalf("unhandled toml structure under %s: %T\n", key, val)
67 | }
68 | }
69 |
70 | return buf.Bytes()
71 | }
72 |
73 | func WriteReplacement(t *testing.T) {
74 | r := repo.New(filepath.Join("testrun", t.Name()))
75 |
76 | testOverride := filepath.Join(r.GetPath("i18n"), "active.en.toml")
77 | t.Log(testOverride)
78 | os.MkdirAll(filepath.Dir(testOverride), 0700)
79 |
80 | content := justTheKeys(t)
81 |
82 | err := ioutil.WriteFile(testOverride, content, 0700)
83 | if err != nil {
84 | t.Fatal(err)
85 | }
86 | }
87 |
--------------------------------------------------------------------------------
/internal/signinwithssb/challenges.go:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | package signinwithssb
6 |
7 | import (
8 | "bytes"
9 | "crypto/rand"
10 | "encoding/base64"
11 | "fmt"
12 |
13 | "golang.org/x/crypto/ed25519"
14 |
15 | refs "github.com/ssbc/go-ssb-refs"
16 | )
17 |
18 | // sign-in with ssb uses 256-bit nonces
19 | const challengeLength = 32
20 |
21 | // DecodeChallengeString accepts base64 encoded strings and decodes them,
22 | // checks their length to be equal to challengeLength,
23 | // and returns the decoded bytes
24 | func DecodeChallengeString(c string) ([]byte, error) {
25 | challengeBytes, err := base64.URLEncoding.DecodeString(c)
26 | if err != nil {
27 | return nil, fmt.Errorf("invalid challenge encoding: %w", err)
28 | }
29 |
30 | if n := len(challengeBytes); n != challengeLength {
31 | return nil, fmt.Errorf("invalid challenge length: expected %d but got %d", challengeLength, n)
32 | }
33 |
34 | return challengeBytes, nil
35 | }
36 |
37 | // GenerateChallenge returs a base64 encoded string
38 | // with challangeLength bytes of random data
39 | func GenerateChallenge() string {
40 | buf := make([]byte, challengeLength)
41 | rand.Read(buf)
42 | return base64.URLEncoding.EncodeToString(buf)
43 | }
44 |
45 | // ClientPayload is used to create and verify solutions
46 | type ClientPayload struct {
47 | ClientID, ServerID refs.FeedRef
48 |
49 | ClientChallenge string
50 | ServerChallenge string
51 | }
52 |
53 | // recreate the signed message
54 | func (cr ClientPayload) createMessage() []byte {
55 | var msg bytes.Buffer
56 | msg.WriteString("=http-auth-sign-in:")
57 | msg.WriteString(cr.ServerID.String())
58 | msg.WriteString(":")
59 | msg.WriteString(cr.ClientID.String())
60 | msg.WriteString(":")
61 | msg.WriteString(cr.ServerChallenge)
62 | msg.WriteString(":")
63 | msg.WriteString(cr.ClientChallenge)
64 | return msg.Bytes()
65 | }
66 |
67 | // Sign returns the signature created with the passed privateKey
68 | func (cr ClientPayload) Sign(privateKey ed25519.PrivateKey) []byte {
69 | msg := cr.createMessage()
70 | return ed25519.Sign(privateKey, msg)
71 | }
72 |
73 | // Validate checks the signature by calling createMessage() and ed25519.Verify()
74 | // together with the ClientID public key.
75 | func (cr ClientPayload) Validate(signature []byte) bool {
76 | msg := cr.createMessage()
77 | return ed25519.Verify(cr.ClientID.PubKey(), msg, signature)
78 | }
79 |
--------------------------------------------------------------------------------
/roomsrv/init_handlers.go:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | package roomsrv
6 |
7 | import (
8 | muxrpc "github.com/ssbc/go-muxrpc/v2"
9 | "github.com/ssbc/go-muxrpc/v2/typemux"
10 | kitlog "go.mindeco.de/log"
11 |
12 | "github.com/ssbc/go-ssb-room/v2/muxrpc/handlers/alias"
13 | "github.com/ssbc/go-ssb-room/v2/muxrpc/handlers/gossip"
14 | "github.com/ssbc/go-ssb-room/v2/muxrpc/handlers/signinwithssb"
15 | "github.com/ssbc/go-ssb-room/v2/muxrpc/handlers/tunnel/server"
16 | "github.com/ssbc/go-ssb-room/v2/muxrpc/handlers/whoami"
17 | )
18 |
19 | // instantiate and register the muxrpc handlers
20 | func (s *Server) initHandlers() {
21 | // inistaniate handler packages
22 | whoami := whoami.New(s.Whoami())
23 |
24 | tunnelHandler := server.New(
25 | kitlog.With(s.logger, "unit", "tunnel"),
26 | s.netInfo,
27 | s.StateManager,
28 | s.Members,
29 | s.Config,
30 | )
31 |
32 | aliasHandler := alias.New(
33 | kitlog.With(s.logger, "unit", "aliases"),
34 | s.Whoami(),
35 | s.Aliases,
36 | s.netInfo,
37 | )
38 |
39 | siwssbHandler := signinwithssb.New(
40 | kitlog.With(s.logger, "unit", "auth-with-ssb"),
41 | s.Whoami(),
42 | s.netInfo.Domain,
43 | s.Members,
44 | s.authWithSSB,
45 | s.authWithSSBBridge,
46 | )
47 |
48 | // register muxrpc commands
49 | registries := []typemux.HandlerMux{s.public, s.master}
50 |
51 | for _, mux := range registries {
52 | mux.RegisterAsync(muxrpc.Method{"manifest"}, manifest)
53 | mux.RegisterAsync(muxrpc.Method{"whoami"}, whoami)
54 |
55 | // register old room v1 commands
56 | tunnelHandler.RegisterTunnel(mux)
57 |
58 | // register new room v2 commands
59 | tunnelHandler.RegisterRoom(mux)
60 |
61 | var method = muxrpc.Method{"room"}
62 | mux.RegisterAsync(append(method, "registerAlias"), typemux.AsyncFunc(aliasHandler.Register))
63 | mux.RegisterAsync(append(method, "revokeAlias"), typemux.AsyncFunc(aliasHandler.Revoke))
64 | mux.RegisterAsync(append(method, "listAliases"), typemux.AsyncFunc(aliasHandler.List))
65 |
66 | method = muxrpc.Method{"httpAuth"}
67 | mux.RegisterAsync(append(method, "invalidateAllSolutions"), typemux.AsyncFunc(siwssbHandler.InvalidateAllSolutions))
68 | mux.RegisterAsync(append(method, "sendSolution"), typemux.AsyncFunc(siwssbHandler.SendSolution))
69 |
70 | method = muxrpc.Method{"gossip"}
71 | mux.RegisterDuplex(append(method, "ping"), typemux.DuplexFunc(gossip.Ping))
72 | }
73 | }
74 |
--------------------------------------------------------------------------------
/muxrpc/test/nodejs/sbot_serv.js:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | const Path = require('path')
6 | const tapSpec = require('tap-spec')
7 | const tape = require('tape')
8 | const { loadOrCreateSync } = require('ssb-keys')
9 | const theStack = require('secret-stack')
10 | const ssbCaps = require('ssb-caps')
11 |
12 | const testSHSappKey = bufFromEnv('TEST_APPKEY')
13 | let testAppkey = Buffer.from(ssbCaps.shs, 'base64')
14 | if (testSHSappKey !== false) {
15 | testAppkey = testSHSappKey
16 | }
17 |
18 | stackOpts = {caps: {shs: testAppkey } }
19 | let createSbot = theStack(stackOpts)
20 | .use(require('ssb-db2'))
21 | .use(require('ssb-db2/compat/db'))
22 |
23 | const testName = process.env['TEST_NAME']
24 | const testPort = process.env['TEST_PORT']
25 | const testSession = require(process.env['TEST_SESSIONSCRIPT'])
26 |
27 | const path = require("path")
28 | const scriptname = path.basename(__filename)
29 |
30 | // load the plugins needed for this session
31 | for (plug of testSession.secretStackPlugins) {
32 | createSbot = createSbot.use(require(plug))
33 | }
34 |
35 | tape.createStream().pipe(tapSpec()).pipe(process.stderr);
36 | tape(testName, function (t) {
37 | function comment (msg) {
38 | t.comment(`[${scriptname}] ${msg}`)
39 | }
40 | // t.timeoutAfter(30000) // doesn't exit the process
41 | // const tapeTimeout = setTimeout(() => {
42 | // t.comment("test timeout")
43 | // process.exit(1)
44 | // }, 50000)
45 |
46 | function exit() { // call this when you're done
47 | sbot.close()
48 | comment(`closed server: ${testName}`)
49 | // clearTimeout(tapeTimeout)
50 | t.end()
51 | process.exit(0)
52 | }
53 |
54 | const tempRepo = process.env['TEST_REPO']
55 | console.warn("my repo:", tempRepo)
56 | const keys = loadOrCreateSync(Path.join(tempRepo, 'secret'))
57 | const sbot = createSbot({
58 | port: testPort,
59 | path: tempRepo,
60 | keys: keys,
61 | })
62 | const alice = sbot.whoami()
63 |
64 | comment("sbot spawned, running before")
65 |
66 | function ready() {
67 | comment(`server spawned, I am: ${alice.id}`)
68 | console.log(alice.id) // tell go process who our pubkey
69 | }
70 | testSession.before(t, sbot, ready)
71 |
72 | sbot.on("rpc:connect", (remote, isClient) => {
73 | comment(`new connection: ${remote.id}`)
74 | testSession.after(t, sbot, remote, exit)
75 | })
76 | })
77 |
78 | // util
79 | function bufFromEnv(evname) {
80 | const has = process.env[evname]
81 | if (has) {
82 | return Buffer.from(has, 'base64')
83 | }
84 | return false
85 | }
86 |
--------------------------------------------------------------------------------
/internal/broadcasts/endpoints.go:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | package broadcasts
6 |
7 | import (
8 | "io"
9 | "sync"
10 |
11 | "github.com/ssbc/go-ssb-room/v2/internal/maybemod/multierror"
12 | )
13 |
14 | type EndpointsEmitter interface {
15 | Update(members []string) error
16 | io.Closer
17 | }
18 |
19 | // NewEndpointsEmitter returns the Sink, to write to the broadcaster, and the new
20 | // broadcast instance.
21 | func NewEndpointsEmitter() (EndpointsEmitter, *EndpointsBroadcast) {
22 | bcst := EndpointsBroadcast{
23 | mu: &sync.Mutex{},
24 | sinks: make(map[*EndpointsEmitter]struct{}),
25 | }
26 |
27 | return (*endpointsSink)(&bcst), &bcst
28 | }
29 |
30 | // EndpointsBroadcast is an interface for registering one or more Sinks to recieve
31 | // updates.
32 | type EndpointsBroadcast struct {
33 | mu *sync.Mutex
34 | sinks map[*EndpointsEmitter]struct{}
35 | }
36 |
37 | // Register a Sink for updates to be sent. also returns
38 | func (bcst *EndpointsBroadcast) Register(sink EndpointsEmitter) func() {
39 | bcst.mu.Lock()
40 | defer bcst.mu.Unlock()
41 | bcst.sinks[&sink] = struct{}{}
42 |
43 | return func() {
44 | bcst.mu.Lock()
45 | defer bcst.mu.Unlock()
46 | delete(bcst.sinks, &sink)
47 | sink.Close()
48 | }
49 | }
50 |
51 | type endpointsSink EndpointsBroadcast
52 |
53 | // Pour implements the Sink interface.
54 | func (bcst *endpointsSink) Update(members []string) error {
55 |
56 | bcst.mu.Lock()
57 | for s := range bcst.sinks {
58 | err := (*s).Update(members)
59 | if err != nil {
60 | delete(bcst.sinks, s)
61 | }
62 | }
63 | bcst.mu.Unlock()
64 |
65 | return nil
66 | }
67 |
68 | // Close implements the Sink interface.
69 | func (bcst *endpointsSink) Close() error {
70 | var sinks []EndpointsEmitter
71 |
72 | bcst.mu.Lock()
73 | defer bcst.mu.Unlock()
74 |
75 | sinks = make([]EndpointsEmitter, 0, len(bcst.sinks))
76 |
77 | for sink := range bcst.sinks {
78 | sinks = append(sinks, *sink)
79 | }
80 |
81 | var (
82 | wg sync.WaitGroup
83 | me multierror.List
84 | )
85 |
86 | // might be fine without the waitgroup and concurrency
87 |
88 | wg.Add(len(sinks))
89 | for _, sink_ := range sinks {
90 | go func(sink EndpointsEmitter) {
91 | defer wg.Done()
92 |
93 | err := sink.Close()
94 | if err != nil {
95 | me.Errs = append(me.Errs, err)
96 | return
97 | }
98 | }(sink_)
99 | }
100 | wg.Wait()
101 |
102 | if len(me.Errs) == 0 {
103 | return nil
104 | }
105 |
106 | return me
107 | }
108 |
--------------------------------------------------------------------------------
/go.mod:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: Unlicense
4 |
5 | module github.com/ssbc/go-ssb-room/v2
6 |
7 | go 1.16
8 |
9 | require (
10 | filippo.io/edwards25519 v1.0.0 // indirect
11 | github.com/BurntSushi/toml v1.3.1
12 | github.com/PuerkitoBio/goquery v1.8.1
13 | github.com/andybalholm/cascadia v1.3.2 // indirect
14 | github.com/dustin/go-humanize v1.0.1
15 | github.com/friendsofgo/errors v0.9.2
16 | github.com/go-logfmt/logfmt v0.6.0 // indirect
17 | github.com/gomodule/redigo v2.0.0+incompatible // indirect
18 | github.com/gorilla/csrf v1.7.1
19 | github.com/gorilla/mux v1.8.0
20 | github.com/gorilla/securecookie v1.1.1
21 | github.com/gorilla/sessions v1.2.1
22 | github.com/gorilla/websocket v1.5.0
23 | github.com/hashicorp/go-multierror v1.1.1 // indirect
24 | github.com/jinzhu/now v1.1.5 // indirect
25 | github.com/mattevans/pwned-passwords v0.6.0
26 | github.com/mattn/go-sqlite3 v1.14.17
27 | github.com/maxbrunsfeld/counterfeiter/v6 v6.5.0
28 | github.com/mileusna/useragent v1.3.3
29 | github.com/nicksnyder/go-i18n/v2 v2.2.1
30 | github.com/oxtoacart/bpool v0.0.0-20190530202638-03653db5a59c // indirect
31 | github.com/pkg/errors v0.9.1
32 | github.com/rubenv/sql-migrate v1.4.0
33 | github.com/russross/blackfriday/v2 v2.1.0
34 | github.com/shurcooL/httpfs v0.0.0-20190707220628-8d4bc4ba7749 // indirect
35 | github.com/skip2/go-qrcode v0.0.0-20200617195104-da1b6568686e
36 | github.com/spf13/cast v1.5.1 // indirect
37 | github.com/ssbc/go-muxrpc/v2 v2.0.14-0.20221111190521-10382533750c
38 | github.com/ssbc/go-netwrap v0.1.5-0.20221019160355-cd323bb2e29d
39 | github.com/ssbc/go-secretstream v1.2.11-0.20221111164233-4b41f899f844
40 | github.com/ssbc/go-ssb-refs v0.5.2
41 | github.com/stretchr/testify v1.8.4
42 | github.com/throttled/throttled/v2 v2.11.0
43 | github.com/unrolled/secure v1.13.0
44 | github.com/vcraescu/go-paginator/v2 v2.0.0
45 | github.com/volatiletech/sqlboiler/v4 v4.14.2
46 | github.com/volatiletech/strmangle v0.0.4
47 | go.cryptoscope.co/nocomment v0.0.0-20210520094614-fb744e81f810
48 | go.mindeco.de v1.12.0
49 | golang.org/x/crypto v0.9.0
50 | golang.org/x/sync v0.1.0
51 | golang.org/x/text v0.9.0
52 | golang.org/x/tools v0.6.0
53 | golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2 // indirect
54 | gorm.io/gorm v1.25.1 // indirect
55 | modernc.org/sqlite v1.23.0 // indirect
56 | )
57 |
58 | exclude go.cryptoscope.co/ssb v0.0.0-20201207161753-31d0f24b7a79
59 |
60 | // https://github.com/rubenv/sql-migrate/pull/189
61 | // and using branch 'drop-other-drivers' for less dependency pollution (oracaldb and the like)
62 | replace github.com/rubenv/sql-migrate => github.com/cryptix/go-sql-migrate v0.0.0-20210521142015-a3e4d9974764
63 |
--------------------------------------------------------------------------------
/web/handlers/set_language_test.go:
--------------------------------------------------------------------------------
1 | // SPDX-FileCopyrightText: 2021 The NGI Pointer Secure-Scuttlebutt Team of 2020/2021
2 | //
3 | // SPDX-License-Identifier: MIT
4 |
5 | package handlers
6 |
7 | import (
8 | "net/http"
9 | "net/url"
10 | "strings"
11 | "testing"
12 |
13 | "github.com/stretchr/testify/assert"
14 |
15 | "github.com/ssbc/go-ssb-room/v2/web/i18n"
16 | "github.com/ssbc/go-ssb-room/v2/web/router"
17 | )
18 |
19 | func TestLanguageDefaultNoCookie(t *testing.T) {
20 | ts := setup(t)
21 | a := assert.New(t)
22 | route := ts.URLTo(router.CompleteIndex)
23 |
24 | html, res := ts.Client.GetHTML(route)
25 | a.Equal(http.StatusOK, res.Code, "wrong HTTP status code")
26 |
27 | languageForms := html.Find("#visitor-set-language form")
28 | // two languages: english, deutsch => two