# Feature: Security
Security centraliza limites y politicas compartidas por parser, query y
transform. La meta es que procesar XML externo sea seguro por defecto y que los
limites se puedan ajustar explicitamente.
## Que aprenderas aqui
[] Que limites existen.
[] Como configurar parser, query y transform.
[] Que hace la politica de entidades.
[] Que no cubre esta feature.
## Archivo
[] `src/security/mod.rs`
## Defaults
| Documento | 10 MiB |
| Texto | 1 MiB |
| Profundidad | 128 |
| Nodos | 100000 |
| Pasos de query | 100000 |
| Expansiones de transform | 100000 |
Estos valores son defaults razonables para el MVP. Una aplicacion puede
reducirlos o ampliarlos segun su contexto.
## Limites de parser
```rust
use xdoc::parser::{parse_str_with_config, ParserConfig};
use xdoc::security::{ParserSecurityConfig, SecurityLimits};
let limits = SecurityLimits::new()
.with_max_document_bytes(1024 * 1024)
.with_max_depth(32)
.with_max_nodes(10_000);
let parser_security = ParserSecurityConfig::new().with_limits(limits);
let config = ParserConfig::new().with_security(parser_security);
let document = parse_str_with_config(xml_input, &config)?;
```
## Politica de entidades
Por defecto, `EntityPolicy::secure()` rechaza DTD y entidades externas.
```rust
use xdoc::security::{EntityPolicy, ParserSecurityConfig};
let policy = EntityPolicy::secure();
let security = ParserSecurityConfig::new().with_entity_policy(policy);
```
El motor no descarga red ni filesystem implicitamente. Si una aplicacion quiere
soportar resolucion externa, debe hacerlo explicitamente en una capa superior y
con controles propios.
## Limites de query
```rust
use xdoc::query::{NamespaceContext, Query};
use xdoc::security::{QuerySecurityConfig, SecurityLimits};
let limits = SecurityLimits::new().with_max_query_steps(10_000);
let security = QuerySecurityConfig::new().with_limits(limits);
let query = Query::parse("//Item")?;
let result = query.evaluate_with_options(
&document,
&NamespaceContext::new(),
&security,
)?;
```
## Limites de transform
```rust
use xdoc::security::{SecurityLimits, TransformSecurityConfig};
use xdoc::transform::TransformConfig;
let limits = SecurityLimits::new().with_max_transform_expansion(1000);
let transform_security = TransformSecurityConfig::new().with_limits(limits);
let config = TransformConfig::new().with_security(transform_security);
```
## Como elegir limites
Para XML controlado internamente:
[] Puedes usar defaults.
[] Ajusta solo si tus documentos son grandes.
Para XML recibido de usuarios o terceros:
[] Reduce profundidad maxima.
[] Reduce tamano maximo de documento.
[] Mantiene DTD y entidades externas rechazadas.
[] Limita expansion de transform.
[] Registra errores de limite como input invalido, no como fallo interno.
## Que no cubre
Security no es:
[] Sandbox del sistema operativo.
[] Validacion criptografica.
[] Validacion legal de certificados.
[] Politica de negocio.
[] Proteccion contra todo uso intensivo de CPU fuera de las rutas instrumentadas.
## Errores comunes
[] Aumentar limites para XML no confiable sin necesidad.
[] Habilitar entidades externas sin una capa de resolucion controlada.
[] Confundir limites de parser con validacion de schema.
[] Pensar que validation data de firma implica confianza legal.
## API principal
[] `SecurityLimits`
[] `EntityPolicy`
[] `ParserSecurityConfig`
[] `QuerySecurityConfig`
[] `TransformSecurityConfig`
## Siguiente lectura
[] [parser.md](parser.md) para XML externo.
[] [query.md](query.md) para limites de evaluacion.
[] [transform.md](transform.md) para limites de expansion.
[Volver al indice](features.md).