Jump to content
  • Análise do malware IMG2005M.exe

       (0 reviews)

    Fernando Mercês
     Share

    Mês passado eu postei no blog uma análise básica de um malware brasileiro que recebi por e-mail. Algumas pessoas se ofereceram para continuar a análise mas não o fizeram, por motivos diversos. Eu tomei vergonha e achei uma máquina virtual com o XP e alguns programas velhos que ajudariam na análise. Este artigo é o meu relato sobre esse malware.

    No post do blog cheguei a identificar que o malware tinha UPX [1], então neste artigo vamos partir da remoção do packer:

    $ wc -c IMG2005M.exe
    58880 IMG2005M.exe
    
    $ upx -dqq IMG2005M.exe
    102400 <- 58880 57.50% win32/pe IMG2005M.exe
    
    $ wc -c IMG2005M.exe
    102400 IMG2005M.exe

    Ainda no Linux, fui atrás do entry point do binário com o pev [2]:

    $ pev -o IMG2005M.exe | grep -iA3 entry
    Entry point: 0x1758
    Address of CODE section: 0x1000
    Address of DATA section: 0x10000
    Imagebase: 0x400000

    Soma-se o EP à ImageBase e tem-se o offset do EP: 0x401758.

    Daqui pra frente resta muito pouco a se fazer com ferramentas nativas do Linux já que o binário é de Windows e o pev ainda não disassembla.

    Em seguida eu abri uma VM com Windows XP para ver a cara do inimigo:

    icone.png.6d9db8db87dfb8e1af13bae8e2dd780c.png

    Brincalhão esse coder hein? Detalhe para o ícone de fotos no EXE – usuário leigo cai fácil.

    Depois usei o RDG Packer Detector [3] para tentar descobrir o compilador utilizado no arquivo, se há alguma criptografia conhecida envolvida, hashes etc:

    rdg.png.20aaa7fddf8d4ad3465166c51d47d4b8.png

    O RDG detectou que é um binário compilado em Visual Basic 6.0, em código nativo. Pelo visto era só o UPX mesmo pois o RDG não detectou mais nada. No entanto, são suposições…

    Usando o OllyDbg [4], abri o malandro, e sempre a primeira coisa que vem em minha mente binária é buscar pelas strings hardcoded no executável. As strings dentro de um executável podem dizer *muito* sobre ele. Vale sempre a pena “passar o olho” nelas. No Olly é bem simples buscá-las: basta clicar com o botão direito e ir em “Search for -> All referenced strings”.

    Várias strings foram encontradas (referenced-strings.txt). Destaco algumas:

    UNICODE “*AC:Documents and SettingsMasterDesktopProfessor PardalSummer_TRSSummer_TRS.vbp”
    ASCII “GetLocaleInfoA”
    ASCII “GetUserDefaultLCID”
    UNICODE “6655475C45405C58521B606F53535577515F505640625441”
    UNICODE “625F5B06076B7A465047524C58585F6B4A46415059”
    UNICODE “695B5E545F470707584D1D4C5C46”

    A primeira string, bem, acho que dispensa comentários né? 

    Em seguida duas funções da API do Windows para identificação do idioma. Seria particularmente interessante um malware brasileiro ter versões do Windows em português como alvo?

    As outras três eu escolhi aleatoriamente. Acontece que criadores de malware sabem que precisam proteger suas strings, do contrário, muita coisa ficaria exposta a qualquer curioso que souber utilizar o comando strings do *n?x ou funções como essa do OllyDbg. Como há várias strings similares a essas três no binário, aposto que são strings encriptadas pelo programador do malware. Você não? =P

    De volta à tela do disassembly (ALT+C), parado bem no EP:

    00401758 PUSH 00401850
    0040175D CALL <JMP.&MSVBVM60.#100> ;Jump to MSVBVM60.ThunRTMain

    O jeito como o compilador constrói o executável é importante. No caso do VB é desse jeito acima: coloca-se um endereço na pilha e chama uma função da biblioteca. Esse endereço PUSHado é o offset de uma estrutura que define todo o programa em VB.

    Olhando a estrutura em 0x401850 no dump, dá pra identificar o offset do ProjectStruct (vem após esse 0x409):

    00401850  56 42 35 21|F0 1F 56 42|36 45 53 2E|44 4C 4C 00|  VB5!ðVB6ES.DLL.
    00401860  00 00 00 00|2A 00 00 00|00 00 00 00|00 00 00 00|  ….*………..
    00401870  00 00 0A 00|0A 0C 00 00|09 04 00 00|D0 AE 40 00|  ………..Ю@.
    00401880  D8 1B 40 00|00 F8 30 00|00 FF FF FF|08 00 00 00|  Ø@..ø0..ÿÿÿ…

    Então fui para o endereço 0x40AED0 no disassembler (CTRL+G) e coloquei um breakpoint (F2) logo no início da função. Aí foi só seguir com o F8 até chegar numa call que parecia interessante pois era uma chamada de função interna em 0x40AF1C.

    0040AF16  MOV EAX, DWORD PTR SS:[LOCAL.5]
    0040AF19  PUSH EAX
    0040AF1A  MOV ECX, DWORD PTR DS:[EAX]
    0040AF1C  CALL DWORD PTR DS:[ECX+1C] (0x40B450)
    0040AF1F  TEST EAX, EAX
    0040AF21  FCLEX

    Ao entrar nessa call, caí em 0x40B450. Nessa função dá pra ver uma daquelas strings doidas sendo operada em 0x40B4B7. Foi ali mesmo que coloquei um breakpoint e mandei rodar (F9).

    0040B4B0  MOV DWORD PTR SS:[LOCAL.1], 3
    0040B4B7  MOV EDX, 00402664  ; UNICODE “6655475C45405C58521B606F53535577515F505640625441”
    0040B4BC  LEA ECX, [LOCAL.11]
    0040B4BF  CALL DWORD PTR DS:[<&MSVBVM60.__vbaStrCopy>]
    0040B4C5  LEA EAX, [LOCAL.11]
    0040B4C8  PUSH EAX
    0040B4C9  LEA ECX, [LOCAL.17]
    0040B4CC  PUSH ECX
    0040B4CD  CALL 0040AF60
    0040B4D2  PUSH 0
    0040B4D4  LEA EDX, [LOCAL.17]
    0040B4D7  PUSH EDX
    0040B4D8  LEA EAX, [LOCAL.12]
    0040B4DB  PUSH EAX
    0040B4DC  CALL DWORD PTR DS:[<&MSVBVM60.__vbaStrVarVal>]
    0040B4E2  PUSH EAX
    0040B4E3  LEA ECX, [LOCAL.21]
    0040B4E6  PUSH ECX

    Fui seguindo com F8 e quando passei da chamada para __vbaStrVarVal em 0x40B4DC não é que a string se transformou?!

    O que era “6655475C45405C58521B606F53535577515F505640625441” virou “Scripting.SWbemObjectSet”, mas como? Os olhos aqui têm que estar afiados. Se liga:

    $ echo -n 6655475C45405C58521B606F53535577515F505640625441 | wc -c
    48
    
    $ echo -n Scripting.SWbemObjectSet | wc -c
    24

    A string encriptada tem o dobro do tamanho. Além disso, parecem ser bytes hexa já que todos os dígitos vão de 0 a F. Mas se você achou que o Professor Pardal simplesmente usou os bytes hexa de cada caracter da string original para encriptá-la, se enganou. É um pouquinho mais trabalhado. hehehe

    Repara que antes da string ser desencriptada, o fluxo de execução só passou por uma função local, uma call em 0x40B4CD para 0x40AF60. As outras são funções da MSVBVM60.DLL. Portanto pude supor que é nesta função que está a rotina de desencriptação, coloquei um breakpoint lá e comecei tudo de novo…

    Essa função que desencripta (0x40AF60) é relativamente grande. Vou resumir o que ela faz:

    O primeiro loop (de 0x40B08F a 0x40B123) cria a seguinte string fixa gigante que será usada mais à frente:

    “5655545655381688355541151683736525351505152535455336435363716816838424040414195431239696123125941259”

    Por que usar um loop para criar uma string fixa ao invés de declará-la hardcoded? Essa string é a chave para descriptografar todas as outras. O Professor Pardal não a deixaria tão solta. Se tiver curiosidade de descobrir como ela é gerada vai ser um ótimo treino, principalmente pra quem está começando. Qualquer coisa tô pelo Twitter.;)

    O segundo loop pega dois caracteres da string encriptada e os interpreta de uma vez como um byte hexadecimal (um número). Depois disso, XOReia (tem gente que fala mIgUxOO) este número com o equivalente númerico do caractere da string chave na mesma posição. Complicou? Vamos a um exemplo…

    String encriptada: 665547

    1. Pegam-se dois caracteres da string encriptada e os interpreta como um número hexa:
    “66” -> 0x66

    2. Pega-se o equivalente numérico de um caractere da string chave:
    “5” -> 0x35

    3. Faz-se o xor entre esses números
    0x66 ^ 0x35 = 0x53

    4. Converte o resultado para o equivalente em ASCII.
    $ printf “x53n”

    5. Volta para o passo 1 até que todos os caracteres da string encriptada tenham sido pegos, sempre dois a dois. O próximo cálculo será 0x55 ^ 0x36 e o outro, 0x47 ^ 0x35, certo?

    Pra você não se perder no disassembly, o xor fica em 0x40B309 – é uma chamada à função __vbaVarXor da MSVBVM60.DLL. Nem bitwise programa em VB faz, rapaiz!

    Escrevi um programa em C para fazer este trabalho sujo de desencriptar as strings (pardal_decrypt.c) :

    $ gcc -o pardal_decrypt pardal_decrypt.c
    
    $ ./pardal_decrypt 6655475C45405C58521B606F53535577515F505640625441
    Scripting.SWbemObjectSet

    Em 0x40B4E7, depois de desencriptar a primeira string, o malware chama a função rtcCreateObject2 da biblioteca. Conseguimos saber o nome dela graças à análise do OllyDbg. Dá pra imaginar o que essa função faz pelo nome e pela string que foi descriptografada antes dela.

    Não tenho intenção aqui de reescrever o código do malawre, então não vou me focar em como ele faz e sim o que ele faz. Logo, meus chutes de código não refletem necessariamente a realidade.

    Daqui pra frente seria bom acompanhar olhando o disassembly do malware (cuidado – não vá rodar o cara!)

    Na sequência, mais strings são desencriptadas: “Scripting.SWbemObjectSet” e “Scripting.SWbemObject”. Objetos destas classes também são criados. Em seguida mais duas strings: “Win32_OperatingSystem” e “winmgmts:{impersonationLevel=impersonate}”.

    Não é difícil deduzir que será feita uma query WMI. Em 0x40B672 há uma chamada para a rtcGetObject. É claro que ter alguma experiência com programação ajuda aqui. No caso de executáveis feitos em VB, ter programado em VBScript me ajuda.

    Entrando na call em 0x40B70D, cheguei na função 0x40E210, que pega o idioma da instalação do Windows. Ainda nesta função, em 0x40E38F, o malware verifica se a string “uguês (Brasil)” faz parte da string de retorno do idioma. É uma chamada à função InStr() do VB.

    De volta ao fluxo anterior, em 0x40B726 rola um “for each” que vai iterar através da coleção de objetos que a query “SELECT * FROM Win32_OperatingSystem”, montada algumas linhas antes, retorna. Nesse loop duas coisas são feitas: o atributo Caption do objeto retornado é guardado e o idioma é checado.

    Em 0x40B87F há uma call interna para 0x4019ED. Esta é um call bem legal de acompanhar de perto. Ela desencripta a string “TMP” e em 0x40BB58 chama a rtcEnvironBstr, que vai retornar o valor de uma variável de ambiente. No caso, o valor da variável de ambiente TMP que é o caminho completo do diretório temporário do usuário logado:

    C:> echo %TMP%
    C:DOCUME~1xpclientCONFIG~1Temp

    O malware desperta a curiosidade: o que ele quer no temp? Baixar algo? Gravar algo? Em 0x40BF57 o corno chama a rtcFileCopy e se copia para o diretório temporário do usuário. Em seguida testa se está no Windows Vista ou 7 para usar o runas, porque ele vai querer executar a sua cópia com privilégios administrativos.

    Em 0x40C101 ele manda executar sua cópia com uma chamada a rtcShell e morre. O trabalho sujo mesmo será feito pela cópia agora.

    Abri a cópia no debugger e vi que em 0x40C12A o malware verifica se seu caminho atual de execução é o diretório temporário. O problema é que pelo menos no Windows XP, essa checagem foi feita de maneira errada (pois é, bug no malware). O caminho atual pego vem no formato 8.3 do DOS. Veja:

    0040C12A  MOV EAX, DWORD PTR SS:[LOCAL.10] ; UNICODE “C:\DOCUME~1\xpclient\CONFIG~1\Temp\IMG2005M.exe”

    Quando essa string é comparada com o conteúdo da variável ambiente TMP, o resultado é falso e o malware tenta se copiar novamente para o temp, mas já existe um executável dele lá (que é ele mesmo) e não consegue se copiar. Aí entra em loop. =P

    Zerei, em tempo de execução, o valor de EAX, que é o registrador que armazena o retorno da __vbaStrCmp, para que o salto em 0x40C132 aconteça.;)

    Seguindo a análise, entrei numa call para 0x40C640 que busca o valor “EnableLUA” na chave “HKLMSOFTWAREMicrosoftWindowsCurrentVersionPoliciesSystem”. Caso não exista ou não seja zero, o malware seta para zero, desabilitando esta proteção do Windows.

    Mais a frente, em 0x40C939 ele exibe essa mensagem:

    msgbox.png.5ad2a82a47a43c63b275ed1e599df3ab.png

    Isso não é um erro causado pelo malware – é uma mensagem inofensiva, exibida de propósito. O texto é fixo e essas strings fazem parte das strings criptografadas. Elas estão em 0x40C8CF e 0x40C8EA.

    Agora o processo fica residente aguardando acesso à internet. Para isso ele tenta acessar a página do Google. Quando conseguir, vai para a última função do mal em 0x40C9D0. À esta altura do campeonato, basta olhar a função que você vai perceber todo este fluxo.;)

    Logo no início dela, um arquivo mkajs21mx.tmp é criado no diretório temp do usuário. Em seguida o malware faz uma conexão com um serivodr MS-SQL remoto, na URLia8eaatjyur0gqzaslrlqw2n8k.zlg.br na porta 9321. Nome de usuário, senha e nome do banco também são desencriptados pela mesmíssima rotina 0x40AF60. Após conectar, o malare faz a seguinte query SQL:

    SELECT TOP 1 * FROM Professor_Carregador ORDER BY Professor_Carregador_ID DESC

    O retorno dessa consulta tem ~70k e começa com 0x4d e 0x5a. O que é o que é? =D

    O malware salva o binário pego via SQL em %WINDIR%System32MakeObject.dll e depois registra essa DLL com o regsvr32.exe como um complemento do IE:

    complemento.png.35a43b5f9f9c9c57a0ff526b75e22006.png

    Aí vem outra query:

    INSERT INTO Professor_Informa(Professor_Informa_WithEvents,Professor_Informa_Control) VALUES(‘0’, ‘0’)

    Fiz um script em VBScript pra pegar alguns registros deste banco (pardal_sql.vbs) e descobri que há mais de 6000 registros já. Ou seja, um número próximo desse de computadores brasileiros foram infectados. Impressionante. Já em relação aos registros, não tem nada demais.

    Por fim, só pra não dizer que não perturbou, o malware tenta apagar o arquivo WAV que é o somzinho de inicialização do Windows, mas pelo menos no XP SP3 PT-BR ele errou o nome e tentou apagar o Início do Windows XP.wav quando o nome real é Inicialização do Windows XP.wav. Segundo bug. ¬¬

    E o que faz a MakeObject.dll? Eu dei uma pesquisada e achei alguns usuários reportando sintomas de envio automático de e-mail via Hotmail. Por coincidência ou não, todos tinham essa DLL em logs do HiJackThis. Mas no momento estou cansado de ver funções do VB na minha frente. Então quem quiser analisar, eu envio a DLL.

    Os usuários de Windows têm então mais duas coisas para se preocupar: a falta do somzinho de incialização e um MakeObjects como complemento no IE. Sem falar na DLL em si, que não sabemos o que faz ainda. Boa sorte! hehe

     

    Referências:


    [1] upx.sourceforge.net
    [2] https://github.com/merces/pev
    [3] rdgsoft.net
    [4] www.ollydbg.de


    Revisão: Leandro Fróes
     Share


    User Feedback

    Join the conversation

    You can post now and register later. If you have an account, sign in now to post with your account.
    Note: Your post will require moderator approval before it will be visible.

    Guest

    • This will not be shown to other users.
    • Add a review...

      ×   Pasted as rich text.   Paste as plain text instead

        Only 75 emoji are allowed.

      ×   Your link has been automatically embedded.   Display as a link instead

      ×   Your previous content has been restored.   Clear editor

      ×   You cannot paste images directly. Upload or insert images from URL.


  • Similar Content

    • By Bruna Chieco
      Os operadores do SolarMarker estão usando envenenamento de Search Engine Optimization (SEO) para encher milhares de PDFs com dezenas de milhares de páginas cheias de palavras-chave e links que visam fazer redirecionamentos que levam ao malware. O SolarMarker é um malware de backdoor que rouba dados e credenciais dos navegadores.
      Segundo a Microsoft Security Intelligence, o ataque funciona usando documentos PDF projetados para classificação nos resultados da pesquisa. Para conseguir isso, os invasores preencheram esses documentos com mais de 10 páginas de palavras-chave em uma ampla variedade de tópicos, desde “formulário de seguro” e “aceitação de contrato” a “como ingressar no SQL” e “respostas matemáticas”.
      Os pesquisadores observaram que esses invasores usaram o Google Sites para hospedar esses documentos. Em campanhas recentes, os atacantes passaram a usar principalmente o Amazon Web Services e o Strikingly. 
      Quando abertos, os PDFs solicitam que os usuários baixem um arquivo .doc ou uma versão .pdf das informações desejadas. Os usuários que clicam nos links são redirecionados por 5 a 7 sites com TLDs como .site, .tk e .ga.
      Os pesquisadores dizem ainda que após vários redirecionamentos, os usuários chegam a um site controlado pelo invasor, que imita o Google Drive, e são solicitados a baixar o arquivo, que normalmente é o malware SolarMarker/Jupyter. Também foram vistos arquivos aleatórios sendo baixados em uma tática de evasão de detecção/análise.
    • By Bruna Chieco
      O Siloscape é o primeiro malware que tem como alvo os contêineres do Windows – tecnologia para empacotamento e execução de aplicativos. Segundo o ThreatPost, o malware implanta backdoors e nós de invasão para obter credenciais de usuários.
      A campanha em andamento perfura os clusters do Kubernetes – sistema de orquestração de contêineres open-source – para a implantação de backdoors, permitindo que os invasores roubem dados e credenciais do usuário ou sequestrem bancos de dados inteiros hospedados em um cluster.
      Segundo a reportagem, o malware foi descoberto pelo pesquisador de segurança da Unidade 42, Daniel Prizmant, que o apelidou de Siloscape, ou "Fuga do Silo". O malware explora vulnerabilidades conhecidas em servidores da web e bancos de dados para comprometer os nós do Kubernetes e os clusters de backdoor. 
      Prizmant fez um trabalho de engenharia reversa para conseguir se conectar ao servidor de comando e controle (C2) do Siloscape, onde descobriu que estava hospedando um total de 313 usuários. Isso implica que o Siloscape é uma pequena parte de uma campanha mais ampla, observou ele. Prizmant destaca que o Siloscape é um malware fortemente ofuscado. 
      Os pesquisadores da Unidade 42 identificaram 23 vítimas do Siloscape e disseram que as evidências indicam que a campanha foi lançada há mais de um ano, podendo ter iniciado em janeiro de 2020. 
      A recomendação é que os usuários sigam o conselho da Microsoft para não usar contêineres do Windows como um recurso de segurança. Em vez disso, a Microsoft recomenda o uso estritamente de contêineres Hyper-V para qualquer coisa que dependa da conteinerização como limite de segurança. 
    • By Leandro Fróes
      Depois de muita espera a NSA anunciou oficialmente a inclusão de um debugger no Guidra na sua versão 10.0. Depois de muita discussão sobre esta possibilidade o time de desenvolvimento do framework lançou uma release beta da versão 10.0 ontem!
      Neste momento o debugger suporta analisar aplicações em userland e consegue debuggar tanto binários Windows quanto Linux (utilizando o gdb neste caso). Para quem quer começar logo de cara o Guidra disponibiliza um tutorial de início rápido em Help -> Guidra Functionality -> Debugger -> Getting Started:

      Existem várias formas de iniciar o debugger, desde clicando com o Botão direito -> Open With -> Debugger até direto da sua Project Window do Guidra clicando no ícone de "bug" debaixo de "Tool Chest", como mostrado abaixo:

      Uma vez que a ferramenta é inicializada você deve importar o arquivo a ser depurado para a ferramenta. Uma das formas de fazer isto é simplesmente o arrastando da Project Window. Uma fez carregado podemos ver a cara do mais novo debugger do Guidra:

      Algumas das funcionalidades são: debugging remoto utilizando GDB e windbg, rodar o debugger direto no programa do qual você está analizando estaticamente e tracing de memória.
      Além disso ele também conta com as funcionalidades básicas de um debugger como utilização de breakpoints, listagem de regiões de memória mapeadas, estados dos registradores e uma interface de linha de comando própria.
      Todas as funcionalidades listadas aqui possuem sua própria View, isto é, sua própria janela dentro da ferramenta:


      Vale lembrar que esta release está em sua versão beta e tem como objetivo principal coletar o feedback da comunidade. Caso queira dar uma testada e/ou dar um feedback pra galera do Guidra basta baixar a release clicando no botão abaixo 😉.

    • By Bruna Chieco
      Uma versão falsa do aplicativo de desktop remoto AnyDesk contendo um cavalo de Troia (trojan) apareceu em meio aos anúncios dos resultados de pesquisa do Google. A empresa de segurança CrowdStrike descobriu que a campanha está ativa desde abril e aparentemente superou a própria propaganda oficial do AnyDesk no Google.
      "O uso malicioso do Google Ads é uma maneira eficaz e inteligente de obter implantação em massa de shells, pois fornece ao agente da ameaça a capacidade de escolher livremente seus alvos de interesse", diz a empresa de segurança. "Além de direcionar ferramentas como AnyDesk ou outras ferramentas administrativas, o ator da ameaça pode direcionar usuários privilegiados/administrativos de uma maneira única". 
      Por esse motivo, a equipe CrowdStrike notificou o Google sobre a atividade observada para que tomassem medidas contra a campanha de malvertising – anúncio publicitário online geralmente usado para espalhar malware na Internet – e, aparentemente, o Google rapidamente tomou as medidas adequadas, já que o anúncio não está mais sendo veiculado, segundo a empresa.
      Os criminosos por trás do anúncio malicioso conseguiram, antes de serem descobertos, evitar o policiamento de triagem anti-malvertising do Google. Como resultado, 40% daqueles que clicaram no anúncio começaram a instalar o malware, sendo que 20% dessas instalações incluíam “atividades práticas no teclado”, de acordo com o relatório publicado pela CrowdStrike.
      Os pesquisadores dizem ainda que as vítimas que baixaram o programa foram induzidas a executar um binário chamado AnyDeskSetup.exe. Depois de executado, o malware tenta iniciar um script do PowerShell. O arquivo executável falso foi assinado por "Digital IT Consultants Plus Inc.", em vez dos criadores legítimos "philandro Software GmbH".
      A CrowdStrike informa que sua equipe de inteligência continua investigando e, no momento, não atribui essa atividade a um agente de ameaça ou vínculo específico. No entanto, dada a popularidade do AnyDesk, essa pode ser uma campanha generalizada que afeta uma ampla gama de clientes. 
    • By Leandro Fróes
      E lá vai mais uma do horsicq! No dia de hoje horsicq, criador de inúmeras ferramentas de análise incluindo o incrível Detect It Easy (DIE), lançou a primeira release do seu novo projeto, um analisador de arquivos MachO chamado XMachOViewer.

      Para quem já utilizou o DIE vai notar uma grande semelhança no design e usabilidade. Já aquelas que não estão familiarizados com as ferramentas do horsicq (deveriam, sério!) fiquem tranquilos, todas são bem simples e intuitívas de se usar.
      Ao contrário do DIE o XMachOViewer tem foco exclusivo em binários MachO. Em relação à funcionalidades a ferramenta consegue fazer tudo que o Detect It Easy faz e ainda mais, tudo isso com uma console exclusiva e mais detalhada: 

      Dentre as funcionalidades novas temos a busca por padrões de criptografia (Base64, RSA, etc), muito útil para análise de malware, por exemplo:

      Name demangling (precisamos dizer o quanto isso é útil? 😄) :

      E também uma funcionalidade de hashing (por que não, né?):

      Além disso, devido à natureza interativa da ferramenta ela permite você editar o arquivo diretamente, bastando apenas selecionar o campo que deseja e começar a digitar:

      A versão 0.01 está pronta para download e com certeza vale uma conferida:

×
×
  • Create New...