Ver código fonte para Shellcode

{{Short description |Código destinado a ser uma carga útil para explorar uma vulnerabilidade de software}}
<!---->
{{Redirect||código escrito na linguagem de comando de um shell|Shell script}}
<!---->
'''Shellcode''' é [[código executável]] destinado a ser usado como uma [[Carga útil (computação)|carga útil]] para [[Exploit (segurança de computadores)|explorar]] uma [[Vulnerabilidade (computação)|vulnerabilidade]] de [[software]]. O termo inclui ''shell'' (em inglês, "casca" ou "interpretador de comandos") porque o ataque originalmente descrito abria um [[Shell (computação)|interpretador de comandos]] que o atacante poderia usar para controlar a máquina alvo, mas qualquer código injetado para obter acesso que de outra forma não é permitido pode ser chamado de shellcode. Por este motivo, alguns consideram o nome ''shellcode'' impreciso.<ref>{{cite book |title=Sockets, Shellcode, Porting, & Coding: Reverse Engineering Exploits and Tool Coding for Security Professionals 
|author-first1=James C. |author-last1=Foster |author-first2=Mike |author-last2=Price |publisher=Elsevier Science & Technology Books |date=2005-04-12 |isbn=1-59749-005-9 |url=https://books.google.com/books?id=ZNI5dvBSfZoC}}</ref>

Um ataque geralmente injeta [[dados]] que consistem em código executável em um [[Processo (informática)|processo]] antes ou enquanto explora uma vulnerabilidade para obter o controle. O [[contador de programa]] é definido para o {{ill|en|ponto de entrada|entry point}} do shellcode para que o shellcode seja executado. A implantação de shellcode é frequentemente realizada incluindo o código em um arquivo que um processo vulnerável baixa e, em seguida, carrega em sua memória.

O senso comum dita que, para máxima eficácia, uma carga útil de shellcode deve ser pequena.<ref name="anley_koziol_2007">{{Cite book |title=The shellcoder's handbook: discovering and exploiting security holes |date=2007 |publisher=Wiley |author-first1=Chris |author-last1=Anley |author-first2=Jack |author-last2=Koziol |url=https://archive.org/details/Wiley.The.Shellcoders.Handbook.2nd.Edition.Aug.2007/ |isbn=978-0-470-19882-7 |edition=2 |location=Indianapolis, Indiana, UA |oclc=173682537}}</ref> [[Código de máquina]] fornece a flexibilidade necessária para atingir o objetivo. [[Hacker|Autores]] de shellcode aproveitam pequenos opcodes para criar shellcode compacto.<ref>{{Cite book |title=Buffer overflow attacks: detect, exploit, prevent |date=2005 |publisher=Syngress |author-last=Foster |author-first=James C. |isbn=1-59749-022-9 |location=Rockland, MA, USA |oclc=57566682}}</ref><ref>{{Cite web |title=Tiny Execve sh - Assembly Language - Linux/x86 |url=https://github.com/geyslan/SLAE/blob/master/4th.assignment/tiny_execve_sh.asm |access-date=2021-02-01 |website=GitHub}}</ref>

==Tipos==
; Local
Um ataque de shellcode local permite que um atacante obtenha privilégios de acesso elevados em seu próprio computador. Em alguns casos, a exploração de uma vulnerabilidade pode ser alcançada causando um erro como [[Transbordamento de dados|estouro de buffer]]. Se bem-sucedido, o shellcode permite o acesso à máquina por meio dos privilégios elevados concedidos ao processo alvo.

; Remoto
Um ataque de shellcode remoto visa um processo em execução em uma máquina remota {{endash}} na mesma [[rede de área local]], [[intranet]] ou na [[Internet]]. Se bem-sucedido, o shellcode fornece acesso à máquina alvo através da rede. O shellcode normalmente abre uma conexão de [[Soquete de rede|soquete]], do tipo stream, [[TCP/IP]] para permitir o acesso a um shell na máquina alvo. 

Um ataque de shellcode remoto pode ser categorizado pelo seu comportamento. Se o shellcode estabelece a conexão, ele é chamado de ''shell reverso'' (''reverse shell''), ou shellcode de ''conexão de volta'' (''connect-back''). Por outro lado, se o atacante estabelece a conexão, o shellcode é chamado de ''shell de ligação'' (''bindshell'') porque o shellcode se ''liga'' a uma determinada porta na máquina da vítima. Um ''bindshell de porta aleatória'' (''bindshell random port'') ignora a parte de ligação e escuta em uma porta aleatória.{{efn|O ''[https://github.com/geyslan/SLAE/blob/master/improvements/tiny_shell_bind_tcp_random_port_x86_64.asm bindshell random port]'' é o menor shellcode bindshell estável para [[X86-64|x86_64]] disponível até hoje.}} Um shellcode de ''reutilização de soquete'' (''socket-reuse'') é uma exploração (exploit) que estabelece uma conexão com o processo vulnerável que não é fechada antes que o shellcode seja executado, para que o shellcode possa reutilizar a conexão para permitir o acesso remoto. O shellcode de reutilização de soquete é mais elaborado, pois ele precisa descobrir qual conexão reutilizar e a máquina pode ter muitas conexões abertas.<ref>{{cite web |url=http://www.blackhatlibrary.net/Shellcode/Socket-reuse |title=Shellcode/Socket-reuse |author=BHA |date=2013-06-06 |access-date=2013-06-07}}</ref>

Um [[firewall]] pode detectar conexões de saída feitas por shellcode de conexão de volta, bem como conexões de entrada feitas por shell de ligação e, portanto, oferece alguma proteção contra um ataque. Mesmo que o sistema seja vulnerável, um firewall pode impedir que o atacante se conecte ao shell criado pelo shellcode. Uma das razões pelas quais o shellcode de reutilização de soquete é usado é que ele não cria novas conexões e, portanto, é mais difícil de detectar e bloquear.

; Download e execução
Um ataque de shellcode de download e execução [[download|baixa]] e [[Execução (computação)|executa]] [[malware]] no sistema alvo. Este tipo de shellcode não gera um shell, mas sim instrui a máquina a baixar um determinado arquivo executável da rede e executá-lo. Hoje em dia, é comumente usado em ataques de [[drive-by download]], onde uma vítima visita uma página web maliciosa que, por sua vez, tenta executar tal shellcode de download e execução para instalar software na máquina da vítima. 

Uma variação deste ataque baixa e {{ill|en|Carregamento dinâmico|Dynamic loading|carrega}} uma [[Biblioteca (computação)|biblioteca]].<ref>{{cite web |url=http://skypher.com/index.php/2010/01/11/download-and-loadlibrary-shellcode-released/ |title=Download and LoadLibrary shellcode released |author=SkyLined |date=2010-01-11 |access-date=2010-01-19 |urlmorta=sim |archive-url=https://web.archive.org/web/20100123014637/http://skypher.com/index.php/2010/01/11/download-and-loadlibrary-shellcode-released/ |archive-date=2010-01-23}}</ref><ref>{{cite web |url=http://code.google.com/p/w32-dl-loadlib-shellcode/ |title=Download and LoadLibrary shellcode for x86 Windows |date=2010-01-11 |access-date=2010-01-19}}</ref> As vantagens desta técnica são que o código pode ser menor, que não requer que o shellcode gere um novo processo no sistema alvo e que o shellcode não precisa de código para limpar o processo alvo, pois isso pode ser feito pela biblioteca carregada no processo.

; Em estágios (Staged)
Quando a quantidade de dados que um atacante pode injetar no processo alvo é muito limitada para alcançar o efeito desejado, pode ser possível implantar o shellcode em estágios que progressivamente fornecem mais acesso. O primeiro estágio pode fazer nada mais do que baixar o segundo estágio que então fornece o acesso desejado.

; Caça-ao-ovo (Egg-hunt)
Um ataque de shellcode de caça-ao-ovo (''egg-hunt'') é um ataque em estágios no qual o atacante pode injetar shellcode em um processo, mas não sabe onde ele está dentro do processo. Um shellcode de segundo estágio, geralmente menor que o primeiro, é injetado no processo para procurar o primeiro shellcode (o ''ovo'' ou ''egg'') no espaço de endereçamento do processo e o executa.<ref>{{cite web |url=http://www.hick.org/code/skape/papers/egghunt-shellcode.pdf 
|title=Safely Searching Process Virtual Address Space 
|author=Skape |publisher=nologin |date=2004-03-09 |access-date=2009-03-19}}</ref>

; Omelete
Um ataque de shellcode omelete (''omelet''), semelhante ao de caça-ao-ovo, procura vários pequenos blocos de dados (''ovos'' ou ''eggs'') e os combina em um bloco maior (''omelete'' ou ''omelet'') que é então executado. Isso é usado quando um atacante é limitado no tamanho do código injetado, mas pode injetar vários blocos.<ref>{{cite web |url=http://skypher.com/wiki/index.php?title=Shellcode/w32_SEH_omelet_shellcode |title=w32 SEH omelet shellcode |author=SkyLined |publisher=Skypher.com |date=2009-03-16 |access-date=2009-03-19 |urlmorta=sim |archive-url=https://web.archive.org/web/20090323030636/http://skypher.com/wiki/index.php?title=Shellcode%2Fw32_SEH_omelet_shellcode |archive-date=2009-03-23}}</ref>

==Codificação==
O Shellcode é frequentemente escrito para contornar as restrições sobre os dados que um processo irá permitir. As técnicas gerais incluem:

; Otimizar para tamanho
Otimizar o código para diminuir seu tamanho.

; Código automodificável
{{ill|en|Código automodificável|Self-modifying code |Modificar seu próprio código}} antes de executá-lo para usar valores de byte que são de outra forma restritos.

; Criptografia
Para evitar [[Sistema de detecção de intrusos|detecção de intrusão]], codificar como autodecriptação ou {{ill|en|código polimórfico|polymorphic code|polimórfico}}.

; Codificação de caracteres
Um ataque que visa um navegador pode ofuscar o shellcode em uma string [[JavaScript]] usando uma codificação de caracteres expandida.<ref>{{cite web |url=http://www.iss.net/security_center/reference/vuln/JavaScript_Large_Unescape.htm |title=JavaScript large number of unescape patterns detected |archive-url=https://web.archive.org/web/20150403203325/http://www.iss.net/security_center/reference/vuln/JavaScript_Large_Unescape.htm |archive-date=2015-04-03 |urlmorta=sim}}</ref> Por exemplo, na arquitetura [[IA-32]], aqui estão duas instruções de não-operação (no-operation, NOP) não codificadas (usadas em um {{ill|en|NOP slide|NOP slide}}):

 90             NOP
 90             NOP

Codificado como:
* [[Codificação por cento |Codificação por porcentagem]]: {{code|unescape("%u9090")}}
* Literal [[Unicode]]: {{code|\u9090}}
* {{ill|en|Codificações de caracteres em HTML|Character encodings in HTML|Referência de caractere HTML/XML}} : {{code|&#x9090;}} ou {{code|&#37008;}}

; Livre de nulo (Null-free)
O shellcode deve ser escrito sem bytes de valor zero quando se destina a ser injetado em uma {pill|en||string terminada em nulo|null-terminated string}} que é copiada no processo alvo através do algoritmo usual (ou seja, {{ill|en|strcpy|strcpy}}) de encerrar a cópia no primeiro byte zero {{endash}} chamado de [[caractere nulo]] em [[Codificação de caracteres<!--#-->|conjuntos de caracteres]] comuns. Se o shellcode contivesse um nulo, a cópia seria truncada e não funcionaria corretamente. Para produzir código livre de nulo a partir de código que contém nulos, pode-se substituir instruções de máquina que contêm zeros por instruções que não contêm. Por exemplo, na arquitetura {{ill|en|IA-32|IA-32}} a instrução para definir o registrador EAX para 1 contém zeros como parte do literal (<code>1</code> expande para <code>0x00000001</code>).

 B8 01000000    {{ill|en|MOV (instrução x86)|MOV (x86 instruction)|MOV}} EAX,1

As seguintes instruções realizam o mesmo objetivo (EAX contendo 1) sem bytes zero embutidos, primeiro definindo EAX para 0 e depois incrementando EAX para 1:

 33C0           {{ill|en|XOR (instrução x86)|XOR (x86 instruction)|XOR}} EAX,EAX
 40             {{ill|en|INC (instrução x86)|XOR (x86 instruction)|INC}} EAX

; <!--{{anchor|Alphanumeric|Multi-architecture}}-->Texto
Um shellcode alfanumérico consiste apenas em caracteres [[alfanumérico]]s (0–9, A–Z e a–z).<ref name="Rix_2001">{{cite journal |title=Writing ia32 alphanumeric shellcodes |author=rix |volume=0x0b |issue=57 |id=#0x0f of 0x12 |journal=Phrack |publisher=Phrack Inc. |date=2001-08-11 |url=http://www.phrack.org/issues/57/15 |access-date=2022-05-26 |url-status=live |archive-url=https://web.archive.org/web/20220308045645/http://phrack.org/issues/57/15.html#article |archive-date=2022-03-08}}</ref><ref name="Obscou_2003">{{cite journal |title=Building IA32 'Unicode-Proof' Shellcodes |author=obscou |date=2003-08-13 |volume=11 |issue=61 |id=#0x0b of 0x0f |journal=Phrack |publisher=Phrack Inc. |url=http://www.phrack.org/issues/61/11 |access-date=2008-02-29 |url-status=live |archive-url=https://web.archive.org/web/20220526165740/http://phrack.org/issues/61/11.html#article |archive-date=2022-05-26}}</ref> Este tipo de codificação foi criado por [[Hacker de segurança|hackers]] para ofuscar o código de máquina dentro do que parece ser [[texto simples]]. Isso pode ser útil para evitar a detecção do código; para permitir que o código passe por filtros que removem caracteres não alfanuméricos de strings.{{efn |em parte, tais filtros foram uma resposta a exploits de shellcode não alfanuméricos}} Um tipo de codificação semelhante é chamado de ''código imprimível'' (''printable code'') e usa todos os caracteres [[Caractere de controle|imprimíveis]] (alfanuméricos mais símbolos como !@#%^&*). Uma variante semelhante e restrita é o ''código ECHOável'' que não contém nenhum caractere que não seja aceito pelo comando [[echo (comando)|ECHO]]. Foi demonstrado que é possível criar shellcode que se parece com texto normal em inglês.<ref name="Mason-Small-Monrose-MacManus_2009">{{cite conference |title=English Shellcode |author-first1=Joshua |author-last1=Mason |author-first2=Sam |author-last2=Small |author-first3=Fabian |author-last3=Monrose |author-first4=Greg |author-last4=MacManus |date=11-2009 |conference=Proceedings of the 16th ACM conference on Computer and Communications Security |location=New York, NY, USA |pages=524–533 |url=http://www.cs.jhu.edu/~sam/ccs243-mason.pdf |access-date=2010-01-10 |urlmorta=não |archive-url=https://web.archive.org/web/20220526164459/https://www.cs.jhu.edu/~sam/ccs243-mason.pdf |archive-date=2022-05-26}} (10 pages)</ref>
Escrever tal shellcode requer uma compreensão aprofundada da {{ill|en|arquitetura do conjunto de instruções|instruction set architecture}} das máquinas alvo. Foi demonstrado que é possível escrever código alfanumérico que é executável em mais de uma máquina,<ref>{{cite web |title=Multi-architecture (x86) and 64-bit alphanumeric shellcode explained |publisher=Blackhat Academy |url=http://www.blackhatlibrary.net/Alphanumeric_shellcode |urlmorta=sim |archive-url=https://web.archive.org/web/20120621124443/http://www.blackhatlibrary.net/Alphanumeric_shellcode |archive-date=2012-06-21}}</ref> constituindo, assim, código [[Binário multiarquitetura|executável multi-arquitetura]].

Uma solução alternativa (work-around) foi publicada por Rix na {{ill|en|Phrack|Phrack}} 57<ref name="Rix_2001"/> no qual ele mostra que é possível transformar qualquer código em código alfanumérico. Frequentemente, o código automodificável é aproveitado porque permite que o código tenha valores de byte que de outra forma não são permitidos, substituindo valores codificados em tempo de execução. Um decodificador automodificável pode ser criado que inicialmente usa apenas bytes permitidos. O código principal do shellcode é codificado, também usando apenas bytes no intervalo permitido. Quando o shellcode de saída é executado, o decodificador modifica seu código para usar as instruções que ele requer e, em seguida, decodifica o shellcode original. Após decodificar o shellcode, o decodificador transfere o controle para ele. Foi demonstrado que é possível criar shellcode arbitrariamente complexo que se parece com texto normal em inglês.<ref name="Mason-Small-Monrose-MacManus_2009"/>

O software moderno usa [[Unicode]] para suportar [[Internacionalização e tradução|internacionalização e localização]]. Frequentemente, o texto de entrada [[ASCII]] é convertido para Unicode antes do processamento. Quando um caractere ASCII (geralmente [[ISO/IEC 8859-1|Latin-1]]) é transformado em UTF-16 (Unicode de 16 bits), um byte zero é inserido após cada byte (caractere) do texto original. Obscou provou na {{ill|en|Phrack|Phrack}[ 61<ref name="Obscou_2003"/> que é possível escrever shellcode que pode ser executado com sucesso após esta transformação. Existem programas que podem codificar automaticamente qualquer shellcode em shellcode UTF-16 alfanumérico à prova, baseado no mesmo princípio de um pequeno decodificador auto-modificável que decodifica o shellcode original.

==Compatibilidade==
Geralmente, o shellcode é implantado como código de máquina, pois proporciona acesso relativamente desprotegido ao processo alvo. Como o código de máquina é compatível dentro de um contexto de computação relativamente estreito ([[CPU|processador]], [[sistema operacional]] e assim por diante), um fragmento de shellcode tem {{ill|en|Compatibilidade com computadores|Vompatibility (computing)|compatibilidade}} limitada. Além disso, como um ataque de shellcode tende a funcionar melhor quando o código é pequeno e atingir múltiplas explorações (exploits) aumenta o tamanho, tipicamente o código visa apenas uma exploração. No entanto, um único fragmento de shellcode pode funcionar para múltiplos contextos 
e explorações.<ref name="Eugene_2001">{{cite web |title=Architecture Spanning Shellcode |author=eugene |publisher=Phrack Inc. |work=Phrack |date=2001-08-11 |volume=0x0b |issue=57 |id=#0x0e of 0x12 |url=http://www.phrack.org/issues/57/14 |access-date=2008-02-29 |urlmorta=não |archive-url=https://web.archive.org/web/20211109173710/http://phrack.org/issues/57/14.html#article |archive-date=2021-11-09}}</ref><ref name="Nemo_2005">{{cite web |title=OSX - Multi arch shellcode. |author=nemo |work=[[Full disclosure (lista de discussão)|Full disclosure]] |date=2005-11-13 |url=https://seclists.org/fulldisclosure/2005/Nov/387 |access-date=2022-05-26 |url-status=live |archive-url=https://web.archive.org/web/20220526191616/https://seclists.org/fulldisclosure/2005/Nov/387 |archive-date=2022-05-26}}</ref><ref name="Cha-Pak-Brumley-Lipton_2010">{{cite conference |title=Platform-Independent Programs |author-first1=Sang Kil |author-last1=Cha |author-first2=Brian |author-last2=Pak |author-first3=David |author-last3=Brumley |author-link3=David Brumley |author-first4=Richard Jay |author-last4=Lipton |author-link4=Richard Lipton |conference=Proceedings of the 17th ACM conference on Computer and Communications Security (CCS'10) |location=Chicago, Illinois, USA |date=2010-10-08 |orig-date=2010-10-04 |publisher=[[Carnegie Mellon University]], Pittsburgh, Pennsylvania, USA / [[Georgia Institute of Technology]], Atlanta, Georgia, USA |isbn=978-1-4503-0244-9 |doi=10.1145/1866307.1866369 |pages=547–558 |url=https://softsec.kaist.ac.kr/~sangkilc/papers/cha-ccs10.pdf |access-date=2022-05-26 |urlmorta=não |archive-url=https://web.archive.org/web/20220526153147/https://softsec.kaist.ac.kr/~sangkilc/papers/cha-ccs10.pdf |archive-date=2022-05-26}} [https://web.archive.org/web/20220526182333/http://users.ece.cmu.edu/~sangkilc/papers/ccs10-cha.pdf] (12 pages) (See also: [https://security.ece.cmu.edu/pip/index.html])</ref> A versatilidade pode ser alcançada criando um único fragmento que contenha uma implementação para múltiplos contextos. O código comum ramifica para a implementação para o contexto de tempo de execução.

==Análise==
Como o shellcode geralmente não é executável por conta própria, para estudar o que ele faz, ele é tipicamente carregado em um processo especial. Uma técnica comum é escrever um pequeno programa em [[C (linguagem de programação)|C]] que contém o shellcode como dados (ou seja, em um buffer de bytes) e transfere o controle para as instruções codificadas nos dados (através de um {{ill|en|ponteiro de função|function pointer}} ou [[Linguagem assembly|código assembly]] em linha). Outra técnica é usar uma ferramenta online, como {{mono|shellcode_2_exe}}, para incorporar o shellcode em uma carcaça executável pré-fabricada que pode então ser analisada em um depurador padrão. Ferramentas especializadas de análise de shellcode também existem, como o projeto sclog da iDefense (originalmente lançado em 2005 no Malcode Analyst Pack). O sclog é projetado para carregar arquivos de shellcode externos e executá-los dentro de uma estrutura de registro (logging) de API. Também existem ferramentas de análise de shellcode baseadas em emulação, como a aplicação {{Mono|sctest}} que faz parte do pacote libemu de plataforma cruzada. Outra ferramenta de análise de shellcode baseada em emulação, construída em torno da biblioteca libemu, é o {{Mono|scdbg}} que inclui um shell de depuração básico e recursos de relatório integrados.

==Ver também==
* <!--{{Annotated link-->{{ill|en|Estouro de buffer de pilha|Stack buffer overflow}}
* {{Annotated link| Heap overflow|Estouro de heap}}
* {{Annotated link|Metasploit|Projeto Metasploit}}
* {{Annotated link|Segurança de computadores}}
* {{Annotated link|Shell shoveling}}

==Notas==
{{notelist}}

==Referências==
{{reflist}}
<!---->
[[Categoria:Falhas em segurança de computadores]]