Fix TOML config generation producing quoted dotted keys instead of sections

[Copilot]

./HellPot -g was emitting flat quoted dotted keys ('http.bind_addr' = '127.0.0.1') instead of proper TOML sections ([http]). Root cause: declaring defOpts as map[string]map[string]interface{} gave the TOML marshaler conflicting type information, causing it to fall back to flat key output.

Changes

• defOpts type — changed from map[string]map[string]interface{} to map[string]interface{} with explicit map[string]interface{} annotations on each section value; the marshaler now receives a uniform nested structure and emits [section] headers correctly
• gen() — removed the now-unnecessary flatDefOpts conversion loop; marshals defOpts directly
• setDefaults() — updated section access to use type assertions (section.(map[string]interface{})), with a safe continue guard for sections absent from defOpts (e.g. "ssh")

Before:

'http.bind_addr' = '127.0.0.1'
'http.bind_port' = '8080'
'logger.debug' = true

After:

[http]
bind_addr = '127.0.0.1'
bind_port = '8080'

[logger]
debug = true

Original prompt

Fix TOML Config Generation - Remove Type Conversion Issue

Problem

After merging PR #8, ./HellPot -g still generates quoted dotted keys instead of proper TOML sections:

# CURRENT OUTPUT (WRONG)
'deception.server_name' = 'nginx'
'http.bind_addr' = '127.0.0.1'
'http.bind_port' = '8080'
'logger.debug' = true

Expected output:

# DESIRED OUTPUT (CORRECT)
[deception]
server_name = 'nginx'

[http]
bind_addr = '127.0.0.1'
bind_port = '8080'

[logger]
debug = true

Root Cause Analysis

What PR #8 Did

PR #8 attempted to fix this by adding a type conversion in the gen() function (lines 60-66):

flatDefOpts := make(map[string]interface{}, len(defOpts))
for k, v := range defOpts {
    flatDefOpts[k] = v  // Shallow copy
}
if dat, err = toml.Parser().Marshal(flatDefOpts); err != nil {

Why it didn't work: This creates a map[string]interface{} where each value is still a map[string]interface{}, which is correct for nested TOML sections. However, the TOML marshaler is receiving conflicting type information because:

1. The original defOpts is declared as map[string]map[string]interface{} (line 17)
2. The conversion creates map[string]interface{} but preserves the inner map types
3. The TOML marshaler gets confused by this mixed typing and falls back to quoted flat keys

The Real Issue

The problem is the type declaration of defOpts itself:

// Line 17 - WRONG TYPE
var defOpts = map[string]map[string]interface{}{
    "logger": {
        "debug": true,
        // ...
    },
}

The inner maps ({"debug": true, ...}) are already map[string]interface{} by Go's type inference, but declaring the outer map as map[string]map[string]interface{} creates a type mismatch that confuses the TOML marshaler.

Solution

Change 1: Fix the Type Declaration (Line 17)

BEFORE:

var defOpts = map[string]map[string]interface{}{

AFTER:

var defOpts = map[string]interface{}{

This aligns the type declaration with the actual structure. The inner maps remain map[string]interface{} (they always were), but now the type system correctly represents the nested structure.

Change 2: Remove Unnecessary Conversion (Lines 60-66)

BEFORE:

func gen(path string) {
    var (
        dat []byte
        err error
    )
    flatDefOpts := make(map[string]interface{}, len(defOpts))
    for k, v := range defOpts {
        flatDefOpts[k] = v
    }
    if dat, err = toml.Parser().Marshal(flatDefOpts); err != nil {

AFTER:

func gen(path string) {
    var (
        dat []byte
        err error
    )
    if dat, err = toml.Parser().Marshal(defOpts); err != nil {

Why this works: With the correct type declaration, defOpts is already the right type for the TOML marshaler. No conversion needed!

Why This Fix Works

1. ✅ Correct Type Alignment: map[string]interface{} correctly represents nested TOML sections
2. ✅ No Type Confusion: The TOML marshaler receives consistent type information
3. ✅ Simpler Code: Removes unnecessary conversion logic
4. ✅ Proper TOML Output: The marshaler now produces [section] headers instead of quoted keys

Technical Details

When you declare:

var defOpts = map[string]interface{}{
    "logger": {
        "debug": true,
    },
}

Go's type inference creates:

• Outer map: map[string]interface{}
• Inner maps: Each value is map[string]interface{} (inferred)

This is exactly what the TOML marshaler expects for nested sections!

The original map[string]map[string]interface{} declaration was too specific and caused the marshaler to treat it differently.

Testing

After this fix:

# Rebuild
make

# Generate config
./HellPot -g

# Verify output
cat config.toml

Expected output:

[deception]
server_name = 'nginx'

[http]
bind_addr = '127.0.0.1'
bind_port = '8080'
real_ip_header = 'X-Real-IP'
unix_socket_path = '/var/run/hellpot'
unix_socket_permissions = '0666'
use_unix_socket = false

[http.router]
catchall = false
makerobots = true
paths = ['wp-login.php', 'wp-login']

[http]
uagent_string_blacklist = ['Cloudflare-Traffic-Manager']

[logger]
console_time_format = '3:04PM'
debug = true
docker_logging = false
nocolor = false
trace = false
use_date_filename = true

[performance]
max_workers = 256
restrict_concurrency = false

Impact

• ✅ Fixes: TOML config generation now produces proper sections
• ✅ Simplifies: Removes unnecessary type conversion code
• ✅ No Breaking Changes: Config loading unchanged; only affects generation
• ✅ Better UX: Generated configs are human-readable and editable

Files Modified

• internal/config/defaults.go:
  • Line 17: Change type declaration
  • Lines 60-66: Remove conversion loop, marshal directly

This pull request was created from Copilot chat.

---

💬 We'd love your input! Share your thoughts on Copilot coding agent in our 2 minute survey.

[bdk38]

Previous PR #8 wasn't the complete fix