Diferentemente do que muitos pensam, para se obter um software de qualidade, ser bom programador e dominar uma linguagem de programação não é o suficiente. Para criar softwares de qualidade é necessário muito mais do que um bom programador e uma boa linguagem de programação.

Inicialmente, todo sistema tem um propósito e uma necessidade de criação. Nenhum desenvolvedor ou empresa irá criar um software que não será usado por ninguém. Dessa forma um software sempre deverá ser criado para atender às necessidades de alguém. E essas necessidades podem e devem ser "traduzidas" em requisitos.

A análise e especificação de requisitos de um software consiste nas atividades de determinar os objetivos de um sistema de software e as restrições associadas a ele.

Esta análise também deve estabelecer o relacionamento entre estes objetivos e restrições e a especificação precisa do software

A maior parte dos problemas no desenvolvimento de software são originados nas etapas iniciais do desenvolvimento justamente na etapa de levantamento e definição dos requisitos do sistema onde as principais atividades são:

• elicitação,
• análise, 
• especificação, 
• gerenciamento
• validação de requisitos.

Havendo falhas na realização em uma dessas atividades, haverá inconsistência nos documentos de requisitos e o que acarretará um software de baixa qualidade com um custo elevado.

Então o que é um requisito de software ?

Os requisitos expressam as características e restrições do produto de software do ponto de vista de satisfação das necessidades do usuário, e, em geral independem da tecnologia empregada na construção da solução sendo a parte mais crítica e propensa a erros no desenvolvimento de software.

Requisitos são objetivos ou restrições estabelecidas por clientes e usuários do sistema que definem as diversas propriedades do sistema. Os requisitos de software são, obviamente, aqueles dentre os requisitos de sistema que dizem respeito a propriedades do software.

Um conjunto de requisitos pode ser definido como uma condição ou capacidade necessárias que o software deve possuir:

1. para que o usuário possa resolver um problema ou atingir um objetivo
   
   ou
    
2. para atender as necessidades ou restrições da organização ou dos outros componentes do sistema.

Na maioria dos casos, os requisitos de software são separados em requisitos funcionais e não-funcionais.

Os requisitos funcionais são a descrição das diversas funções que clientes e usuários querem ou precisam que o software faça. Eles definem a funcionalidade desejada do software.

O termo função é usado no sentido genérico de operação que pode ser realizada pelo sistema, seja através comandos dos usuários ou seja pela ocorrência de eventos internos ou externos ao sistema.

São exemplos de requisitos funcionais:

• "o software deve possibilitar o cálculo dos gastos diários, semanais, mensais e anuais com pessoal".
• "o software deve emitir relatórios de compras a cada quinze dias"
• "os usuários devem poder obter o número de aprovações, reprovações e trancamentos em todas as disciplinas por um determinado período de tempo.

A especificação de um requisito funcional deve determinar o que se espera que o software faça, sem a preocupação de como ele faz.

É importante diferenciar a atividade de especificar requisitos da atividade de especificação que ocorre durante o design do software.

No design do software deve-se tomar a decisão de quais a funções o sistema efetivamente terá para satisfazer àquilo que os usuários querem.

Requisitos não-funcionais são as qualidades globais de um software, como:

• manutenibilidade,
• usabilidade,
• desempenho, 
• custos 
• várias outras. 

Normalmente estes requisitos são descritos de maneira informal, de maneira controversa (por exemplo, o gerente que segurança mas os usuários querem facilidade de uso) e são difíceis de validar.

São exemplos de requisitos não-funcionais:

• "a base de dados deve ser protegida para acesso apenas de usuários autorizados".'
• "o tempo de resposta do sistema não deve ultrapassar 30 segundo".
• "o software deve ser operacionalizado no sistema Linux"
• "o tempo de desenvolvimento não deve ultrapassar seis meses".

A necessidade de se estabelecer os requisitos de maneira de forma precisa é crítica na medida que o tamanho e a complexidade do software aumentam. Os requisitos exercem influência uns sobre os outros.

Por exemplo, o requisito portabilidade, que muitas vezes faz o desenvovedor achar que deve usar Java para desenvolver, acaba influenciando diretamente no requisito "ser rápido". Softwares em java geralmente são "pesados".

Uma boa especificação de requisitos deve ser:

• Clara e não-ambígua
• Completa
• Correta
• Compreensível
• Consistente
• Concisa
• Confiável

De acordo com Farley, um documento de especificação de requisitos deve possui as seguintes seções:

• Visão geral do produto e Sumário
• Ambientes de desenvolvimento, operação e manutenção
• Interfaces Externas e Fluxo de Dados
• Requisitos Funcionais
• Requisitos de Desempenho
• Tratamento de Exceções
• Prioridades de Implementação
• Antecipação de mudanças e extensões
• Dicas e diretrizes de Design
• Critérios de aceitação
• Índice Remissivo
• Glossário

Construir um sistema de software com base em requisitos inconsistentes e mal discriminados é como construir um edifício sem vigas.

Referências :

http://www.dimap.ufrn.br/~jair/ES/es99c3.html - Jair C Leite, 1999

Após fazer algumas abordagens mais simples à alguns conceitos de Orientação a Objeto em Javascript, hoje irei ensinar como trabalhar com namespaces.

"Registrando" um namespace

Registrar um namespace em javascript, pode ser feito de várias formas possíveis, porém inicialmente irei abordar a forma, que no meu ponto de vista, é a mais fácil e prática.

Para registrar um namespace, basta criar uma variável atribuindo ela à ela mesmo e usando o operador lógico || e logo após {} que definirá a variável como um objeto caso ela esteja indefinida.

Criando o namespace

    //Namespace Carros
    var Carros = Carros || {};
    Carros.quantidade = 3;
    
    alert(Carros.quantidade); // mostrará na tela o valor 3

Uma abordagem mais complexa

Agora que temos o namespace "Carros" criado, vamos fazer uma abordagem um pouco mais complexa ao objeto criando "sub" namespaces. Vejamos o exemplo:

   
    //Namespace HondaCivic
    Carros.HondaCivic = {};
    Carros.HondaCivic.ano = 2011;
    Carros.HondaCivic.cor = "preto";
    
    //Namespace Camaro
    Carros.Camaro = {};
    Carros.Camaro.ano = 2010;
    Carros.Camaro.cor = "amarelo";
    
    //Namespace AudiTT
    Carros.AudiTT = {};
    Carros.AudiTT.ano = 2010;
    Carros.AudiTT.cor = "cinza";
    
    
    alert(Carros.HondaCivic.cor); // mostrará na tela o valor preto
    alert(Carros.HondaCivic.ano); // mostrará na tela o valor 2011

Que tal uma função para registrar vários níveis de namespace?

	function regNS(ns)
	{
		var nameSpaces = ns.split(".");
		var raiz = window;
	
		for(var i=0; i < nameSpaces.length; i  )
		{
			if(typeof raiz[nameSpaces[i]] == "undefined")
			raiz[nameSpaces[i]] = new Object();
			raiz = raiz[nameSpaces[i]];
		}
	}

Exemplo de uso

Para demonstrar o quanto o Javascript é flexível, vou fazer uma demonstração utlizando duas abordagens diferentes de de criar namespaces.

Primeiro, irei criar o namespace Carros conforme no início deste post

	//Namespace Carros
	var Carros = Carros || {};
	Carros.quantidade = 3;

Depois, irei criar o namespace Casa.Garagem utilizando a função regNS que criamos acima

	regNS("Casa.Garagem");

No final, podemos simular herança, atribuindo o namespace Carros ao namespace Casa.Garagem.Carros

	Casa.Garagem.Carros = Carros;
	
	alert(Casa.Garagem.Carros.quantidade);  // mostrará na tela o valor 3

O que são Aplicativos Ricos?

A grande rede mundial vem se modernizando cada vez mais e com isso possibilitando o avanço e surgimento de diversas tecnologias e metodologias.

Graças ao aumento de velocidade de acesso à rede e a diminiuição de problemas como intermitência no sinal, foi possível aprimorar metodologias de desenvolvimento web e trazer para esse ambiente, características até então somente presentes em aplicativos desktop. Então, eis surge um novo conceito para desenvolvimento web: RIA.

RIA, da sigla em inglês Rich Internet Application, nada mais é que um aplicativo web com características de aplicativos desktop com interface. Um aplicativo RIA, tem por conceito uma interface que mimifica os recursos encontrados em aplicativos GUI presente em qualquer Sistema Operacional.

Nos aplicativos RIA, todos (ou quase todos) os recuros pertinentes a interface são processados pelo browser, e estado e dados da aplicação continuam sendo executados no servidor de aplicativos.

"Aplicações web tradicionais centralizam todo seu código em torno de uma arquitetura de Cliente-servidor e um cliente magro. Todo o processamento é realizado no servidor, e o cliente apenas utiliza uma tela estática (neste caso em HTML). A grande desvantagem deste sistema é que a interação com a aplicação deve ser feita através do servidor, onde os dados são enviados para o servidor, são respondidos e a página é recarregada no cliente como resposta. Utilizando uma tecnologia uma aplicação-cliente que possa executar instruções no computador do usuário, RIAs podem reduzir significativamente o número de sincronizações e aumentar a interatividade com o cliente. Esta diferença pode ser verificada fazendo uma analogia entre terminal e mainframe e servidor de aplicação/Cliente Gordo. " (trecho retirado da WIKIPEDIA)

Em alguns contextos, fica difícil dizer o que é RIA ou não, porém uma característica é comum a este conceito: eles introduzem uma camada intermediária de código, chamada normalmente de client engine, entre o usuário e o servidor. Este client engine é normalmente carregado no início da aplicação, e pode ser acrescido de outras atualizações do código que são baixadas enquanto a aplicação ainda está rodando. O client engine atua como uma extensão do navegador, e é responsável pela renderização da interface de aplicação do usuário e fazer a comunição com o servidor.

Atualmente, para o desenvolvimento RIA, ainda não há um grande número de ferramentas e recursos se comparados com outros conceitos, porém existem alguns frameworks bem ricos e maduros com esse propósito, como DHTMLX e EXTJS.

Eu não incluiría frameworks como Jquery e Prototype nessa lista, porque esses frameworks tem como propósito simplificar a escrita de códigos Javascript, e nao implementar componentes característicos de softwares GUI como DHTMLX e EXTJS fazem.

O que é Middleware

Middleware ou mediador, no campo da computação distribuída, é um programa de computador que faz e mediação entre software e demais aplicações. É utilizado para mover ou transportar informações e dados entre programas de diferentes protocolos de comunicação, plataformas e dependências do sistema operacional.

É geralmente constituído por módulos dotados com APIs de alto nível que proporcionam a sua integração com aplicações desenvolvidas em diversas linguagens de programação e interfaces de baixo nível que permitem a sua independência relativamente ao dispositivo. Seu objetivo é mascarar a heterogeneidade e fornecer um modelo de programação mais produtivo para os programadores de aplicativos.

É composto por um conjunto da processos ou objetos em um grupo de computadores, que interagem entre si de forma a implementar comunicação e oferecer suporte para compartilhamento de recursos e aplicativos distribuídos.

O Middleware é a designação genérica utilizada para referir aos sistemas de software que se executam entre as aplicações e os sistemas operacionais.

O objetivo do middleware é facilitar o desenvolvimento de aplicações, tipicamente as distribuídas, assim como facilitar a integração de sistemas legados ou desenvolvidos de forma não integrada automática.

Liberdade pra uns, escravidão pra outros

Com o amadurecimento da web, foram surgindo diversos ambientes servidores, e consecutivamente diversas outras APIs para esses servidores. Muitos enchergam essa vasta quantidade de opções de servers web como uma "liberdade", porém, o que muitos não vêem, é que na maioria dos casos, ao escolher aquele ambiente e aquela API, o desenvolvedor se tornou eterno escravo daquele ambiente. Ou seja, seu aplicativo, pra "rodar" sempre dependerá daquela tecnologia, e assim, ele acabou de virar um escravo.

E assim, o conceito de Middleware nunca foi tão valioso, e esse sim, pode ser intitulado por "liberdade", pois lhe garante desenvolver um aplicativo que funcione em qualquer ambiente servidor, e o tempo que seria perdido com peculiaridades do ambiente, poderá ser empenhado em tarefas pertinentes a melhoria da aplicação em si.

Seguindo os ensinamentos de meu querido amigo e professor Edem Cardim, resolvi estudar e empregar um fantástico modulo perl que consiste num "kit" de ferramentas, dentre elas um middleware e server de teste que é o Plack -> http://search.cpan.org/dist/Plack/lib/Plack.pm

Então resumindo, com o Plack, pude constuir um aplicativo sem me preocupar com o ambiente servidor, e com isso me dedicar mais ao aplicativo em si.

Definindo "ferramentas & recursos"

1 - IDE Perl: Padre (http://padre.perlide.org/)

2 - Ambiente de desenvolvimento: Plack

3 - Interface HTTP: CGI (http://search.cpan.org/~markstos/CGI.pm-3.55/lib/CGI.pm), poderia ser qualquer outra.

4 - Framework Javascript: DHTMLX (www.dhtmlx.com) O framework DHTMLX é um framework muito rico e maduro e oferece diversos componentes RIA para aplicações de propósitos diversos. Possui versão open e paga. Iremos utilizar a open, lógico.

Definindo o "aplicativo"

O aplicativo tem como idéia principal mimificar um aplicativo do tipo Gerenciador de Arquivos

Funções Principais:

        # Visualização dos diretórios em "estrutura de árvore"

        # Visualização dos arquivos contidos no diretório com informações particulares sobre cada um

        # Criação de diretórios

        # Exclusão de diretórios

        # Visualização de arquivos

        # Download de arquivos

        # Exclusão de arquivos

Preparando o Ambiente

Pra mostrar a verdadeira liberdade que o Plack dá ao desenvolvedor, vou fazer o deploy de nossa aplicação em um SO Windows 2008 Server e esta mesma aplicação rodará em qualquer ambiente que tenha Perl instalado. Porém, quem quiser fazer o deploy num SO linux ou unix, poderá efetuar os mesmos procedimentos correspondentes.

1º passo: Instalar o Perl

        # Windows
        
        1 - Vá até a url http://strawberryperl.com/ e baixe o Strawberry Perl seguindo o link  Download Strawberry Perl 5.12.3.0 e instale. Durante a instalação, 
        escolha o diretório C:\strawberry para a instalação do Strawberry Perl
        
        # Linux, Unix, Mac
        A maioria desses SOs ja vêm com perl instalado. Digite perl -v numa linha de comando para saber qual a versao do seu Perl

2º passo: Instalar os módulos Perl que utilizaremos em nossa aplicação

        1 - Abra o prompt de comando. Menu Iniciar => Executar => cmd "enter".
        
        2 - Já no prompt de comando, digite o seguinte comando cd c:\strawberry\perl\bin para "entrarmos" no diretório onde se encontram os binários do Perl
        
        3 - Digite o comando => cpanm CGI => dê enter para instalar o Modulo CGI. Após terminar, siga o próximo comando.
        
        4 - Digite o comando => cpanm CGI::Emulate::PSGI => dê enter para instalar o Modulo CGI::Emulate::PSGI. Após terminar, siga o próximo comando.
        
        5 - Digite o comando => cpanm CGI::Compile => dê enter para instalar o Modulo CGI::Compile. Após terminar, siga o próximo comando.
        
        6 - Digite o comando => cpanm Plack => dê enter para instalar o Modulo Plack. Após terminar, siga o próximo comando.
        
        7 - Digite o comando => cpanm JSON => dê enter para instalar o Modulo JSON. Após terminar, siga o próximo comando.
        
        8 - Digite o comando => cpanm Date::Day => dê enter para instalar o Modulo Date::Day. Após terminar, siga o próximo comando.
        
        9 - Digite o comando => cpanm Date::Language => dê enter para instalar o Modulo Date::Language. Após terminar, siga o próximo comando.
        
        10 - Digite o comando => cpanm Path::Class => dê enter para instalar o Modulo Path::Class. Após terminar, siga o próximo comando.
        
        11 - Digite o comando => cpanm HTML::Entities => dê enter para instalar o Modulo HTML::Entities.

3º passo: Criar estrutura de diretórios para a aplicação

        Como meu HD é particionado, vou criar o minha estrutura de diretórios no drive D:\
        A estrutura de diretórios ficará assim:
        
        D:\artigo\
        =>      diretório "container"  de nossa aplicação
        
        D:\artigo\plack_conf\
        =>      diretório onde armazenaremos o arquivo de configuracao de nossa aplicação plack
        
        D:\artigo\www\

        =>      diretório raiz de nosso aplicativo web que vamos construir
        
        D:\artigo\www\cgi-bin\
        =>      diretório onde armazenaremos os arquivos Perl de nosso aplicativo web que vamos construir
        
        D:\artigo\www\gerenciadordedocumentos\
        =>      diretório que servirá para armazenar os files que nosso aplicativo web irá gerenciar
        
        D:\artigo\www\static\
        => diretório onde armazenaremos os arquivos estáticos de nossa aplicação web. aqui ficarão os arquivos como html, javascripts e imagens
        
        D:\artigo\www\static\codebase\
        =>      diretório onde iremos armazenar os arquivos dos componentes do framework DHTMLX que iremos utilizar em nossa aplicação
        
        D:\artigo\www\static\javascript\
        => diretório onde armazenaremos os scripts javascript que iremos construir para nossa aplicação
        

4º passo: Criar o arquivo de configuracao da aplicação plack

Abra seu editor de texto preferido e cole o seguinte código:

		use warnings;
		use strict;


		# Importar modulos Plack
		use Plack::Builder;
		use Plack::App::CGIBin;
		use Plack::App::Directory;

		# configuracao do mapeamento da raiz do aplicativo web, com possibilidade de usar arquivos dinamicos como .pl
		my $root = Plack::App::CGIBin->new(
		  root => "D:/artigo/www/",
		)->to_app;

		# configuracao do mapeamento para o diret?rio que est?o os arquivos din?micos como os .pl
		my $cgi_bin = Plack::App::CGIBin->new(
		  root => "D:/artigo/www/cgi-bin/",
		)->to_app;
		
		# configuracao do mapeamento para o diret?rio onde est?o os arquivos est?ticos diversos
		my $static = Plack::App::Directory->new(
		  root => "D:/artigo/www/static/"
		)->to_app;

		# configuracao do mapeamento para o diret?rio que servir? como container dos files gerenciados pela aplica??o
		my $files_dir = Plack::App::Directory->new(
		  root => "D:/artigo/www/gerenciadordedocumentos/"
		)->to_app;

		# montagem dos mapeamentos da aplica??o plack
		builder {
		  mount '/' => $root;
		  mount '/cgi-bin' => $cgi_bin;
		  mount '/static'  => $static;
		  mount '/gerenciadordedocumentos'  => $files_dir;
		}

Salve o arquivo com o nome de app.psgi no diretório D:\artigo\plack_conf\

5º passo: Iniciar a aplicação plack na porta 5000 da máquina

        1 - Abra o prompt de comando. Menu Iniciar => Executar => cmd "enter".
        
        2 - Já no prompt de comando, digite o seguinte comando cd c:\strawberry\perl\bin para "entrarmos" no diretório onde se encontram os binários do Perl
        
        3 - Digite o seguinte comando: plackup d:\artigo\plack_conf\app.psgi                    => dê enter
        
        4 - Você verá no terminal escrito: HTTP::Server::PSGI: Accepting connections at http://0:5000/  => a partir deste momento, você ja pode acessar sua aplicação
        pelo browser, digitando por exemplo a seguinte url: http://127.0.0.1:5000
        Porém, nossa aplicação web ainda não foi construída, e logo, o plack não tem nada à servir para o browser.

6 passo: Construir o aplicativo web

1 - Baixar e armazenar os arquivos do framework DHTMLX que iremos utilizar na interface RIA.

Em nossa aplicação, iremos utilizar os seguintes componentes da versão 2.5 :

        # DHTMLX layout API
        # DHTMLX tree API
        # DHTMLX windows API
        # DHTMLX folders  API - atual DATAVIEW na lib 3.0 (versao current)
        # DHTMLX toolbar API
        # DHTMLX menu API
        
        Baixe o arquivo http://www.web2solutions.com.br/artigo/codebase.rar contendo todos os componentes já "instalados" no mesmo diretório.
        Descompacte os arquivos dentro do diretório D:\artigo\www\static\codebase\

Você ainda poderá baixar a suite DHTMLX diretamente no site da fabricante em http://www.dhtmlx.com.br. A suíte vem com cada componente isolado em seus respectivos diretórios

2 - Vamos criar o arquivo principal de nossa interface.

Abra seu editor de texto preferido e crie um novo arquivo do tipo XHTML (contendo doctype, head e body).

No HEAD, faremos uma "chamada" para um arquivo Javascript contendo um Objeto especialmente construído para representar nossa aplicação

Objeto Javascript principal da aplicação

 <script src="javascript/Perl_File_Explorer.js"></script><!-- ============ OBJETO FILE EXPLORER ============ -->

Ainda na tag HEAD, instanciaremos nosso objeto FILE EXPLORER e faremos um controle simples de carregamento da aplicação utilizando o evento onload do DOM

Instanciando o Objeto Javascript principal da aplicação

        //===> instanciamos o objeto
        var explorer = new Perl_File_Explorer(); //==> Cria o objeto explorer no escopo
        //===> certificamos que o documento foi totalmente carregado
        window.onload = function() //==> quando o DOM tiver totalmente carregado, inicia o processo de parser do FILE EXPLORER
        {
            //===> iniciamos nossa aplica??o atrav?s do m?todo init
            explorer.init();
        }

O BODY

Agora iremos construir body de nossa aplicação. O seletor body será utilizado para o parser o layout DHTMLX principal da aplicação. Em aplicaçõs RIA com javascript, é normal utilizar elementos inline do DOM para fazer parser de elementos construídos (componentes), bem como a criação de elementos html em tempo de execução, e a partir daí contruir terceiros elementos (componentes). No nosso exemplo, todos os elementos HTML serão criados em tempo de execução. Assim, crie o body de sua página vazio e atribua a ele o id ¨body¨

Salve o arquivo como view.html no diretório D:\artigo\www\static\

3 - Objeto Javascript Perl File Explorer

Vamos criar um objeto Javascript que controlará boa parte de nossa aplicação web. Nesse objeto haverão as funções principais de nossa interface web. Funcionará como uma camada intermediária entre os componentes DHTMLX e a aplicação em si

Abra seu editor de texto preferido e cole o seguinte código do objeto que pode ser encontrado no seguinte paste: http://pastebin.com/rWtyxtk4

		function Perl_File_Explorer()
		{
			//==> copie e cole o c?digo do paste :  http://pastebin.com/rWtyxtk4 
		}

Paste: http://pastebin.com/rWtyxtk4

        # Observe que código contido do paste está 100% explicativo de forma que o leitor possa entender 
        o que está sendo feito, linha à linha.

Salve o arquivo como Perl_File_Explorer.js no diretório D:\artigo\www\static\javascript\

"Dando vida" ao Javascript

Agora com a interface gráfica construída, precisamos criar os arquivos Perl que serão responsáveis por receber as requisições de nossa interface e realizar as tarefas necessárias no servidor

1 - Alimentando o treeview com diretórios

Vamos criar o arquivo que fornece a estrutura de diretórios em XML para interface renderizar o menu em árvore

Abra seu editor de texto preferido e cole o seguinte código:

		#!/usr/bin/env perl
		use strict;
		use CGI;
		use Path::Class;

		use utf8;
		no utf8;
		my $q = new CGI;		

		my $strXML;

		$strXML = $strXML."";
		$strXML = $strXML."";
		$strXML = $strXML."";

		my $pdir  = dir('../gerenciadordedocumentos');

		chdir $pdir;

		opendir(DIR, $pdir) or die "N?o foi poss?vel abrir o diret?rio $!";

		while (my $file = readdir DIR)
		{
			my $ediretorio = -d $file;
				if($ediretorio eq 1)
				{
					if($file ne "." && $file ne "..")
					{
						$strXML = $strXML.'		';
					}
				}
		}
		closedir DIR;
		$strXML = $strXML.'		';
		$strXML = $strXML.'	';

		print $q->header('text/xml');

		print $strXML;

Salve o arquivo como tree_files.pl no diretório D:\artigo\www\cgi-bin

2 - Alimentando o diretório da aplicação com arquivos

Vamos criar o arquivo que fornece a estrutura de arquivos em XML para interface renderizar a visualização dos arquivos contido no diretório selecionado

Abra seu editor de texto preferido e cole o seguinte código:

		#!/usr/bin/env perl
		use strict;
		use CGI;
		use File::Path qw{mkpath}; # make_path
		use File::stat;
		use Date::Day;
		use Date::Language;
		use POSIX qw(strtod);
		use Path::Class;

		my $q = new CGI;		
		my $strXML;
		my $diretorio=$q->param("diretorio");
		my $imagemtipo;
		my $pegadir  = dir('../gerenciadordedocumentos');       # Path::Class::Dir object
		my $file;

		$strXML = $strXML. '';
		$strXML = $strXML. '';

		if($diretorio eq "raiz")
		{
			my @files = ;
			foreach my $file (@files)
			{
				$file = file($file); # Path::Class::File object
				my $ediretorio = -d $file;
				my @vettipo=split(/\./, $file);
				my $tipofile=@vettipo[3];
				#my @vetnome=split(/\\/, $file); #windows
				my @vetnome=split(/\//, $file); #linux
		
				my $nomefile=@vetnome[2];
				if($ediretorio ne 1)
				{
					my $filesize = stat($file)->size;
					$filesize = $filesize/1024;
					$filesize=sprintf("0.00",strtod($filesize));
					my $st = stat($file) or die "erro ao ler tamanho $file: $!"; 
					my $mtime = $st->mtime; # modification time in seconds since epoch 
					my $localtimept = Date::Language->new('Brazilian');
					my $ultimamodificacao=$localtimept->time2str("%A 0 0  %Y %T\n",$mtime);
					$strXML = $strXML. "$filesize$ultimamodificacao";
				}
			}
			closedir DIR;
		}
		else
		{
			my $subdir  = $pegadir->subdir($diretorio);

			my @files = ;
			foreach my $file (@files)
			{
				$file = file($file); # Path::Class::File object
				my $ediretorio = -d $file;
				my @vettipo=split(/\./, $file);
				my $tipofile=@vettipo[3];
				#my @vetnome=split(/\\/, $file); #windows
				my @vetnome=split(/\//, $file); #linux
		
				my $nomefile=@vetnome[3];
		
				if($ediretorio ne 1)
				{
					my $filesize = stat($file)->size;
					$filesize = $filesize/1024;
					$filesize=sprintf("0.00",strtod($filesize));
					my $st = stat($file) or die "erro ao ler tamanho"; 
					my $mtime = $st->mtime; # modification time in seconds since epoch 
					my $localtimept = Date::Language->new('Brazilian');
					my $ultimamodificacao=$localtimept->time2str(" 0 0  %Y %T\n",$mtime);
					$strXML = $strXML. "$filesize$ultimamodificacao";
				}
			}
			closedir DIR;
		}
		$strXML = $strXML. '';
		
		print $q->header('text/xml');

		print $strXML;

Salve o arquivo como folder_files.pl no diretório D:\artigo\www\cgi-bin

3 - Criando diretórios

Vamos criar o arquivo que cria diretórios baseados nos parâmetros passados pela interface RIA

Abra seu editor de texto preferido e cole o seguinte código:

		#!/usr/bin/env perl
		use strict;
		use CGI;
		use File::Path qw{mkpath}; # make_path
		use JSON;
		use Path::Class;
		use HTML::Entities;

		my $q = new CGI;

		my $dirtarget=$q->param("dirtarget");
		my $nomenovo=$q->param("nomenovo");

		my $path = "../gerenciadordedocumentos/$nomenovo";


		my $direxiste = -d $path || mkpath($path) || dir "erro ao criar o dir"; 
	
		my %resposta = (
			status  => "sucesso",
			resposta =>  decode_entities("Novo diret?rio $nomenovo criado com sucesso"),
		);

		my $json = \%resposta;
		my $json_text = to_json($json);
		print $q->header('application/json');
		print $json_text;

Salve o arquivo como makedir.pl no diretório D:\artigo\www\cgi-bin

Observações

Como o foco do artigo era mostrar o deploy de aplicativos RIA com Plack, idependentemente de servidor web, partes de nossa aplicação, como a geração do XMLs que alimentam nossa interface, foram feitas da forma mais simples possível.

Porém, quem for seguir esse artigo, ou até mesmo utilizar a aplicação construída, aconselho fazer alguns melhoramentos, como exemplo, usar um módulo Perl específico para manipulação e geração de arquivos XML.

Outros recursos interessante de serem implementado seriam a recursividade entre diretórios listados por nossa aplicação e uploado de arquivos. Inclusive, já há na aplica ção, alguma coisa implementadas visando a futura implementação do uploado de arquivos utilizando o DHTMLX Vault

A aplicação desse artigo é meramente para fins educacionais.

A fim de fazer o leitor se envolver com assunto, o recurso de exclusão de arquivos foi implementado em partes, faltando fazer o arquivo em perl que receba os comandos para exclusão e que devolva a reposta à aplicação no formato JSON

Conclusão

Desenvolver aplicativos web utilizando o Plack, além de dar ao desenvolvedor uma liberdade real, permite que o mesmo mantenha o foco na aplicação em si, e não no ambiente onde ela será executada.

A aplicação desse artigo foi testada nos seguinte ambientes com sucesso:

* Windows 2008 Active Perl Plack

* Windows 2008 Cygwin Perl Plack

* Windows 2008 Strawberry Plack

* Windows 2008 Active Perl IIS7

* Ubuntu 11 Perl Plack

* Ubuntu 11 Perl Apache

Demo da aplicação

Após alguns dias envolvidos com projetos importantes e sem poder postar no blog, resolvi escrever um post bacana que retratasse bem o poder do Perl usado dentro do ambiente ASP.

Eu pensei em diversos temas, como Crawlers ou algo que demontrasse o poder absurdo do Perl para manipulação de texto, mas acabei escolhendo uma temática bem exótica se levada em consideração a cultura ASP tradicional, o tema escolhido foi: Port Scan.

Por que exótico? Basta se responder: quantos port scan rodando em arquivos ASP você ja viu?

Vamos ao que interessa

Bom, antes de entrar na parte técnica, há alguns pontos que os "marujos" de plantão deveriam saber:

1. ASP não é linguagem, é originalmente uma especificação de uma "API" do IIS. Assim como toda especificação, ela pode ser portada para outras plataformas e sistemas operacionais.
    
2. ASP no IIS pode ser codificado em diversas linguagens diferentes: VBScript, JScript, Perl, Python, PHP, etc.
   
   
3. ASP, além de ser nativo no IIS, foi portado para diversas plataformas: ASPL, ASP4 (Apache::ASP) e o Sun Java Systems Active Server Pages (ChiliASP).
   
   
4. Perl é uma linguagem muito poderosa e madura apesar de não ser muito conhecida de desenvolvedores que "consomem tecnologias hype". É utilizada em grande escala em aplicativos de diversos tipos, que vão desde softwares de roteadores, softwares baseados em GUI até à web.
    
5. Perl já foi portado para mais de 100 plataformas diferentes. Isso quer dizer que "funciona" em diversos sistemas operacionais, sejam eles windows, linux ou unix.
   
   
6. Há várias formas de se programar em Perl para web, porém escolhi ASP para aplicativo deste post por ser uma forma mais fácil de se ensinar Perl aos desenvolvedores desse ambiente. 

Criando o port scan

Todo port scan é baseado no uso de sockets. Atravé do sockets é que podemos nos "conectar" a outro computador na "porta X" e testarmos se ela está aberta ou fechada.

Um port scan para ser produtivo, precisa ter algumas features básicas como entrada de intervalos de porta a serem testadas bem como o uso de arquivos contendo host e portas a serem testadas. E assim foi feito.

Vamos ao código:

Arquivo: port_scan.aspl

< % @ LANGUAGE = " PerlScript " CODEPAGE = "65001 " % >
< %
use strict;
use warnings 'all';
use Win32::ASP;
use IO::Socket;
use base 'ASP4::FormHandler';
use vars __ PACKAGE __ - >VARS;

$Response->{Buffer} = 1;
$Server->{ScriptTimeout} = 99999999999999;
$Response->{CodePage} = 65001;
$Response->{charset}="utf-8";

my $versao = "v1.0";
my $host; 
my $porta;	
my $porta1; 
my $porta2; 
my $socket;	 
my $abre;	 
my @portas_abertas;	 
my @portas; 
my @comandos;	
my $count; 
my $auto;
my $s;
my $p;
my $all;
my $f;
my $c;
my $r;
my $l;
my $localdohost = $Request->QueryString("localdohost")->Item();
my $modo = $Request->QueryString("modo")->Item();
my $portadeinicio = $Request->QueryString("portadeinicio")->Item();
my $portafinal = $Request->QueryString("portafinal")->Item();

#==>>> inicia programa

start(); 

@comandos[0] = $localdohost;
@comandos[1] = $modo;
@comandos[2] = $portadeinicio;
@comandos[3] = $portafinal;

if((@comandos[0] eq "") || (@comandos[1] eq ""))
{
	print "Parâmetros incompletos
";
	forma_de_uso();
}

$host = @comandos[0]; 

seta_variaveis();

#==>>> inicia programa

sub start
{
	$host = ""; 
	$porta1 = 0;
	$porta2 = 0;
	$porta = 0;	
	$socket;	
	$abre = "";	
	@portas_abertas = "";
	@portas = "";
	@comandos = "";
	$count = 0;
	$auto = "";	
	$s = 0;	 
	$p = 0;	 
	$all = 0;	
	$f = "";
	$c = 0;	
	$r = 0;	
	$l = "";
}


sub forma_de_uso
{
	print "
-==============================-==============================-=-
";
	print " ASPL Portscan $versao
";
	print "Forma de uso:

";
	print "
port_scan.aspl?localdohost=HOST&modo=-s&portadeinicio=NUMEROPORTAINICIAL&portafinal=NUMEROPORTAFINAL

";
	print "
port_scan.aspl?localdohost=HOST&modo=-p&portadeinicio=NUMEROPORTA

";
	print "-==============================-==============================-=-

";
	exit;
}

sub seta_variaveis
{
	if(@comandos[0] eq "-a")
	{
		if($auto ne "")
		{
			print "Impossível automatizar o scan automatizado!
";
			forma_de_uso();
		}
	
		if(@comandos[1] eq "") 
		{
			print "Faltando parâmetro!
";
			forma_de_uso();
		}
	
		$auto = @comandos[1]; 
		automatizado();
	}

	if($auto ne "")
	{
		$count = 2; 
	}
	else
	{
		$count = 1; 
	}

	while((@comandos[$count] ne "") && (@comandos[$count] ne "#")) 
	{
		if (@comandos[$count] eq "-p") 
		{
			if(($s eq 1) || ($p eq 1) || ($all eq 1) || ($l ne "")) 
			{
				print "Comando incompatível ou duplicado!
";
				forma_de_uso();
			}

			$count  ; 
			if((@comandos[$count] eq "") || (@comandos[$count] < 1) || (@comandos[$count] > 65535)) 
			{	 
				print "Especificação de porta inválida!
";
				forma_de_uso();
			}
			$porta1 = @comandos[$count]; 
			$porta2 = @comandos[$count];

			$count  ; 
			$p = 1; 
		}

		if(@comandos[$count] eq "-s") 
		{
			if(($s eq 1) || ($p eq 1) || ($all eq 1) || ($l ne "")) 
			{
				print "Comando incompatível ou duplicado!
";
				forma_de_uso();
			}
	
			$count  ; 
			$porta1 = @comandos[$count]; 
			$count  ; 
			$porta2 = @comandos[$count];
	
			if(($porta1 < 1) || ($porta2 > 65535) || ($porta2 < $porta1)) 
			{
				print "Especificação de porta inválida!
";
				forma_de_uso();
			}
	
			$count  ; 
			$s = 1;
		}
	
		if(@comandos[$count] eq "-all") 
		{
			if(($s eq 1) || ($p eq 1) || ($all eq 1) || ($l ne "")) 
			{
				print "Comando incompatível ou duplicado!
";
				forma_de_uso();
			}
			
			$porta1 = 1;
			$porta2 = 65535;
			
			$count  ;
			$all = 1;
		}
	
		if(@comandos[$count] eq "-c") 
		{
			if($c eq 1) 
			{
				print "Comando incompatível ou duplicado!
";
				forma_de_uso();
			}
			
			$count  ;
			$c = 1;
		}
	
		if(@comandos[$count] eq "-f") 
		{
			if($f ne "") 
			{
				print "Comando incompatível ou duplicado!
";
				forma_de_uso();
			}
			$count  ;
			if(@comandos[$count] eq "")
			{
				print "Você não especificou o nome do arquivo!
";
				forma_de_uso();
			}
			$f = @comandos[$count];
			$count  ;
		}
		if((@comandos[$count] ne "-f") && (@comandos[$count] ne "-s") && (@comandos[$count] ne "-p") && (@comandos[$count] ne "-c") && (@comandos[$count] ne "-f") && (@comandos[$count] ne "-r") && (@comandos[$count] ne "-l") && (@comandos[$count] ne "") && (@comandos[$count] ne "#"))
		{
			print "Escolha de comando inválida!: @comandos[$count]
";
			forma_de_uso();
		}
	}
	chomp($host);
	chomp($porta1);
	chomp($porta2);
	chomp($f);
	chomp($l);
	scanneia();
}

sub automatizado
{
	if((@comandos[2] ne "#") && (@comandos[2] ne ""))
	{
		print "Comando incompatível ou duplicado!
";
		forma_de_uso();
	}

	open(a_arquivo, ")
	{
		$f = "";
		$f = ; 
		#chomp($f); 
		@comandos=split(/ /, $f);
		
		$f = ""; 
		
		if(@comandos[0] ne "#")
		{
			start();
			$host = @comandos[1];
			seta_variaveis();
		}

		for($count = 0; scalar(@comandos) >= $count; $count  )
		{
			pop @comandos;
		}

	}

	close(a_arquivo);
}


sub scanneia
{

	if($f ne "")
	{
		open(arquivo, ">$f") || die "Impossível abrir o arquivo! $!
"; #Linux
		close(arquivo);
	}

	$porta = $porta1;
	
	print "
Scanneando $host...

";
	$Response->Flush;
	
	if($f ne "")
	{
		print "salvando para o arquivo: $f
";
		$Response->Flush;
	}

	print "==============================
";
	print " ASPL Portscan $versao
";
	print " Written by Eduardow
";
	print "==============================

";
	print "Port\t\tStatus
";
	print "==============================
";
	$Response->Flush;

	for($porta = $porta1; $porta Flush;
		}

		$abre = eval	
		{
			$socket = new IO::Socket::INET	
			(
				PeerAddr => $host,
				PeerPort => $porta,
				Proto => getprotobyname('tcp') || 6
			)
		};

		chomp($porta);
		if ($abre) 
		{
			if($c eq 1){print $porta;}
			
			print "\t\tAberta ";
			push @portas_abertas, $porta;
			$Response->Flush;
		}
		else
		{
			if($c eq 0)
			{
				print "\t\tFechada
";
				$Response->Flush;
			}
		}
		if(defined($socket))
		{
			close($socket);	
		}
	}
	print "==============================

";
	print "Resultado Final:
";
	$Response->Flush;
	
	my $abre_p = sort {$a$b;} @portas_abertas;
	
	if(($s eq 1) || ($all eq 1))
	{
		print scalar(@portas_abertas)-1;
		print " portas abertas entre as portas $porta1 e $porta2 no host $host

";
		
		#if(scalar(@open) >= 1) 
		#{
			print "Porta\t\tStaus
";
			print "=-=-=\t\t=-=-=
";
			$Response->Flush;
			foreach $porta (@portas_abertas) 
			{
				if($porta>0)
				{
					print "$porta\t\tAberta
";
					$Response->Flush;
				}
			}
		#}
	}

	if($p eq 1) 
	{
		if(@portas_abertas[0] ne "")
		{
			print "Porta $porta1 está ABERTA no host $host
";
			$Response->Flush;
		}
		else
		{
			print "Port $porta1 está FECHADA no host $host
";
			$Response->Flush;
		}
	}

	if($f ne "")
	{
		salva_arquivo();
	}
	print "
";
}

sub salva_arquivo
{
	open(arquivo, ">$f") || die "Impossível abrir o arquivo! $!
"; 
	
	print arquivo "==============================\n";
	print arquivo " ASPL Portscan $versao\n";
	print arquivo " Written by Eduardow\n";
	print arquivo "==============================\n\n";
	print arquivo "Host: $host\n";

	
	if(($s eq 1) || ($all eq 1))
	{
		print arquivo "Portas scanneadas: $porta1 à $porta2\n\n";
		print arquivo "Resultado final:\n\n";
		print arquivo scalar(@portas_abertas); 
		print arquivo " portas abertas entre as portas $porta1 e $porta2 no host $host

"; 
		
		print arquivo "Porta\t\tStatus\n";
		print arquivo "=-=-=\t\t=-=-=\n";

		foreach $porta (@portas_abertas) 
		{
			print arquivo "$porta\t\tAberta\n";
		}
	}

	if($p eq 1) 
	{
		print arquivo "Porta scanneada: $porta1\n\n";
		print arquivo "Resultado final:\n\n";
		if(@portas_abertas[0] ne "") 
		{
			print arquivo "Port $porta1 está FECHADA no host $host
";
		}
		else
		{
			print arquivo "Porta $porta1 está ABERTA no host $host
";
		}
	}
}
%>

A mágica

Com apenas uma linha (abaixo divida em 4 para maior compreensão) em Perl, podemos testar a disponibilidade de uma porta.

            $socket = new IO::Socket::INET  
            (
                PeerAddr => $host,
                PeerPort => $porta,
                Proto => getprotobyname('tcp') || 6
            )

Testando o Port Scan

Quem quiser testar o port scan feito em ASP e Perl, basta acessar :  www.web2solutions.com.br/port_scan.aspl

Sinopse

port_scan.aspl?localdohost=HOST&modo=-s&portadeinicio=NUMEROPORTAINICIAL&portafinal=NUMEROPORTAFINAL

port_scan.aspl?localdohost=HOST&modo=-p&portadeinicio=NUMEROPORTA

A Cleids Imobiliária ja era cliente da web2, e após mudar seu targeting, encomendou um novo site.

O site atual deles é o www.cleidsimobiliaria.com.br.

Acompanhe agora, como está indo a criação do layout para o novo site.

Página Inicial

 Página interna de listagens em geral

 Página de comparação de imóveis

 Página de exibição do imóvel

Após a fase do photoshop, exportamos as imagens e começamos a montagem.

Acompanhe na integra como anda montagem do site em http://novo.cleidsimobiliaria.com.br/

Ei pessoal, estamos iniciando o processo de desenvolvimento de um novo site para um novo cliente e estamos formatando um novo layout; vamos ao longo do desenvolvimento demonstrando o passo a passo do processo.

Vamos considerar que a logo foi desenvolvida por terceiros a pedido do cliente, apenas estamos trabalhando em cima de uma identidade visual que já existe.

Observem a identidade do cliente, há duas aplicações possíveis:

Primeiro fizemos um esboço grosseiro para ter uma ideia de diagramação:

Depois, partimos para o Photoshop e começamos a layoutar a home do site. Por enquanto, está assim:

Seguindo o pedido do cliente, foram criadas algumas opções de "prova" como fundo levemente texturizado e a área ativa do site em branco, fundo levemente texturizado com o topo do site em branco, fundo levemente texturizado com a parte superior da área ativa do site em branco e fundo e topo 100% branco.

Acompanhe a montagem do site em: http://www.houseimobiliariadf.com.br/

Acompanhe nos prints abaixo:

Assim como qualquer software que tenha interface gráfica, nos sites, a maior parte de dados têm como entrada os formulários.

O grande problema, é que na internet, esses formulários estão na maioria das vezes expostos à qualquer um que tenha acesso a rede.

Problemas estes, que não existiriam se todos os desenvolvedores se preocupassem em tratar essas entradas de dados.

Um formulário pode ser explorado por uma pessoa mal intencionada das seguintes formas:

• File Injection
  Ocorre em campos para upload de arquivos para o site. Muito utilizado em upload de fotos, arquivos de currículos, etc. Uma pessoa mal intencionada poderá fazer upload de xploits do mais diversos tipos e que exploram diversas falhas em servidores, desde falha em permissões até a execução de códigos maliciosos.
  
  Ataques realizado através destes xploits são muito difíceis de detectar pois são originados na porta 80, e o armazenamento desse xploit poderá ser feito em qualquer diretório do site que esteja acessível pela porta 80.
  
  Exemplo de xploit bem utilizado em campos de upload: Rhtools
  
  Como evitar?
  
  1 - Validação do tipo de arquivo no lado do cliente.
  
  2 - Validação do tipo de arquivo no lado do servidor.
  
  3 - Aceitar somente extensões de arquivos confiáveis.
  
  4 - Aceitar somente arquivos com extensões esperadas, ou seja, num campo de currículo, aceitar somente arquivos .doc ou .pdf, num campo de foto aceitar somente .png, .jpg, .gif ou .tiff
  
  
• SQL Injection
  Ocorre em qualquer campo com entrada de dados no formato texto e que tenha ligação com o banco de dados. Uma pessoa mal intencionada poderá passar comandos SQL através de um scape usando ' (áspas simples) e logo após sua instrução maliciosa como "DELETE * FROM contas WHERE 1=1".
  
  Como evitar?
  
  1 - Validação/remoção de caracteres "especiais" do lado cliente
  
  2 - Validação/remoção de caracteres "especiais" do lado servidor 
  
  
• Data Flood
  Ocorre em formulários do tipo "cadastro" com inserção das informações diretamente no banco de dados. Uma pessoa mal intencionada, poderá realizar milhares e até milhões de novos cadastros, e com isso causar diversos transtornos no banco e no software em si, já que o software depende do bom funcionamento do banco consecutivamente.
  
  Em hostings comerciais, onde os ambientes e recursos são compartilhados, é sabido que, mesmo usando SGDBs de grande porte como PostgreSQL, Oracle e SQL Server, tabelas contendo em média ou acima de 10 mil registros, começam a responder de forma muito lenta querys simples como "SELECT id FROM produtos WHERE 1=1;". Alguns servidores começam a "responder de forma lenta" com menos registros, como 5 mil por exemplo. Leve em consideração, que muitos SGDBs, mesmo após você ter excluído o registro, o mesmo "permanece na memória" a fim de futura recuperação deste registro. A exemplo disto, podemos citar o "VACUUM" do PostgreSQl que tem com uma de suas funções, "apagar essa memória recuperável".
  
  Como evitar?
  
  1 - Usar Captcha.
  
  2 - A imagens usadas em Captcha deverão ter fundo com illustrações a fim de evitar a leitura da mesma via OCR.
  
  3 - O código sequencial da Captcha nunca poderá ser repetido, pois mesmo sem OCR, existe possibilidade de recuperar a imagem da Captcha e retorná-la dentro do xploit usado no ataque.

É com imenso prazer, que anunciamos para vocês, nossos clientes que caminharam conosco até aqui, que o novo Painel do Cliente já está em uma fase adiantada em seu desenvolvimento.

No Painel do Cliente, será possível gerenciar seus domínios, gerenciar e-mails e senhas, acompanhar o histórico financeiro, bem como emitir segunda vias de boletos, criar tickets de suporte, acompanhar seu projetos em andamentos, participar do FAQ, ter acesso às documentações de todos os softwares, dentre outros.

Nesta segunda-feira (27-06-11) foi liberado a Central de Tickets de Suporte. O acesso ao mesmo já está disponível para os clientes.

Quando o Painel do Cliente estiver 100% pronto, enviaremos para os clientes as novas informações para acesso ao mesmo. Por enquanto, os clientes que precisarem de criar tickets, basta solicitar o recadastramento via e-mail ou no telefone (27) 3021-1530.

Pros curiosos, segue 2 prints para uma pequena prévia.

Antes de qualquer coisa, é preciso saber que toda “estrutura computacional” possui “limites”. Limites estes do mais diversos tipos, como “limite de processamento”, “limite de conexões simultâneas”, “limite de armazenagem”, e por ai vai.

Um site, pra poder “ser acessível” pelas pessoas, precisa “estar hospedado” em uma “estrutura computacional” que tenha ligação direta com a internet.

Esta estrutura onde ele está hospedado se caracteriza pelo conjunto de “aparatos” necessários “para que o conteúdo do site” possa ser servido para a internet. Dentre estes aparatos, estão equipamentos como computadores de alta disponibilidade, switchs e roteadores por exemplo. Vale ressaltar que cada equipamento desses, possui seus próprios ”limites”.

Para que um site seja “servido” na internet sem nenhum problema, dois destes limites não poderão jamais ser “extrapolados”, e são eles:

1. Limite de Tráfego ou Banda – quando se excede a banda disponível para o site, o mesmo pode ficar inacessível.
2. Limite de Conexões simultâneas – sabe-se que todo banco de dados têm limites de acessos simultâneos, e em servidores comerciais esse número de conexões simultâneas geralmente não podem passar de 100 conexões.

Em ambas as situações o site poderá sair do ar.

O ataque DoS, ou Denial of Service, tem como propósito explorar estes “limites” e consecutivamente tirar o site do ar através de um grande número de conexões e operações simultâneas no site alvo.

Alguns ataques DoS não são necessariamente para tirar o site do ar, mas poderão criar muitos transtornos prejudicando serviços de e-mails, lentidão nas redes, dentre outros.

Como são feitos os ataques DoS?

Os ataques DOS podem ser feitos de diversas formas e podem ter diversos “tipos de alvos”. Mas um conceito que é comum á todos, é de que o “atacante” obtém controle de computadores diversos, e através deles realiza um grande número de requisições ao servidor alvo ao mesmo tempo.

Vale dizer que apesar dos ataques terem essa característica em comum, os “limites”que eles exploram nem sempre são os mesmos.

Alguns ataques propõem causar problemas no DNS (serviço de resolução de domínios), outros já exploram os limites do banco de dados ao realizar diversos cadastros ao mesmo tempo em um formulário no site, outros visam onerar os servidores de e-mail disparando milhões de mensagens falsas ao mesmo tempo. Enfim, as possibilidades são muitas.

Através de LOGs e varreduras é possível identificar as origens dos ataques e bloqueá-los consecutivamente.

Apesar de ser um tipo de ataque bem antigo, é obvio que sempre irão existir. Por isso é necessário tomar muitos cuidados tanto com as estruturas computacionais, tanto com a estrutura dos sites e aplicativos web em si.

Lembre-se, segurança nunca é demais.

Essa é pro pessoal descontrair um pouco. Não levem pro lado pessoal, ahahahaha