Add the identity command and serve it on an opt-in HTTP info API

Build slackhq/nebula#1821 ("who is this vpn address?" over a local
HTTP+JSON socket) on the command registry, so the lookup is one command
on every surface and the socket is one more local API.

identity
- `identity [-address <vpn addr>[:port]]`: no address reports this node;
  with one, this node or the peer behind an established tunnel
- Certificate fields only: name, vpn addresses, networks, unsafe
  networks, groups, fingerprint, issuer, validity, cert version; a peer's
  fingerprint is the one nebula computed when it verified the cert
- Port accepted and stripped, 4in6 unmapped, so a RemoteAddr passes
  straight through
- No tunnel is a commands.NotFound; an empty -address is refused
- Lighthouse TXT lookup shares the owner and peer lookups, keeps answering
  with the initiating certificate, and no longer panics without a default cert
- Served on ssh and nebula ctl too

Info API
- Off until `local_api.info.enabled` with `socket` and optional quoted
  octal `socket_mode` (default "0600"); nothing derived
- Serves commands declaring Command.Identity plus help; others 403 naming
  their surfaces. TestInfoAPISurface pins the set to identity
- GET /v1 is the schema; GET /v1/<cmd>?<flag>=<value> runs one; body is
  the -json rendering via commands.Render; commands.PresentationFormat
  reads json/pretty from the query the way a line is read
- 400 commands.ParamError, 403 commands.WithheldError (what Resolve now
  returns for a withheld name, so help and dispatch type-check it too),
  404 NotFound or unknown, 500 Run error, refusal with no reason, or
  recovered panic with no detail; no redirects; every miss is JSON
- listen takes a mode: bind under umask 0077 then chmod; "0660" plus a
  searchable dir opens it to a group
- The chmod, at bind and on a mode-only reload, goes through chmodSocket,
  which never follows a link: a user who can write the socket's directory
  could otherwise swap the node for a link and have a root daemon put
  0660 or 0666 on any file. Only a socket we own is chmoded. On linux the
  node is held open O_PATH|O_NOFOLLOW, checked by fstat, and chmoded
  through /proc/self/fd, so the check and the chmod land on one inode;
  fchmodat2 is the fallback without /proc. On darwin and the BSDs it is
  an Lstat check and fchmodat(AT_SYMLINK_NOFOLLOW). clearStale Lstats
  too, so a dangling link is refused rather than followed by bind on
  darwin
- One endpoint type owns bind under mutex, bind-before-release move,
  context watch and stop/unlink; each server supplies what it serves
- Reloadable through the same reconcile shape as the control socket:
  mode applied in place, unparsable section keeps what runs, control
  socket path refused by name
- Wire returns Endpoints{Control, Info} with one Stop
- Windows unsupported for now (a pipe has no mode); warned once

Tests: identity lookups and shapes; API filter, status codes, panic
recovery, socket mode, rebind, cancellation; config parsing incl. bare
0660; Wire transitions; e2e of two nebulas with the info API resolving
the peer by address and port, through shared test.HTTPDo/HTTPGet helpers.
Goldens gain identity.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

cmd/nebula-service/main.go

@@ -117,15 +117,15 @@ func main() {
 			os.Exit(1)
 		}
 
-		ctl := localapi.Wire(ctrl.Context(), l, c, ctrl.Commands())
+		local := localapi.Wire(ctrl.Context(), l, c, ctrl.Commands())
 
 		go ctrl.ShutdownBlock()
 
 		err := ctrl.Wait()
 
-		// os.Exit skips deferred calls, so the socket is removed here, before either exit
-		// below, rather than left to a deferred Stop that would never run.
-		ctl.Stop()
+		// os.Exit skips deferred calls, so the sockets are removed here, before either
+		// exit below, rather than left to a deferred Stop that would never run.
+		local.Stop()
 
 		if err != nil {
 			l.Error("Nebula stopped due to fatal error", "error", err)

cmd/nebula-service/service.go

@@ -18,7 +18,7 @@ type program struct {
 	configPath *string
 	build      string
 	control    *nebula.Control
-	ctl        *localapi.Server
+	local      *localapi.Endpoints
 }
 
 func (p *program) Start(s service.Service) error {
@@ -52,16 +52,16 @@ func (p *program) Start(s service.Service) error {
 		return err
 	}
 
-	// Now that we're started, stand up the local control socket.
-	p.ctl = localapi.Wire(p.control.Context(), l, c, p.control.Commands())
+	// Now that we're started, stand up the local APIs.
+	p.local = localapi.Wire(p.control.Context(), l, c, p.control.Commands())
 
 	// Nebula can stop itself on a fatal packet reader error, make sure to log it if it happens.
 	go func() {
 		if err := p.control.Wait(); err != nil {
 			logger.Error(fmt.Sprintf("Nebula stopped due to fatal error: %v", err))
-			// os.Exit skips deferred calls and races the socket's own context watcher,
-			// so the socket is removed here, as cmd/nebula does.
-			p.ctl.Stop()
+			// os.Exit skips deferred calls and races the sockets' own context watchers,
+			// so they are removed here, as cmd/nebula does.
+			p.local.Stop()
 			os.Exit(2)
 		}
 	}()
@@ -72,8 +72,8 @@ func (p *program) Start(s service.Service) error {
 func (p *program) Stop(s service.Service) error {
 	logger.Info("Nebula service stopping.")
 
-	if p.ctl != nil {
-		p.ctl.Stop()
+	if p.local != nil {
+		p.local.Stop()
 	}
 
 	if p.control == nil {

cmd/nebula/main.go

@@ -103,16 +103,16 @@ func main() {
 			os.Exit(1)
 		}
 
-		ctl := localapi.Wire(ctrl.Context(), l, c, ctrl.Commands())
+		local := localapi.Wire(ctrl.Context(), l, c, ctrl.Commands())
 
 		go ctrl.ShutdownBlock()
 		notifyReady(l)
 
 		err := ctrl.Wait()
 
-		// os.Exit skips deferred calls, so the socket is removed here, before either exit
-		// below, rather than left to a deferred Stop that would never run.
-		ctl.Stop()
+		// os.Exit skips deferred calls, so the sockets are removed here, before either
+		// exit below, rather than left to a deferred Stop that would never run.
+		local.Stop()
 
 		if err != nil {
 			l.Error("Nebula stopped due to fatal error", "error", err)