sábado, 25 de dezembro de 2010

Imprimindo vários documentos em um só PDF

A praticidade de um documento em PDF é inquestionável, uma vez que não precisamos utilizar na máquina um editor de texto como o Microsoft Word, por exemplo, e ainda, nos dá uma maior segurança, pois arquivos de texto podem ser facilmente alterados e o seu conteúdo mudar drasticamente de significado, já em documentos PDF, onde só é possível a leitura (claro que existem técnicas de transformar um PDF em um DOC da vida, e depois convertê-lo em PDF novamente, mas isso não é tão simples...). Isso sem contar os transtornos que temos em abrir o documento em um editor diferente e ver que as configurações de margens e fontes, por exemplo, estão alteradas, que dor de cabeça! Um documento PDF preserva suas características, podendo ser aberto em vários sistemas operacionais (Windows, Linux...) e enviado para a impressora (se necessário) sem mais estresse.

Agora imagine a seguinte situação, você está com dois documentos que na verdade deveria ser um apenas, como acontece com os TCCs, em função de contagem de páginas, as vezes se torna necessário criar mais de um arquivo, como podemos ver nas imagens que seguem, onde temos duas partes distintas de um mesmo TCC, onde uma corresponde as páginas iniciais e o outro arquivo, o restante do trabalho.



Ok! Teoricamente seria fácil imprimir os documentos, pois poderíamos enviar ambos para a fila de impressão e depois juntar tudo. Mas e se pelos fatos que citei anteriormente alguém pedir uma cópia em PDF? E mais, imprimindo em PDF fica melhor de ver como ficará o documento depois de impresso, já que assim não será modificado na hora de jogar o documento para a impressora.

Bom, vamos botar a mão na massa e mesclar os dois documentos num só para imprimir num arquivo com a extenção pdf. Primeiramente, vamos ao primeiro arquivo que queremos imprimir, que no caso é o "Capa ao Sumário... .doc". Claro, esqueci de mencionar que estou trabalhando com o Microsoft Office Word 2007 , então com a utilização de outra versão ou mesmo outro editor, o processo é parecido, mas os menus provavelmente fica em outro lugar... Vamos ao menu e escolhemos a opção Imprimir, como podemos ver a seguir:


Clicando em imprimir, irá aparecer uma lista com as impressoras instaladas, no meu caso o que interessa é o PDFCreator, que será selecionado. Bom, obviamente que há a necessidade de instalar o PDF Creator antes, mas isso é um processo simples e o software é freeware.


Agora que vem um detalhe, ao invés de clicar em Salvar, clique em "Aguardar - Armazenar", isso para que os documentos fiquem na fila de impressão do PDF Creator, sendo possível mesclá-los posteriormente.



Bom, tendo feito esta parte, vamos ao segundo arquivo e repetimos os mesmos processos, como podemos ver nas imagens abaixo:





Já com os dois documentos na fila, vamos mesclar ou unir os mesmos. Para tanto, deve-se selecionar os dois documentos que estão na fila e depois vamos ao menu "Documento"  - "Unir" (ou utilizando as teclas de atalho Ctrl + C).


Então, irá iniciar o processo de mesclagem dos arquivos, o que é relativamente rápido, então veremos uma tela como segue, com apenas um arquivo ao invés dos dois originais.


O próximo passo é mandar imprimir o documento, e para tanto, façamos o seguinte, vá no menu  (do PDF Creator) "Documento" - "Imprimir".


Então informamos os dados necessários como o nome do documento entre outros, e após clicamos em "Salvar".




Escolha um local adequado para salvar o arquivo (como podemos ver na imagem anterior) e salve seu arquivo em PDF.  O processo é bem rápido, claro, dependendo do tamanho do arquivo e outros fatores que podem afetar esse fator.

Após isso, podemos ver que foi criado um novo arquivo na pasta indicada, que compreende o conteúdo dos outros dois anteriores.


Agora abrimos o arquivo em PDF para verificar se está tudo OK!


Pelo visto ocorreu tudo bem e temos o nosso arquivo em PDF pronto! 

Como vimos no decorrer desta postagem, é bem simples trabalhar com o PDF Creator, mesmo quando se trata de unir vários documentos num só arquivo, tanto que nem precisava explicar com tantos detalhes e colocar tantas imagens, mas em caso de dúvida, fica mais fácil de compreender, principalmente para os iniciantes. Espero ter contribuído em algo... Mas qualquer dúvida, estamos aí... hehe!!!

Abraços!!!

terça-feira, 2 de novembro de 2010

Utilizando o Aircrack-ng

Olá pessoal! 

Hoje vou falar rapidamente sobre um aplicativo, cujo nome é aircrack-ng (testado no SO Linux Ubuntu 10.04) bem interessante para detectar informações de redes wireless que estão ao alcance. O software é capaz de recuperar chaves WEP uma vez que um número suficiente de pacotes criptografados sejam capturados com o airodump-ng. Esta parte do pacote Aircrack-ng determina a chave WEP usando dois métodos fundamentais, o PTW e o FMS/KoreK, que não serão explicados neste post. O software ainda é capaz de quebrar chaves WPA, utilizando o método de dicionário, que também não será comentado nesta postagem. Só para lembrar, este software pode tanto ser utilizado para ver como está a segurança de uma rede wireless bem como no caso da quebra da chave, ser utlizado para um acesso não autorizado em determinada rede. Portanto, cabe a pessoa que irá utilizar tal software, saber como vai utilizar as informações coletadas, se para proteger mais ainda sua rede ou tentar invadir a rede alheia, estando sujeito as penalidades por isso.

Todo o procedimento foi realizado na minha própria rede wireless e com meu notebook, para um trabalho da pós-graduação, disciplina Segurança de Sistemas.

Vamos iniciar instalando o pacote de software (caso não tenha instalado ainda, obviamente). Primeiramente entre com a senha de administrador (root) do sistema, e dê o comando: apt-get install aircrack-ng
Feito isso aguarde enquanto o pacote é baixado e instalado em seu computador, o que geralmente é rápido, já que o pacote é relativamente pequeno.

Vamos aos procedimentos e comandos utilizados, para mais informações sobre s comandos, verifique o manual do software ou outros locais da web, apenas se atenha a sequência.

  • Primeiramente foi dado o comando airmon-ng stop wlan0;
  • Após o comando anterior, foi dado o seguinte comando: ifconfig wlan0 down;
  • Posteriormente, foi alterado o MAC da placa de rede wireless, com o comando macchanger --mac 00:11:22:33:44:55 wlan0;
  • A seguir foi reativada a placa de rede, utilizando o comando airmon-ng start wlan0
Depois desse passo, foi utilizado o airodump-ng, que é utilizado para capturar dados transmitidos através do protocolo 802.11 e em particular para a capturar e coletar IV's (vetores iniciais) dos pacotes WEP com a intensão de usar o aircrack-ng para recuperar a chave WEP.

Com o comando airodump-ng wlan0 foi verificado os APs cujo sinal foi captado por minha placa wireless, como pode ser visto a seguir:


Com isso conseguimos descobrir 5 redes wireless ao alcance de minha placa de rede. Podemos ver na coluna BSSID que é o endereço MAC do AP, que em conjunto com a coluna CH (canal) serão utilizados nos passos posteriores. Também podemos obter outros dados interessantes, como a intensidade de sinal, a taxa de transmissão, o tipo de criptografia utilizado (claro, se utilizado!) e o ESSID, que é o nome da rede.

Com posse do BSSID e do canal, pode-se começar os testes no AP escolhido, que no caso foi o que cujo ESSID é PLS_WIRELESS. Para começar a captura de IVs foi utilizado o comando airodump-ng -c 1 -w paulo --bssid 00:26:5A:D5:CE:95 wlan0, onde -c indica que será passado um parâmetro de canal (1), o -w indica ele irá gravar as informações coletadas num arquivo, cujo nome é paulo, já o --bssid é o endereço MAC do AP selecionado, e wlan0 é obviamente a interface de rede wireless que está sendo utilizada no teste.


Agora aqui entra um detalhe importante, há a necessidade de que haja tráfego na rede wireless para que o teste possa ser feito, uma vez que o software analisa alguns dados transmitidos, e a velocidade de quebra da senha é diretamente proporcional a quantidade de dados trafegando na rede wireless, ou seja, quanto mais dados, mais rápido é o processo, já que há mais IV's (na coluna #Data) para serem capturados. Então obviamente para acelerar o processo, tratei de gerar tráfego da rede com outro equipamento que estava na rede wireless. Outro detalhe é que quanto melhor o sinal, mais pacotes são capturados!

Com o processo de captura de IV's em andamento, foi aberto outro terminal onde foi informado o comando aircrack-ng -b 00:26:5A:D5:CE:95 paulo- 01.cap , onde é informado o BSSID de onde foram coletadas as informações e em que arquivo essas informações estão, onde antes era somente paulo, aqui temos que chamar por paulo-01.cap.

Como era de se esperar a senha não foi quebrada logo de início, e o aircrack-ng, de tempos em tempos (de acordo com o número de IVs capturados) fazia nova tentativa, como é mostrado a seguir, onde foi feita a primeira tentativa com em torno de 5000 IVs capturados e como não foi descoberto a senha, a próxima tentativa ocorreu com 10000 IVs e assim por diante até chegar num resultado final.



Nas duas imagens anteriores podemos ver os dois terminais em cada imagem, na parte superior de cada imagem está o terminal do airodump-ng e na parte inferior o aircrack-ng. Na última imagem pode-se ver que a operação foi realizada com sucesso e que a chave WEP foi quebrada, tendo como resultado de saída, o conteúdo abaixo:


Bom, mas a chave está um pouco estranha, certo? Aí tem um detalhe, a chave é hexadecimal, como foi comentado no início do relatório. Se for-mos analisar o que está na figura que aparecem as configurações do roteador (em outra postagem), pode-se ver que a chave é 20b3cde687fe8f289ba23ee871, então o que falta para que a chave coincida é retirar os “:” que separam os caracteres, que estão assim: 20:B3:CD:E6:87:FE:8F:28:9B:A2:3E:E8:71. Tirando todos os “:” ficamos com 20B3CDE687FE8F289BA23EE871 que é igual a 20b3cde687fe8f289ba23ee871.

Finalizando, o aircrack-ng é um software muito interessante para verificar algumas caracterícticas de redes wireless, sobretudo no que se trata a segurança da rede (isso contando com o que vimos acima, o que é só uma parte do que o software nos oferece). Com isso concluimos que é necessário um bom planejamento quanto a segurança de nossa rede, para que outras pessoas não autorizadas acessem a rede sem que saibamos.

Um abraço a todos!!!



quarta-feira, 13 de outubro de 2010

Árvore Binária

Olá! Esta postagem é um pouco diferente das demais, pois é voltada principalmente ao pessoal que está estudando algoritmos e estruturas de dados, que a princípio não é muito complicado, pois é só usar a lógica. Porém, nem tudo é assim tão simples, principalmente quando trabalhamos com ponteiros de memória em estruturas de dados. A coisa fica um pouco mais difícil quando chegamos a parte de árvores binárias e grafos.
 
Quanto a definição de árvores de busca binária, para quem está vendo isso em estruturas de dados, deve ser tranquilo, e para quem nunca ouviu na vida algo relacionado a isso, há inúmeros textos na internet, então não vou entrar em detalhes nesse sentido e sim vou dar um exemplo de alguns procedimentos (em Pascal)  de um trabalho feito para a disciplina Estruturas de Dados II, onde deveríamos criar uma árvore binária onde pudéssemos inserir elementos, excluir elementos, contar os nós da árvore, dentre outras coisas, como mostra a figura a seguir, que é a tela principal do programa (não notem o visual da tela do programa, pois o objetivo era fazer um programa que funcionasse, e não fazer milagres com o Pascal e costruir "telinhas bonitinhas"... ). Aliás, não é a tela inteira do programa, pois com o ".exe" sendo executado, acabou-se perdendo parte da tela... mas enfim, o menu está na imagem.


Como podemos ver, esse programa deve ser capaz de fazer uma quantidade significativa de coisas na árvore que será criada, o que sem dúvidas fez com que o programa tivesse um número considerável de linhas, então para esta postagem não ficar muito grande, optei por não inserir as linhas correspondentes ao programa principal, mas sim, as variáveis e procedimentos utilizados para que o programa funcionasse.

Uma coisa que deve ser lembrado, é esta árvore trabalha com elementos  numéricos do tipo integer, mas tranquilamente poderíamos alterar alguns detalhes para que ela funcionasse com letras (char).

No site da UFSC, no endereço http://www.inf.ufsc.br/~ine5384-hp/Estruturas.ArvBusca.html, podemos ver um exemplo bem interessante que trata do assunto.


Bom, mas vamos ao código! Veja abaixo, analise e verá que não é assim coisa de outro mundo. É um pouco complicado mas se não fosse, não seria interssante, pois não haveria um desafio... hehe!!!
 

{NOVEMBRO DE 2006
 TRABALHO DE ESTRUTURAS DE DADOS II
 ARVORE BINARIA

 Autor: Paulo Luis Steinhauser
}
program arvore_binaria;
uses crt;

type inform = integer;

     ptnodo = ^elemento;
     elemento = record
        dado : inform;
        dir : ptnodo;
        esq : ptnodo;
     end;

     arvore = record
        raiz : ptnodo;
     end;

     vetor = array[1..50] of integer;

var opt, first,pos_x,pos_y,pos_x2,pos_y2: integer;
    dado: inform;
    arv, arv_aux: ptnodo;
    conta, compara, alta, max, father: integer;
    a: vetor;
    tipos: byte;

{++++++++++++++++++++++++++++++++++++++++++++++++++++++++++}

procedure cria_arvore(var raiz: ptnodo);

begin            {cria a arvore vazia}
  raiz:= nil;
end;

{****************************************************}


procedure incluir(var tree: ptnodo; item: inform);
var no: ptnodo;

begin
   if tree = nil then
   begin                 { se a arvore estiver vazia}
      new (no);          { a informaçao vai para a raiz}
      no^.esq:= nil;
      no^.dir:= nil;
      no^.dado:= item;
      tree:= no;
   end
   else
   if item = tree^.dado then   {verifica se elento ja existe}
   begin
      textcolor(red + blink);
      writeln('Elemento ja cadastrado');
      readkey;
   end
   else
   if item < tree^.dado then
   begin                               {se ainda nao existir o elemento}
      incluir(tree^.esq,item);  {verifica-se se vai ser incluido na}
   end                                 {esquerda ou na direita}
   else
      incluir(tree^.dir,item);
end;

{***********************************************************}

function vazia(tree: ptnodo): boolean;

begin
   vazia:= false;
   if tree = nil then   {verifica se a arvore esta vazia}
      vazia:= true      {procedimentos posteriores utilizam esta function}
   else
      vazia:= false;
end;


{************************************************************}

function achou(tree: ptnodo; item: inform): boolean;

begin
   achou:= false;
   if tree = nil then             {funcao que procura o elemnto}
   begin                            {na arvore para ver se ele existe}
     achou:= false;             {ou nao, retornando um valor...}
   end
   else
   if item = tree^.dado then
   begin
      achou:= true;
   end
   else
   if item < tree^.dado then
      begin
      achou:= achou(tree^.esq,item);
   end
   else
   begin
      achou:= achou(tree^.dir,item);
   end;
end;

{*********************************************************}

procedure deleta (aux:ptnodo; var tree:ptnodo);
begin
   if tree^.dir <> nil
   then
   begin
      deleta(aux,tree^.dir);
   end
   else
   begin
      aux^.dado:= tree^.dado;
      aux:= tree;
      tree:= tree^.esq;
      dispose(aux);
   end;
end;

{********************************************************}

procedure excluir (var tree: ptnodo; item: inform);
var aux : ptnodo;

begin
  if (item < tree^.dado) then
  begin
     excluir(tree^.esq,item); {verifica a sub da esquerda}
  end
  else
  if (item > tree^.dado) then
  begin
     excluir(tree^.dir,item); {verifica a sub da direira}
  end
  else
  if tree^.dir = nil then
  begin
     aux := tree;
     tree := tree^.esq;
     dispose(aux);
  end
  else
  if tree^.esq = nil then
  begin
     aux := tree;
     tree := tree^.dir;
     dispose(aux);
  end
  else
  begin
     deleta(tree, tree^.esq);
  end;
end;

{*********************************************************}

procedure caminha_pre(tree: ptnodo);

begin
   if tree <> nil then           {procedimento para camhinhar prefixado}
   begin
      write(tree^.dado,' ');
      caminha_pre(tree^.esq);
      caminha_pre(tree^.dir);
   end;
end;

{**********************************************************}

procedure caminha_in(tree: ptnodo);
{procedimento para camhinhar infixado}
begin
   if tree <> nil then           
   begin
      caminha_in(tree^.esq);
      write(tree^.dado,' ');
      caminha_in(tree^.dir);
   end;
end;

{***********************************************************}

procedure caminha_pos(tree: ptnodo);
{procedimento para camhinhar posfixado}
begin
   if tree <> nil then         
   begin
      caminha_pos(tree^.esq);
      caminha_pos(tree^.dir);
      write(tree^.dado,' ');
   end;
end;

{***********************************************************}

procedure mostra_folha(tree: ptnodo; var cont: integer);
{procedimento que verifica se folha, mostra as mesmas e caminha na arvore}
begin
   if (tree^.esq = nil) and (tree^.dir = nil) then
   begin
      write(tree^.dado,' ');
      cont:= cont + 1;
   end                
   else              
   if tree^.esq <> nil then    
   begin
      mostra_folha(tree^.esq,cont);
   end;

   if tree^.dir <> nil then
   begin
      mostra_folha(tree^.dir,cont);
   end;
end;

{***********************************************************}

function conta_nos(tree: ptnodo; var cont: integer):integer;

begin
   if tree <> nil then
   begin
      cont:= cont + 1;
      conta_nos:=conta_nos(tree^.esq,cont);
      conta_nos:=conta_nos(tree^.dir,cont);
      conta_nos:= cont;
   end;
end;

{************************************************************}

procedure altura(tree: ptnodo;var alt: integer; aux: integer);

begin
   if (tree^.esq = nil) and (tree^.dir = nil) then
   begin
      if aux > alt then
      begin
         alt := aux;
      end;
      aux:= 0;
   end
   else
   begin
      aux:= aux + 1;
      if tree^.esq <> nil then
      begin
         altura(tree^.esq,alt,aux);
      end;

      if tree^.dir <> nil then
      begin
         altura(tree^.dir,alt,aux);
      end;
   end;
end;

{************************************************************}

procedure nivel_elemento(tree: ptnodo; item: inform; var nivel: integer);

begin
   if item = tree^.dado then
   begin
      textcolor(yellow);
      writeln;
      writeln;
      writeln('*   O elemento ',dado,' esta no nivel ',nivel);
   end
   else
   begin
      nivel:= nivel + 1;
      if item < tree^.dado then
      begin
         nivel_elemento(tree^.esq,item,nivel);
      end
      else
      begin
         nivel_elemento(tree^.dir,item,nivel);
      end;
   end;
end;

{************************************************************}

procedure completa(tree: ptnodo; qtd: integer; alt: integer);
var expo: real;
    x: real;

begin
   alta:= 0;
   compara:= 0;
   expo:= 0;

   altura(arv,alta,compara);  
   alt:= alta;
   qtd:= conta_nos(arv, conta);

   expo:= Round(Exp((alt+1) * Ln(2)) - 1);             


   if  (expo = qtd) then
   begin
      textcolor(green);
      writeln('Arvore Completa !!!');
   end
   else
   begin
      textcolor(red);
      writeln('Arvore Incompleta!!!');
   end;
end;

{************************************************************}

procedure tipo_elem(inf:inform;var vet: vetor; var i:integer;tipo: integer; var pai: integer);
{procedimento que inclui elementos no vetorna respectiva posiçao que ‚ indicada pelo parâmetro tipo}
begin
   if tipo = 0 then      
      vet[1]:= inf;                                
   if tipo = 1 then
   begin
      vet[2*i]:= inf;
      pai:= 2*i;
   end;

   if tipo = 2 then
   begin
      vet[2*i+1]:= inf;
      pai:= 2*i+1;
   end;
end;

{*************************************************************}

procedure tree_vetor(tree:ptnodo;i: integer; var vet: vetor; tipo: integer;  pai: integer; var maior: integer);

begin
   if tree <> nil then
   begin
      tipo_elem(tree^.dado,vet,i,tipo,pai);
      i:= pai;
      tree_vetor(tree^.esq,i,vet,1,pai,maior);
      if i > pai then
         maior:= i;
      tree_vetor(tree^.dir,i,vet,2,pai,maior);
   end;
end;

{**************************************************************}

procedure cria_vetor(var vet: vetor; var tam: integer);
{procedimento que cria o vetor e insere um valor default nos seus elementos}
var alta, compara, alt, i: integer;

begin
   alta:= 0;                             
   compara:= 0;                 
   altura(arv,alta,compara);
   alt:= alta;

   tam:= Round(Exp((alt+1) * Ln(2)) - 1);

   for i:= 1 to tam do
   begin
      vet[i]:= 1000;
   end;
end;

{**************************************************************}

procedure escreve_vetor(vet: vetor; tam: integer);
var i: integer;

begin
   for i:= 1 to tam do                  
   begin                                     
      if vet[i] <> 1000 then   
      begin
         write(vet[i],' ');
      end
      else
      begin
         write('_');
      end;
   end;
end;

{*************************************************************}

procedure desenha(tree:ptnodo; x, y, primeiro:integer);

begin
  if tree^.dado > primeiro then
  begin
     textcolor(6);
  end
  else
  begin
     textcolor(10);
  end;

  if (tree^.esq = nil) and (tree^.dir = nil) then
  begin
     if tree^.dado > primeiro then
     begin
        textcolor(12);
     end
     else
     begin
        textcolor(2);
     end;
  end;
  gotoxy(x,y);
  write(tree^.dado);
end;

{************************************************************}

procedure grafica(tree, aux:ptnodo; alt, primeiro, x, y, x2, y2: integer);

begin
   if tree <> nil then
   begin
      if tree^.esq <> nil then
      begin
         aux:= tree^.esq;
         x:= x - (4 * alt-1);
         y:= y + 2;
         desenha(aux,x,y,first);
      end;
      if tree^.dir <> nil then
      begin
         aux:= tree^.dir;
         x2:= x2 + (4 * alt-1);
         y2:= y2 + 2;
         desenha(aux,x2,y2,first);
      end;
      alt:= alt - 1;
      grafica(tree^.esq,aux,alt,primeiro,x,y,x,y);
      grafica(tree^.dir,aux,alt,primeiro,x2,y2,x2,y2);
   end;
end;


{*****************************************************************}

procedure le_item(var inf: inform);

begin
   textcolor(green);
   gotoxy(5,20);
   write('Informe o n£mero ==>');
   gotoxy(27,20);
   read(inf);
end;

{***********************************************************}

begin

AQUI VAI O PROGRAMA PRINCIPAL!!! 

end.

terça-feira, 28 de setembro de 2010

Como burlar alguns protetores de links

Saudações!

Hoje vou apresentar de maneira resumida como burlar alguns tipos de protetores de links (aqueles que mostram uma tela para cadastrar um número de celular para prosseguir o download). Esses protetores aparecem as vezes quando tentamos fazer o download de algum arquivo em algum site como o MegaUpload, Filserve entre outros. Vou abaixo aprensetar 4 exemplos muito simples.

No primeiro exemplo vou mostrar o caso em que o protetor de link gera uma URL enorme, como pode-se ver na imagem que segue:




Se você percorrer a URL até o final, irá perceber que o link que você necessita para fazer o download está ali, na parte final da URL, depois de "url=".



Então fica óbvio que se você apagar o conteúdo da URL que não nos interessa, que é o que vem antes do último "http://", fica só o link correto, como no caso, o link para um arquivo contido no MEGAUPLOAD.


Veja na figura acima que a URL é exatamente a parte que eu havia destacado na imagem anterior, pois o resto eu apaguei, simples, certo? Ainda teria como ver o link correto se você mandasse o navegador exibir o código fonte, mas para esse tipo de protetor é mais fácil apagar parte da URL do que vasculhar o fonte.

Ok! Vamos para o segundo exemplo, que na verdade é idêntico o primeiro, só que a URL parece estranha, pois ao invés de indicar o MEGAUPLOAD, por exemplo, indica um tal de yess.me.


Então é só apagar a parte que destaquei na imagem que segue:



Agora é só mandar carregar que teremos a tela de download.


Bom, até aqui está tudo muito fácil, então vamos ver dois exemplos um pouquinho mais complexos para descontrair.

O terceiro exemplo é bem interessante, pois não temos como simplesmente apagar parte da URL, e de cara fica meio complicado saber para que página ele deveria direcionar.




Um tanto quanto complicado, certo? Nem tanto, se você reparar, na imagem anterior, o título da página é bem "interessante", começando por "?d=". No caso eu já sabia que esse parâmetro seria utilizado no site do MEGAUPLOAD, mas para confirmar, uma olhadinha no fonte da página tirou qualquer dúvidas que eu tinha.


Aí eu poderia optar por duas opções, entrar no site do MEGAUPLOAD e indicar o endereço que corresponde ao arquivo que pretendia fazer o download (no caso,  "?d=DTH575Q7") ou pegar o link completo lá no fonte mesmo, que seria "http://www.megaupload.com/?d=DTH575Q7").


Agora vamos para o último exemplo, que aparenta ser um pouquinho mais complicado, mas no final das contas também não é coisa de outro planeta. Neste exemplo temos a sequência de caracteres da URL que nos encaminhará para a download totalmente invertida. Só para lembrar, essa URL vem depois de "?url="


Então primeiramente apagamos a parte da URL que não nos interessa, que é a destacada na imagem abaixo:


Ok! Agora sobrou a parte da URL que está invertida, como pode-se ver abaixo:


Agora é só informar a URL correta invertendo a posição dos caracteres e então podemos fazer o download tranquilamente (claro, se não foi cometido nenhum erro na inversão das letras e se o endereço ainda é válido). Para facilitar, tente fazer isso em agum site como: http://www.string-functions.com/reverse.aspx ou para quem gosta de programar, pode criar um programinha simples em Delphi, PHP, Java ou mesmo no Pascal...


Bom, como podemos ver, apesar de inconvenientes, esses protetores de links podem ser burlados facilmente, pelo menos os que apresentei aqui nesta postagem. Caso encontre algum protetor diferente, que não seja assim óbvio como esses, tente verificar o códico fonte para ver onde eles direcionam.

16/04/2011 => Bom pessoal, como sempre há inovações em tudo, inclusive no que diz respeito a protetores de links, vou dar o exemplo de mais dois tipos que encontrei a pouco tempo, um usando hexadecimal e outro utilizando o esquema de reverso do link, mas com alguma complicações, como poderemos ver, mas nada assustador.

Vamos ao caso do hexadecimal, que aparentemente é mais complexo, mas que é bem simples de burlar (ao menos por enquanto... hehe). Primeiramente vejamos a imagem que segue, notem que na url, não temos como saber para que link está apontando, seja normalmente ou inversamente.



O detalhe é que dá para notar na url, que após o "?id=" inicia-se uma série de números e letras, que são caracteres hexadecimais, mas ainda não é o bastante. Então entramos no fonte para procurar-mos o link completo (em hexa!).



Encontrado o link, não é só copiar no navegador. Temos que primeiramente transformar esses caracteres hexadecimais para caracteres da tabela ASCII (com números e letras da forma que estamos acostumados, ou seja, da forma texto...). Para tando, selecione o link e cole em algum aplicativo que faça a conversão, como no caso, foi utilizado um sisteminha bem bolado disponível no site: http://home2.paulschou.net/tools/xlate/


Cole os caracteres na caixa de texto intitulada [HEX], e clique no botão logo abaixo, que tem como label DECODE


Note que irão aparecer vários resultados, mas o que nos interessa encontra-se na caixa "[TEXT]", onde já podemos ver claramente o link.


Então copie e cole o resultado do navegador, se o link estiver disponível e o processo foi bem sucedido, irá conseguir efetuar o download normalmente.



Bom, vamos ao segundo exemplo do dia, que é bem mais simples mas pode confundir um pouco, pelo excesso de infomação na url.


Basicamente o que nos interessa encontra-se no centro desse amontoado de letras, e ainda, está invertido, por isso pode ser difícil de visualizar num primeiro momento, mas olhando mais atentamente, podemos ver e selecionar o que nos interessa.


Em posse dessa informação, basta ir em algum site que possa inverter esses caracteres (caso não queiramos inverter manualmente ou não tenhamos algum software que faça isso em nosso computador).


Agora é só copiar e colar no seu navegador... se estiver tudo ok, o download ocorrerá tranquilamente.

Bom pessoal, por hoje é isso, caso encontrem algum protetor diferente e quiser compartilhar...


Abraços...!!!

sábado, 25 de setembro de 2010

Registrando o antivírus AVAST 5

Olá a todos!

Bom, hoje vou falar rapidamente sobre como fazer o registro do AVAST 5, que é um pouquinho diferente das versões anteriores, onde tínhamos que inserir um código gerado pela empresa desenvolvedora do software e que era enviado para um e-mail indicado, após preencher-mos um formulário. A parte do formulário ainda existe, em virtude de coleta de dados sobre usuários, mas não existe mais a necessidade de informar aquele código, que era uma sequência de caracteres relativamente grande.

Após fazer o download do AVAST 5 e instalar o mesmo em seu equipamento, você poderá verificar que ele não está registrado e que sua licença é de apenas 30 dias,  como pode ser visto nas imagens que seguem:


Vá na aba "Manutenção" e clique em "Registro". Nessa tela podemos ver que realmente o AVAST ainda não está registrado e que o registro atual irá expirar em breve. Para fazer o registro, clique no botão "Registrar agora".


Irá surgir uma nova tela para dar início ao registro de seu software. Nessa tela temos duas opções, a primeira é registrar gratuitamente e a segunda é "Atualizar para o avast! Internet Security", na qual você tem que pagar uma licença pelos recursos extras. No caso de quiser continuar com a versão free, clique no botão "Registrar" contido nesta tela, como podemos ver:


Após clicar no botão da janela anterior, aparecerá outra janela onde você deverá informar seus dados.


Notem que é um formulário bem básico, necessitando apenas informar questões nada complicadas. Só uma coisa me chamou atenção, em "Título" aparecem 3 opções, que seriam "Sr.", "Sra" e "Menina", meio estranho, mas fazer o que... hehe!!!


Ok, depois de preencher todo o formulário, ele deve ficar mais ou menos parecido com o que está na próxima figura, claro que com seus dados...


Depois de tudo preenchido, clique no botão "Registrar para uma licença grátis", e aperecerá uma janela como segue:


Clique no botão "OK" para fechar essa janelinha. Agora note que o estado atual foi alterado para "REGISTRADO" e que a data de expiração é de um ano após a data do registro.


Pronto! Seu antivírus está registrado e pronto para rodar em sua máquina por mais um ano. Mas claro, não se esqueça de que as atualizações devem ser feitas (geralmente são feitas automaticamente) e que nenhum software antivírus é 100% garantido, uma vez que surgem diariamente um número bem maior de vírus do que vacinas para os mesmos, e ainda há outros fatores que podem interferir... Você deve fazer uma varredura completa em todos os discos de tempos em tempos, e aí você tem algumas opções bem interessantes, como fazer um "Escaneamento completo do sistema" ou mesmo agendar um escaneamento ao reiniciar. 


Obviamente que há muitos softwares antivírus grátis e bons por aí, tais como o AVG, Avira entre outros, mas esta postagem foi feita exclusivamente para o Avast em virtude da necessidade de registro do software para utilização por um longo período.

Por enquanto seria isto... Abraços a todos e até a próxima!!!