This is an automated email from the ASF dual-hosted git repository.

davsclaus pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel.git


The following commit(s) were added to refs/heads/main by this push:
     new 8569141d6f0b CAMEL-27068: camel-main - the security policy reports the 
camel-main options flagged insecure:dev (#30216)
8569141d6f0b is described below

commit 8569141d6f0bb52f37e9dfd3b4b2a71bfbf5bb53
Author: Claus Ibsen <[email protected]>
AuthorDate: Mon Nov 16 22:09:53 2026 +0100

    CAMEL-27068: camel-main - the security policy reports the camel-main 
options flagged insecure:dev (#30216)
    
    UpdateSensitizeHelper now generates the camel-main options with a security
    category from camel-main-configuration-metadata.json into SECURITY_KEYS of
    SecurityUtils, matched by their whole key, instead of the hand-kept map that
    held only camel.chaos.rules and camel.chaos.scenario.
    
    The security policy (camel.security.insecureDevPolicy, which fails the
    startup with camel.main.profile=prod) now also reports
    camel.management.mcpEnabled, camel.management.openapiUiEnabled and the
    jwtAllowMissingIssuerAndAudience options of camel.server and
    camel.management. Component options with the same name are not matched.
    
    The upgrade guide 4.24 lists the four options and how to keep one enabled
    in production.
    
    Co-Authored-By: Claude Opus 5.5 <[email protected]>
    Signed-off-by: Claus Ibsen <[email protected]>
---
 .../apache/camel/main/MainSecurityPolicyTest.java  | 29 +++++++++
 .../java/org/apache/camel/util/SecurityUtils.java  | 48 ++++++++++-----
 .../org/apache/camel/util/SecurityUtilsTest.java   | 22 +++++++
 .../ROOT/pages/camel-4x-upgrade-guide-4_24.adoc    | 13 ++++
 .../maven/packaging/UpdateSensitizeHelper.java     | 71 ++++++++++++++++++++--
 5 files changed, 164 insertions(+), 19 deletions(-)

diff --git 
a/core/camel-main/src/test/java/org/apache/camel/main/MainSecurityPolicyTest.java
 
b/core/camel-main/src/test/java/org/apache/camel/main/MainSecurityPolicyTest.java
index e4cd649e32c4..56e990cd9364 100644
--- 
a/core/camel-main/src/test/java/org/apache/camel/main/MainSecurityPolicyTest.java
+++ 
b/core/camel-main/src/test/java/org/apache/camel/main/MainSecurityPolicyTest.java
@@ -31,6 +31,7 @@ import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.ValueSource;
 
 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 import static org.junit.jupiter.api.Assertions.assertEquals;
@@ -569,6 +570,34 @@ public class MainSecurityPolicyTest {
         });
     }
 
+    @ParameterizedTest
+    @ValueSource(strings = {
+            "camel.management.mcpEnabled", "camel.management.openapiUiEnabled",
+            "camel.server.jwtAllowMissingIssuerAndAudience", 
"camel.management.jwtAllowMissingIssuerAndAudience" })
+    public void testInsecureDevMainOptionFailsWithProdProfile(String key) {
+        // the camel-main options flagged insecure:dev in the metadata are 
reported by the security policy
+        Main main = new Main();
+        main.addInitialProperty("camel.main.profile", "prod");
+        main.addInitialProperty(key, "true");
+
+        RuntimeCamelException ex = assertThrows(RuntimeCamelException.class, 
main::start);
+        assertTrue(ex.getMessage().contains("[insecure:dev]"), 
ex.getMessage());
+        assertTrue(ex.getMessage().contains(key), ex.getMessage());
+    }
+
+    @Test
+    public void testInsecureDevMainOptionDisabledWithProdProfile() {
+        Main main = new Main();
+        main.addInitialProperty("camel.main.profile", "prod");
+        main.addInitialProperty("camel.management.mcpEnabled", "false");
+        
main.addInitialProperty("camel.server.jwtAllowMissingIssuerAndAudience", 
"false");
+
+        assertDoesNotThrow(() -> {
+            main.start();
+            main.stop();
+        });
+    }
+
     @Test
     public void testComponentOptionWithTheNameOfASecretVaultOption() {
         // serviceAccountKey and tenantId are secret as camel.vault options, 
but not as component options
diff --git 
a/core/camel-util/src/main/java/org/apache/camel/util/SecurityUtils.java 
b/core/camel-util/src/main/java/org/apache/camel/util/SecurityUtils.java
index e0f2d0bb1fa9..ffd1a1dc60fb 100644
--- a/core/camel-util/src/main/java/org/apache/camel/util/SecurityUtils.java
+++ b/core/camel-util/src/main/java/org/apache/camel/util/SecurityUtils.java
@@ -354,13 +354,30 @@ public final class SecurityUtils {
         SECURITY_OPTION_OWNERS = Collections.unmodifiableMap(owners);
     }
 
-    // options that are matched by their whole configuration key rather than 
by their name, because options of other
-    // components have the same name (such as the rules option of the 
schematron endpoint), and that are insecure with
-    // any value that is not empty: the key in lower case without dashes, and 
the security category
-    private static final Map<String, String> SECURITY_KEYS = Map.of(
-            // the rules of camel-chaos to add at startup (CAMEL-26330), and a 
scenario file of rules (CAMEL-26722)
-            "camel.chaos.rules", INSECURE_DEV,
-            "camel.chaos.scenario", INSECURE_DEV);
+    // the camel-main options with a security category (such as 
camel.management.mcpEnabled), matched by their whole
+    // configuration key in lower case without dashes, as options of 
components can have the same name (such as the
+    // rules option of the schematron endpoint for camel.chaos.rules)
+    private static final Map<String, SecurityOption> SECURITY_KEYS;
+
+    static {
+        Map<String, SecurityOption> keys = new HashMap<>();
+        // Generated by camel build tools - do NOT edit this map!
+        // SECURITY-KEYS: START
+        keys.put("camel.chaos.rules", new SecurityOption(INSECURE_DEV, null));
+        keys.put("camel.chaos.scenario", new SecurityOption(INSECURE_DEV, 
null));
+        keys.put("camel.main.devconsoleenabled", new 
SecurityOption(INSECURE_DEV, "true"));
+        keys.put("camel.management.devconsoleenabled", new 
SecurityOption(INSECURE_DEV, "true"));
+        keys.put("camel.management.downloadenabled", new 
SecurityOption(INSECURE_DEV, "true"));
+        keys.put("camel.management.jwtallowmissingissuerandaudience", new 
SecurityOption(INSECURE_DEV, "true"));
+        keys.put("camel.management.mcpenabled", new 
SecurityOption(INSECURE_DEV, "true"));
+        keys.put("camel.management.openapiuienabled", new 
SecurityOption(INSECURE_DEV, "true"));
+        keys.put("camel.management.sendenabled", new 
SecurityOption(INSECURE_DEV, "true"));
+        keys.put("camel.management.uploadenabled", new 
SecurityOption(INSECURE_DEV, "true"));
+        keys.put("camel.server.jwtallowmissingissuerandaudience", new 
SecurityOption(INSECURE_DEV, "true"));
+        keys.put("camel.ssl.trustallcertificates", new 
SecurityOption(INSECURE_SSL, "true"));
+        // SECURITY-KEYS: END
+        SECURITY_KEYS = Collections.unmodifiableMap(keys);
+    }
 
     private SecurityUtils() {
     }
@@ -375,19 +392,20 @@ public final class SecurityUtils {
     /**
      * Get security information for a configuration property.
      * <p>
-     * A key that identifies a component, data format or language (such as 
{@code camel.component.netty.ssl}) only
-     * matches a security option that this component, data format or language 
declares. Any other key (such as a
-     * camel-main option, or an option name without a prefix) matches by the 
option name, except that a configuration
-     * key never matches an option that only languages declare (such as {@code 
camel.beans.foo.nested} for the
-     * {@code nested} option of the simple language).
+     * A camel-main option with a security category (such as {@code 
camel.management.mcpEnabled}) matches by its whole
+     * key. A key that identifies a component, data format or language (such 
as {@code camel.component.netty.ssl}) only
+     * matches a security option that this component, data format or language 
declares. Any other key (such as an option
+     * name without a prefix) matches by the option name, except that a 
configuration key never matches an option that
+     * only languages declare (such as {@code camel.beans.foo.nested} for the 
{@code nested} option of the simple
+     * language).
      *
      * @param  text the configuration property key (e.g., 
"camel.component.aws2-s3.trustAllCertificates")
      * @return      the security option info, or null if the property has no 
security category
      */
     public static SecurityOption getSecurityOption(String text) {
-        String category = 
SECURITY_KEYS.get(text.toLowerCase(Locale.ENGLISH).replace("-", ""));
-        if (category != null) {
-            return new SecurityOption(category, null);
+        SecurityOption key = 
SECURITY_KEYS.get(text.toLowerCase(Locale.ENGLISH).replace("-", ""));
+        if (key != null) {
+            return key;
         }
         String name = normalizeOptionName(text);
         SecurityOption answer = SECURITY_OPTIONS.get(name);
diff --git 
a/core/camel-util/src/test/java/org/apache/camel/util/SecurityUtilsTest.java 
b/core/camel-util/src/test/java/org/apache/camel/util/SecurityUtilsTest.java
index 60e94f63b989..cbe43a2d7e79 100644
--- a/core/camel-util/src/test/java/org/apache/camel/util/SecurityUtilsTest.java
+++ b/core/camel-util/src/test/java/org/apache/camel/util/SecurityUtilsTest.java
@@ -288,6 +288,28 @@ class SecurityUtilsTest {
         
assertNotNull(SecurityUtils.getSecurityOption("camel.main.devConsoleEnabled"));
     }
 
+    @Test
+    void testCamelMainOptionsMatchByWholeKey() {
+        // the camel-main options flagged insecure:dev, generated from the 
camel-main metadata
+        for (String key : List.of("camel.management.mcpEnabled", 
"camel.management.openapiUiEnabled",
+                "camel.server.jwtAllowMissingIssuerAndAudience", 
"camel.management.jwtAllowMissingIssuerAndAudience",
+                "camel.management.devConsoleEnabled", 
"camel.main.devConsoleEnabled")) {
+            SecurityUtils.SecurityOption option = 
SecurityUtils.getSecurityOption(key);
+            assertNotNull(option, key);
+            assertEquals(SecurityUtils.INSECURE_DEV, option.category(), key);
+            assertTrue(SecurityUtils.isInsecureValue(key, "true"), key);
+            assertFalse(SecurityUtils.isInsecureValue(key, "false"), key);
+        }
+        // dash case
+        
assertTrue(SecurityUtils.isInsecureValue("camel.management.mcp-enabled", 
"true"));
+        // an option of a component with the same name is not the camel-main 
option
+        
assertNull(SecurityUtils.getSecurityOption("camel.component.foo.mcpEnabled"));
+        
assertNull(SecurityUtils.getSecurityOption("camel.component.foo.jwtAllowMissingIssuerAndAudience"));
+        // a camel-main option that is not boolean is insecure with any value 
that is not empty
+        assertTrue(SecurityUtils.isInsecureValue("camel.chaos.rules", 
"delay:route1:1000"));
+        assertFalse(SecurityUtils.isInsecureValue("camel.chaos.rules", ""));
+    }
+
     @Test
     void testLanguageOptionMatchesOnlyItsOwnLanguage() {
         // nested is declared only by the simple and file languages
diff --git 
a/docs/user-manual/modules/ROOT/pages/camel-4x-upgrade-guide-4_24.adoc 
b/docs/user-manual/modules/ROOT/pages/camel-4x-upgrade-guide-4_24.adoc
index 8d1df9473d96..4bc422778bd0 100644
--- a/docs/user-manual/modules/ROOT/pages/camel-4x-upgrade-guide-4_24.adoc
+++ b/docs/user-manual/modules/ROOT/pages/camel-4x-upgrade-guide-4_24.adoc
@@ -61,6 +61,19 @@ including a value set through an environment variable: a 
warning by default, and
 A file location in `camel.vault.gcp.serviceAccountKey`, such as 
`file:/etc/gcp/sa.json`, is also reported. It can go
 behind a property placeholder too.
 
+=== camel-main - more options are reported by the insecure:dev security policy
+
+These camel-main options are flagged `insecure:dev`, and the 
`camel.security.insecureDevPolicy` check now reports them
+when they are set to `true`: a warning by default, and the startup fails with 
`camel.main.profile=prod`.
+
+* `camel.management.mcpEnabled`
+* `camel.management.openapiUiEnabled`
+* `camel.server.jwtAllowMissingIssuerAndAudience`
+* `camel.management.jwtAllowMissingIssuerAndAudience`
+
+To keep one of them enabled in production, set 
`camel.security.insecureDevPolicy=allow`, or add the key to
+`camel.security.allowedProperties`.
+
 === camel-observability-services - promoted to Stable
 
 The `camel-observability-services` component has been promoted from _Preview_ 
to _Stable_ support level.
diff --git 
a/tooling/maven/camel-package-maven-plugin/src/main/java/org/apache/camel/maven/packaging/UpdateSensitizeHelper.java
 
b/tooling/maven/camel-package-maven-plugin/src/main/java/org/apache/camel/maven/packaging/UpdateSensitizeHelper.java
index 3a35ab58d73f..fd5f07788fc6 100644
--- 
a/tooling/maven/camel-package-maven-plugin/src/main/java/org/apache/camel/maven/packaging/UpdateSensitizeHelper.java
+++ 
b/tooling/maven/camel-package-maven-plugin/src/main/java/org/apache/camel/maven/packaging/UpdateSensitizeHelper.java
@@ -66,6 +66,8 @@ public class UpdateSensitizeHelper extends 
AbstractGeneratorMojo {
     private static final String SECURITY_END_TOKEN = "// SECURITY-OPTIONS: 
END";
     private static final String OWNERS_START_TOKEN = "// 
SECURITY-OPTION-OWNERS: START";
     private static final String OWNERS_END_TOKEN = "// SECURITY-OPTION-OWNERS: 
END";
+    private static final String SECURITY_KEYS_START_TOKEN = "// SECURITY-KEYS: 
START";
+    private static final String SECURITY_KEYS_END_TOKEN = "// SECURITY-KEYS: 
END";
 
     private static final String SECRET = "secret";
     private static final String INSECURE_DEV = "insecure:dev";
@@ -99,10 +101,11 @@ public class UpdateSensitizeHelper extends 
AbstractGeneratorMojo {
     // their whole key, as a component can have an option with the same name 
that is not secret (such as tenantId)
     private static final String MAIN_METADATA = 
"camel-main-configuration-metadata.json";
 
-    // extra security options from camel-main properties that are not in 
component JSON files
+    // extra security options that are not in component JSON files, matched by 
their option name
     // each entry: option name (lowercase, no dashes), security category, 
insecure value
-    // (an option that must be matched by its whole key, such as 
camel.chaos.rules, is in SECURITY_KEYS of SecurityUtils,
-    // which is written by hand and not generated)
+    // (the camel-main options with a security category are generated into 
SECURITY_KEYS of SecurityUtils, matched by
+    // their whole key; the camel-main options below are also matched by name, 
for the security scan of the Camel MCP
+    // server, which reads the option names from 
SecurityUtils.getSecurityOptions())
     private static final String[][] EXTRA_SECURITY_OPTIONS = {
             { "devconsoleenabled", INSECURE_DEV, "true" },
             { "uploadenabled", INSECURE_DEV, "true" },
@@ -146,6 +149,9 @@ public class UpdateSensitizeHelper extends 
AbstractGeneratorMojo {
         // key -> [category, insecureValue]
         Map<String, String[]> securityOptions = new TreeMap<>();
         // key -> the components, data formats and languages that declare the 
option (such as component:netty)
+        // the whole key of the camel-main options with a security category 
(such as camel.management.mcpenabled)
+        // -> [category, insecureValue]
+        Map<String, String[]> securityKeys = new TreeMap<>();
         Map<String, Set<String>> securityOptionOwners = new TreeMap<>();
 
         for (Path file : jsonFiles) {
@@ -175,7 +181,10 @@ public class UpdateSensitizeHelper extends 
AbstractGeneratorMojo {
                 if (isMain) {
                     // the option names are whole keys (such as 
camel.server.jwtKeystorePassword)
                     MainModel mm = JsonMapper.generateMainModel(obj);
-                    mm.getOptions().forEach(o -> collectSecretOption(o, 
wholeKeys));
+                    mm.getOptions().forEach(o -> {
+                        collectSecretOption(o, wholeKeys);
+                        collectSecurityKey(o, securityKeys);
+                    });
                 } else if (isBean) {
                     PojoBeanModel pm = JsonMapper.generatePojoBeanModel(obj);
                     pm.getOptions().forEach(o -> collectSecretOption(o, 
secrets));
@@ -256,6 +265,7 @@ public class UpdateSensitizeHelper extends 
AbstractGeneratorMojo {
             try {
                 boolean updated = updateSecurityUtils(camelDir, 
securityOptions);
                 updated |= updateSecurityOptionOwners(camelDir, 
securityOptionOwners);
+                updated |= updateSecurityKeys(camelDir, securityKeys);
                 if (updated) {
                     getLog().info("Updated 
camel-util/src/main/java/org/apache/camel/util/SecurityUtils.java file");
                 } else {
@@ -399,6 +409,59 @@ public class UpdateSensitizeHelper extends 
AbstractGeneratorMojo {
         }
     }
 
+    private static void collectSecurityKey(BaseOptionModel o, Map<String, 
String[]> securityKeys) {
+        String security = o.getSecurity();
+        if (!Strings.isNullOrEmpty(security) && !SECRET.equals(security)) {
+            String key = o.getName().toLowerCase(Locale.ENGLISH).replace("-", 
"");
+            String insecureValue = o.getInsecureValue();
+            if (Strings.isNullOrEmpty(insecureValue)) {
+                // boolean options are insecure when true, and other options 
with any value that is not empty
+                insecureValue = "boolean".equals(o.getType()) ? "true" : null;
+            }
+            securityKeys.put(key, new String[] { security, insecureValue });
+        }
+    }
+
+    private boolean updateSecurityKeys(File camelDir, Map<String, String[]> 
securityKeys) throws Exception {
+        File java = new File(camelDir, 
"src/main/java/org/apache/camel/util/SecurityUtils.java");
+        String text = PackageHelper.loadText(java);
+        String spaces8 = "        ";
+
+        StringJoiner sb = new StringJoiner("\n");
+        for (Map.Entry<String, String[]> entry : securityKeys.entrySet()) {
+            String category = entry.getValue()[0];
+            String insecureValue = entry.getValue()[1];
+            String categoryRef = CATEGORY_CONSTANTS.get(category);
+            String categoryExpr = categoryRef != null ? categoryRef : "\"" + 
category + "\"";
+            String valueExpr;
+            if (insecureValue == null) {
+                valueExpr = "null";
+            } else {
+                String valueRef = VALUE_CONSTANTS.get(insecureValue);
+                valueExpr = valueRef != null ? valueRef : "\"" + insecureValue 
+ "\"";
+            }
+            sb.add(spaces8 + "keys.put(\"" + entry.getKey() + "\", new 
SecurityOption(" + categoryExpr + ", " + valueExpr
+                   + "));");
+        }
+        String changed = sb.toString().trim();
+
+        String existing = Strings.between(text, SECURITY_KEYS_START_TOKEN, 
SECURITY_KEYS_END_TOKEN);
+        if (existing != null) {
+            existing = existing.trim();
+            if (existing.equals(changed)) {
+                return false;
+            }
+            String before = Strings.before(text, SECURITY_KEYS_START_TOKEN);
+            String after = Strings.after(text, SECURITY_KEYS_END_TOKEN);
+            String block = changed.isEmpty() ? "" : spaces8 + changed + "\n";
+            text = before + SECURITY_KEYS_START_TOKEN + "\n" + block + spaces8 
+ SECURITY_KEYS_END_TOKEN + after;
+            PackageHelper.writeText(java, text);
+            return true;
+        }
+
+        return false;
+    }
+
     private boolean updateSecurityUtils(File camelDir, Map<String, String[]> 
securityOptions) throws Exception {
         File java = new File(camelDir, 
"src/main/java/org/apache/camel/util/SecurityUtils.java");
         String text = PackageHelper.loadText(java);

Reply via email to