fix(node): require auth on /node/debug and surface key-file load errors

config/node/api.yaml

@@ -85,8 +85,10 @@ apiPackages:
         open: true
       - name: /p2pstatus
         open: true
+      # /debug returns cached interceptor and resolver state; keep it behind auth.
       - name: /debug
         open: true
+        secured: true
       - name: /peerinfo
         open: true
       - name: /statistics
@@ -114,10 +116,20 @@ apiPackages:
       - name: /query
         open: true
 
+# `password` holds a DIGEST, not the password itself: the hex-encoded hash of the
+# password, using the algorithm named under `hasher` below. A plaintext value here
+# will never authenticate.
+#
+# Generate one with:
+#   printf '%s' 'your-password' | sha256sum | cut -d' ' -f1     # GNU coreutils
+#   printf '%s' 'your-password' | shasum -a 256 | cut -d' ' -f1 # macOS / perl
+#
+# Anyone who can read this file can attempt an offline crack against these digests,
+# so keep it readable only by the node user, and terminate TLS in front of the API.
 credentials:
   - username: example
-    password: hashed password
+    password: replace-me-with-a-sha256-digest
   - username: example2
-    password: hashed password
+    password: replace-me-with-a-sha256-digest
 hasher:
   type: sha256

factory/cryptoSigningParams.go

@@ -3,9 +3,9 @@ package factory
 import (
 	"bytes"
 	"encoding/hex"
+	"errors"
 	"fmt"
 	"os"
-	"strings"
 
 	"github.com/klever-io/klever-go/common"
 	"github.com/klever-io/klever-go/core"
@@ -109,14 +109,27 @@ func (cspf *cryptoSigningParamsLoader) getSkPk() ([]byte, []byte, error) {
 	skIndex := cspf.skIndex
 	encodedSk, pkString, err := tools.LoadSkPkFromPemFile(cspf.skPemFileName, skIndex, os.Getenv("KEY_PASSWORD"))
 	if err != nil {
-		if strings.Contains(err.Error(), ErrFileNotFound.Error()) {
-			keyGen := signing.NewKeyGenerator(cspf.suite)
-			encodedSk, pkString, err = tools.CreateWallet(cspf.skPemFileName, os.Getenv("KEY_PASSWORD"), keyGen, cspf.pubkeyConverter)
-			if err != nil {
-				return nil, nil, err
-			}
+		// Only a missing file is recoverable by generating a key. Anything else
+		// (corrupt pem, wrong KEY_PASSWORD, permissions) must surface here rather
+		// than fall through and fail later against an empty key.
+		if !isSkPemFileNotFound(err) {
+			return nil, nil, fmt.Errorf("loading validator key: %w", err)
 		}
 
+		keyGen := signing.NewKeyGenerator(cspf.suite)
+		encodedSk, pkString, err = tools.CreateWallet(cspf.skPemFileName, os.Getenv("KEY_PASSWORD"), keyGen, cspf.pubkeyConverter)
+		if err != nil {
+			return nil, nil, err
+		}
+
+		// Generating a key here is intentional: it lets an observer start without
+		// operator-provided key material. It is only a problem when the node was
+		// meant to run under an already-registered validator identity, which we
+		// cannot distinguish at this point, so say so rather than staying silent.
+		log.Warn("no key file found - generated a new node identity",
+			"file", cspf.skPemFileName,
+			"public key", pkString,
+			"note", "expected for a new observer; if this node should run as a registered validator, stop it and restore its key file")
 	}
 
 	skBytes, err := hex.DecodeString(string(encodedSk))
@@ -131,3 +144,11 @@ func (cspf *cryptoSigningParamsLoader) getSkPk() ([]byte, []byte, error) {
 
 	return skBytes, pkBytes, nil
 }
+
+// isSkPemFileNotFound reports whether the key file is simply absent. Matched by
+// type only: a substring match on the not-found text is satisfied by any error
+// carrying a path that happens to contain it, which would send a corrupt key
+// file down the generate-and-replace branch.
+func isSkPemFileNotFound(err error) bool {
+	return errors.Is(err, os.ErrNotExist)
+}

factory/cryptoSigningParamsKeyFile_test.go

@@ -0,0 +1,77 @@
+package factory
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/klever-io/klever-go/common/mock"
+	"github.com/stretchr/testify/require"
+)
+
+const corruptPem = "this is not a pem file at all\n"
+
+func newLoaderFor(t *testing.T, pemPath string) *cryptoSigningParamsLoader {
+	t.Helper()
+	cspf, err := NewCryptoSigningParamsLoader(
+		&mock.PubkeyConverterStub{},
+		0,
+		pemPath,
+		&mock.SuiteStub{CreateKeyPairStub: createKeyPair},
+		false,
+	)
+	require.NoError(t, err)
+	return cspf
+}
+
+// SAFETY: an existing-but-unloadable pem (corrupt file, wrong KEY_PASSWORD,
+// bad permissions) must NEVER be replaced by a freshly generated key. Doing so
+// would destroy a validator's key material irrecoverably.
+func TestKeyFileSafety_CorruptPemIsNeverOverwritten(t *testing.T) {
+	dir := t.TempDir()
+	pem := filepath.Join(dir, "validatorKey.pem")
+	require.NoError(t, os.WriteFile(pem, []byte(corruptPem), 0o600))
+
+	_, _, err := newLoaderFor(t, pem).getSkPk()
+	require.Error(t, err, "an unloadable pem must surface an error, not be swallowed")
+	require.ErrorContains(t, err, "loading validator key",
+		"the error must name what failed, not surface as a bare deserialize error")
+
+	after, rerr := os.ReadFile(pem)
+	require.NoError(t, rerr)
+	require.Equal(t, corruptPem, string(after),
+		"CATASTROPHIC: an unloadable pem was overwritten with a generated key")
+}
+
+// Regression: the not-found check must match by error TYPE, not by searching the
+// message for "no such file or directory". That text appears in every PEM error
+// whose path happens to contain it, which sent a corrupt key file down the
+// generate-and-replace branch and destroyed it.
+func TestKeyFileSafety_NotFoundIsMatchedByTypeNotMessage(t *testing.T) {
+	dir := filepath.Join(t.TempDir(), "no such file or directory")
+	require.NoError(t, os.MkdirAll(dir, 0o755))
+	pem := filepath.Join(dir, "validatorKey.pem")
+	require.NoError(t, os.WriteFile(pem, []byte(corruptPem), 0o600))
+
+	_, _, err := newLoaderFor(t, pem).getSkPk()
+	require.Error(t, err, "a corrupt pem must fail even when its path contains the not-found text")
+
+	after, rerr := os.ReadFile(pem)
+	require.NoError(t, rerr)
+	require.Equal(t, corruptPem, string(after),
+		"CATASTROPHIC: a corrupt pem on a path containing the not-found text was replaced")
+}
+
+// The intentional observer path: a genuinely absent pem DOES create a key file.
+func TestKeyFileSafety_MissingPemDoesCreateKey(t *testing.T) {
+	dir := t.TempDir()
+	pem := filepath.Join(dir, "validatorKey.pem")
+
+	_, _, err := newLoaderFor(t, pem).getSkPk()
+	require.NoError(t, err, "observer auto-generation must keep working")
+
+	info, serr := os.Stat(pem)
+	require.NoError(t, serr, "a key file should have been created")
+	require.Greater(t, info.Size(), int64(0))
+	t.Logf("missing pem -> created %s (%d bytes)", pem, info.Size())
+}

network/api/middleware/authHandler.go

@@ -1,6 +1,7 @@
 package middleware
 
 import (
+	"crypto/subtle"
 	"encoding/hex"
 	"net/http"
 
@@ -60,7 +61,8 @@ func NewAuthenticationFunc(credentialsConfig config.APIRoutesConfig) gin.Handler
 			return
 		}
 
-		if userPassword != hex.EncodeToString(hasher.Compute(pass)) {
+		expected := hex.EncodeToString(hasher.Compute(pass))
+		if subtle.ConstantTimeCompare([]byte(userPassword), []byte(expected)) != 1 {
 			c.AbortWithStatusJSON(http.StatusUnauthorized, shared.GenericAPIResponse{
 				Data:  nil,
 				Error: "invalid password",