Enforce channel keys, invites, +s and +H on the IRC listener (closes #122)

The IRC listener's JOIN now passes the channel key on, INVITE records
the invite, LIST and WHOIS hide +s channels from non-members with the
queries the HTTP API uses, and PRIVMSG to a +H channel gets 404.

The INVITE checks and the channel hashcash check move from the HTTP
handlers into the service, so both transports run the same code. An IRC
client cannot attach a stamp, so its PRIVMSG to a +H channel always
fails that check. The unfiltered channel list query, now unused, is
removed.

Model: opus-5-5

internal/ircserver/integration_test.go

@@ -1239,6 +1239,146 @@ func TestIntegrationModeModerated(t *testing.T) {
 	)
 }
 
+// TestIntegrationModeKey checks that JOIN takes the key of
+// a +k channel as its second parameter.
+func TestIntegrationModeKey(t *testing.T) {
+	t.Parallel()
+
+	env := newTestEnv(t)
+
+	alice := env.dial(t)
+	alice.register("alice")
+	alice.joinAndDrain("#keyed")
+
+	// The IRC listener cannot set +k, so the test sets the
+	// key directly.
+	chID, err := env.database.GetChannelByName(
+		t.Context(), "#keyed",
+	)
+	if err != nil {
+		t.Fatalf("get channel: %v", err)
+	}
+
+	err = env.database.SetChannelKey(t.Context(), chID, "sesame")
+	if err != nil {
+		t.Fatalf("set channel key: %v", err)
+	}
+
+	bob := env.dial(t)
+	bob.register("bob")
+
+	bob.sendAndExpect("JOIN #keyed", " 475 ")
+	bob.sendAndExpect("JOIN #keyed wrong", " 475 ")
+
+	lines := bob.sendAndExpect("JOIN #keyed sesame", " 366 ")
+	assertContains(
+		t, lines, "JOIN #keyed", "bob joins with the key",
+	)
+}
+
+// TestIntegrationModeInviteOnly checks that INVITE lets a
+// user into a +i channel.
+func TestIntegrationModeInviteOnly(t *testing.T) {
+	t.Parallel()
+
+	env := newTestEnv(t)
+
+	alice := env.dial(t)
+	alice.register("alice")
+	alice.joinAndDrain("#invonly")
+	alice.sendAndExpect("MODE #invonly +i", "+i")
+
+	bob := env.dial(t)
+	bob.register("bob")
+
+	bob.sendAndExpect("JOIN #invonly", " 473 ")
+
+	alice.sendAndExpect("INVITE bob #invonly", " 341 ")
+
+	lines := bob.sendAndExpect("JOIN #invonly", " 366 ")
+	assertContains(
+		t, lines, "JOIN #invonly", "bob joins once invited",
+	)
+}
+
+// TestIntegrationModeSecretList checks that LIST shows a +s
+// channel only to its members.
+func TestIntegrationModeSecretList(t *testing.T) {
+	t.Parallel()
+
+	env := newTestEnv(t)
+
+	alice := env.dial(t)
+	alice.register("alice")
+	alice.joinAndDrain("#hidden")
+	alice.joinAndDrain("#visible")
+	alice.sendAndExpect("MODE #hidden +s", "+s")
+
+	bob := env.dial(t)
+	bob.register("bob")
+
+	bobList := bob.sendAndExpect("LIST", " 323 ")
+	assertContains(
+		t, bobList, " 322 bob #visible ", "bob's LIST",
+	)
+	assertNotContains(t, bobList, "#hidden", "bob's LIST")
+
+	aliceList := alice.sendAndExpect("LIST", " 323 ")
+	assertContains(
+		t, aliceList, " 322 alice #hidden ", "alice's LIST",
+	)
+}
+
+// TestIntegrationModeSecretWhois checks that WHOIS names a
+// +s channel only to users on it.
+func TestIntegrationModeSecretWhois(t *testing.T) {
+	t.Parallel()
+
+	env := newTestEnv(t)
+
+	alice := env.dial(t)
+	alice.register("alice")
+	alice.joinAndDrain("#hidden")
+	alice.joinAndDrain("#visible")
+	alice.sendAndExpect("MODE #hidden +s", "+s")
+
+	bob := env.dial(t)
+	bob.register("bob")
+
+	bobWhois := bob.sendAndExpect("WHOIS alice", " 318 ")
+	assertContains(t, bobWhois, "@#visible", "bob's WHOIS")
+	assertNotContains(t, bobWhois, "#hidden", "bob's WHOIS")
+
+	carol := env.dial(t)
+	carol.register("carol")
+	carol.joinAndDrain("#hidden")
+
+	carolWhois := carol.sendAndExpect("WHOIS alice", " 318 ")
+	assertContains(t, carolWhois, "@#hidden", "carol's WHOIS")
+}
+
+// TestIntegrationModeHashcash checks that PRIVMSG to a +H
+// channel is refused, since an IRC client cannot attach a
+// hashcash stamp.
+func TestIntegrationModeHashcash(t *testing.T) {
+	t.Parallel()
+
+	env := newTestEnv(t)
+
+	alice := env.dial(t)
+	alice.register("alice")
+	alice.joinAndDrain("#stamped")
+	alice.sendAndExpect("MODE #stamped +H 2", "+H")
+
+	lines := alice.sendAndExpect(
+		"PRIVMSG #stamped :hello", " 404 ",
+	)
+	assertContains(
+		t, lines, " 404 alice #stamped :Channel requires hashcash",
+		"PRIVMSG refused",
+	)
+}
+
 // TestIntegrationThirdClientObserver verifies that a third
 // client observing the same channel receives messages from
 // the other two.