Arquivo de fevereiro, 2014

Condição – Case e Switch – Java, C++, C# e Abap

Publicado: 14 de fevereiro de 2014 em Abap, C#, C/C++, Java
0

A instrução CASE como o IF também é um comando clássico e existe em muitas linguagens de programação, seja ela compilada ou interpretada. O comando Case predominou por muitos anos e nos tempos atuais ganhou uma nova cara e um novo nome apesar de permanecer com a mesma estrutura, o SWITCH. Comando CASE ainda é usado nos dias atuais por varias linguagens de programação e linguagens de scripts entre elas o ABAP, PL/SQL, TRANSACT-SQL e outras.

A instrução CASE e SWITCH é como uma série de instruções IF, apenas usando a palavra-chave WHEN (Quando) ou CASE (Caso). A instrução é avaliada a partir de cima para baixo. Se a condição for verdadeira, então correspondente a cláusula é executado e execução salta para o fim do caso (avaliação curto-circuito).

Ou seja ao contrário de if-then e declarações if-then-else, a instrução switch pode ter um número de possíveis caminhos de execução. Um switch funciona com o byte, short, char, e tipos primitivos de dados int. Ele também funciona com tipos enumerados, a classe String, e algumas classes especiais que envolvem certos tipos primitivos: Character, Byte, Short, e Integer.

Exemplo:

Neste simples exemplo podemos ver como mostrar na tela o dia da semana usando um numero de 1 a 7.

Java

public class Caso {

public static void main(String[] args)
 {
      int dia = 5;
     switch (dia)
   {
       case 1:
      System.out.println("Segunda");
    break;
          case 2:
       System.out.println("Terça");
    break;
           case 3:
       System.out.println("Quarta");
    break;
           case 4:
       System.out.println("Quinta");
    break;
          case 5:
       System.out.println("Sexta");
    break;
          case 6:
       System.out.println("Sabado");
    break;

    default:
       System.out.println("Domingo");
    break;
  }

}

}

C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication55
 {
     class Program
     {
         static void Main(string[] args)
         {
              int dia = 5;
     switch (dia)
   {
       case 1:
      Console.WriteLine("Segunda");
    break;
          case 2:
       Console.WriteLine("Terça");
    break;
           case 3:
       Console.WriteLine("Quarta");
    break;
           case 4:
       Console.WriteLine("Quinta");
    break;
          case 5:
       Console.WriteLine("Sexta");
    break;
          case 6:
       Console.WriteLine("Sabado");
    break;

   default:
   Console.WriteLine("Domingo");
   break;
  }

   Console.ReadKey();
         }
     }
 }

C++

#include "stdafx.h"
#include <iostream>
#include <cstdlib>
using namespace std;

int _tmain(int argc, _TCHAR* argv[])
 {
  int dia = 5;

switch (dia)
  {
  case 1:
   cout << "Segunda" << endl;
   break;

case 2:
   cout << "Terça" << endl;
   break;

case 3:
   cout << "Quarta" << endl;
   break;

case 4:
   cout << "Quinta" << endl;
   break;

case 5:
   cout << "Sexta" << endl;
   break;

case 6:
   cout << "Sabado" << endl;
   break;

default:
   cout << "Domingo" << endl;
   break;
  }
  system("pause");
  return 0;
 }

ABAP

*&---------------------------------------------------------------------*
*& Report  ZCASO
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Caso
*&---------------------------------------------------------------------*
REPORT  ZCASO.

DATA dia TYPE i.

dia = 5.

CASE dia.

WHEN 1.
               WRITE : / 'Segunda'.

WHEN  2.
               WRITE : / 'Terça'.

WHEN  3.
               WRITE : / 'Quarta'.

WHEN  4.
               WRITE : / 'Quinta'.

WHEN  5.
               WRITE : / 'Sexta'.

WHEN  6.
               WRITE : / 'Sabado'.

WHEN OTHERS.
               WRITE : / 'Domingo'.
ENDCASE.

Condição IF, ELSE, ELSEIF – Abap

Publicado: 14 de fevereiro de 2014 em Abap
1

IF é um dos comandos mais comuns e um dos mais importantes na programação, este comando é responsável pelas tomadas de decisões, existe praticamente em todas as linguagens de programação, antigamente este comando era conhecido como “se-então-senão” ou “if-then-else” mas as linguagens mais modernas substituirão o “então” pelo símbolo “{}” (colchetes), se a condição puder ser executada por apenas uma linha de comando então não é necessário usar o colchete.

Em ABAP a condição IF tem uma sintaxe um pouco diferente ficando assim:

IF(se) a condição for atendida faça algo, ELSEIF (senão, se) outra condição for atendida faça algo, ELSE (senão) faça algo, ENDIF (fim da condição).

Uma grande diferença do ABAP em relação as outras linguagens de programação é que mesmo nas instruções de condição se faz necessário dizer ao compilador que a linha foi terminada com o caractere .(ponto).

Sintaxe:

IF condição.
[bloco de comandos 1]
[ELSEIF condição.
[bloco de comandos 2]]
…
[ELSE.   [bloco de comando N]]
ENDIF.

Essas instruções definem uma estrutura de controle que pode conter vários blocos de instrução dos quais no máximo de um serão executados em conjunto com as expressões lógicas.

Outra diferença do ABAP são seus operadores, por não utilizar os símbolos padrões e sim instruções literais para avaliar as condições.

Operadores ABAP:

  • EQ  (=)  – É igual a.
  • NE (<>) – Não é igual a.
  • LT  (<) – É menor que.
  • GT  (>) – é maior do que.
  • LE (<=) – é menor do que ou igual a.
  • GE (>=) – é maior do que ou igual a.
  • AND – lógico e .
  • OR  – Lógico ou .
  • NOT – logico não.

Exemplo:

ABAP

*&---------------------------------------------------------------------*
*& Report  ZCONDICAO 
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Condições
*&---------------------------------------------------------------------*

REPORT  ZCONDICAO.

* Declarando Variáveis
DATA :    variavel1 TYPE i,
          variavel2 TYPE i,
          variavel3 TYPE i.

* Alimenta as Variáveis
variavel1 = 100.
variavel2 = 150.
variavel3 = 200.

* Verifica as Condições.

* Comando IF
IF variavel1 LT variavel2.
WRITE : / 'Condicao1:', variavel1, ' é menor que ', variavel2.
ENDIF.

* Comando IF e ELSE
 IF variavel1 GT variavel2.
   WRITE : / 'Condicao2:', variavel1, ' é menor que ', variavel2.
 ELSE.
   WRITE : / 'Condicao2:', variavel2, ' é maior que ', variavel1.
 ENDIF.

* Comando IF e ELSEIF
 IF variavel1 EQ variavel2.
   WRITE : / 'Condicao3:', variavel1, ' é menor que ', variavel2.
 ELSEIF variavel2 LT variavel3.
   WRITE : / 'Condicao3:', variavel2, ' é menor que ', variavel3.
 ENDIF.

Classes – Escopos – Java, C++ e C#

Publicado: 14 de fevereiro de 2014 em C#, C/C++, Java
0

Escopo refere-se à vida e acessibilidade de uma variável. Quão grande é o alcance depende de onde uma variável é declarada. Por exemplo, se uma variável é declarada na parte superior de uma classe, ela será acessível a todos os métodos de classe. Se for declarada num método, em seguida, só pode ser utilizada em tal método.

O escopo de uma variável é a parte do programa que pode acessar uma variável. Quando você tenta acessar uma variável que não está no escopo, você normalmente tém um erro do compilador. Aqui estão algumas das regras de escopo:

  1. Variáveis ​​de classe (campos estáticos) estão no escopo em todos os lugares na classe.
  2. Se uma variável de classe é declarada “pública”, está no escopo em todas as classes.
  3. As variáveis ​​de instância (campos não-estáticos) estão no escopo em métodos não estáticos chamados em um objeto apropriado.
  4. As variáveis ​​e parâmetros locais estão no escopo apenas dentro do método que os declarou.

Exemplo:

Neste exemplo veremos o alcance do escopo das variáveis estáticas, publicas e privadas em sua classe. Na classe principal vemos o resultado do escopo utilizado na classe planeta.

As variáveis privadas podem ser utilizadas somente dentro da classe planeta, a variável publica pode ser utilizada por todas as classes ou neste caso pelo objeto, a variável estática é utilizada globalmente e não precisa ser instanciada, todos os objeto que você criar, ou seja outros planetas irão compartilhar os dados desta variável, as variáveis locais criadas dentro do construtor só podem ser utilizadas dentro do método em que foi criada.

Criamos o objeto da classe planeta chamado Marte, experimente criar outros objetos com nome de planetas e imprima seus valores.

Java

Classe #1 – Principal

public class principal {

public static void main(String[] args)
  {
      Planetas marte = new Planetas(3.0, 1.5, 6.419e23);

      marte.apelido = "Marte";

      System.out.println("Quantidade de planetas: " + Planetas.numeroDePlanetas);
      System.out.println("Nome do Planeta: " + marte.apelido);
      System.out.println("As outras variaveis da classe não podem ser alcançadas devido ao escopo");
      System.out.println("mas podem ser utlizadas dentro da classe");
  }
 }

Classe #2 – Planetas

public class Planetas {

 // Variavel da classe é compartilhada por todos
 public static long numeroDePlanetas;

 // Variavel de intancias
 private double x, y;
 private double massa;
 public String apelido;

      // Construtor
      //  x e y são  variaveis instanciadas,
      //  mas newX and newY são variaveis locais
      //  O construtor incrementa o valor
    public  Planetas(double novoX, double novoY, double novaMassa)
    {
       x = novoX;
       y = novoY;

       massa = novaMassa;
       numeroDePlanetas++;
    }
}

C#

Classe #1 – Principal

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication53  {
      class Program
      {
          static void Main(string[] args)
          {
              Planetas marte = new Planetas(3.0, 1.5, 6.419e23);

              marte.apelido = "Marte";

              Console.WriteLine("Quantidade de planetas: " + Planetas.numeroDePlanetas);
              Console.WriteLine("Nome do Planeta: " + marte.apelido);
              Console.WriteLine("As outras variaveis da classe não podem ser alcançadas devido ao escopo");
              Console.WriteLine("mas podem ser utlizadas dentro da classe");

              Console.ReadKey();
          }
      }
  }

Classe #2 – Planetas

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApplication53 {

public class Planetas {

         // Variavel da classe é compartilhada por todos
          public static long numeroDePlanetas;

         // Variavel de intancias
          private double x, y;
          private double massa;
          public String apelido;

          // Construtor
          //  x e y são  variaveis instanciadas,
          //  mas newX and newY são variaveis locais
          //  O construtor incrementa o valor

          public Planetas(double novoX, double novoY, double novaMassa)
          {
              x = novoX;
              y = novoY;

              massa = novaMassa;
              numeroDePlanetas++;
          }
    }
}

C++

Classe #1 – Principal

#include "stdafx.h"
#include <iostream>
#include <string>
#include "planetas.h"

using namespace std;

int _tmain(int argc, _TCHAR* argv[])  {

   Planetas marte(3.0, 1.5, 6.419e23);

   marte.apelido = "Marte";

   cout << "Quantidade de planetas: " << marte.numeroDePlanetas << endl;
   cout << "Nome do Planeta: " << marte.apelido << endl;
   cout << "As outras variaveis da classe não podem ser alcançadas devido ao escopo" << endl;
   cout << "mas podem ser utlizadas dentro da classe" << endl;

   system("pause");

   return 0;
}

Classe #2 – Planetas

#include "stdafx.h"
#include <iostream>
#include <string>

using namespace std;

class Planetas {

private:
    // Variavel de intancias
     double x, y;
     double massa;

public:

     // Variavel de intancias
     string apelido;

     // Variavel da classe é compartilhada por todos
     static int numeroDePlanetas;

     // Construtor
     //  x e y são  variaveis instanciadas,
     //  mas newX and newY são variaveis locais
     //  O construtor incrementa o valor

  Planetas(double novoX, double novoY, double novaMassa)
  {
    x = novoX;
    y = novoY;

    massa = novaMassa;
    numeroDePlanetas++;
   }
};

  int Planetas::numeroDePlanetas;

PARAMETERS – ABAP

Publicado: 13 de fevereiro de 2014 em Abap
0

Você pode usar a declaração PARAMETERS para declarar variáveis ​​de uma forma semelhante a declaração variáveis ​​DATA. Para cada parâmetro declarado, um campo de entrada aparece na tela de seleção correspondente. No lado esquerdo do campo de entrada, o nome do parâmetro é apresentado como texto. Os valores inseridos no campo de entrada pelo usuário são atribuídos à variável correspondente, enquanto o sistema processa a tela de seleção.

Sintaxe:

PARAMETERS variável TYPE tipo LENGTH tamanho DEFAULT valor.

Exemplo:

ABAP

*&---------------------------------------------------------------------*
*& Report  ZPARAMETROS
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Parametros
*&---------------------------------------------------------------------*

REPORT  ZPARAMETROS.

PARAMETERS:  Nome   TYPE c LENGTH 50 DEFAULT 'Digite seu nome',
             Rua    TYPE c LENGTH 40 DEFAULT 'Digite sua Rua',
             Numero TYPE i,
             Bairro TYPE c LENGTH 30 DEFAULT 'Digite seu Bairro',
             CEP    TYPE c LENGTH 9 DEFAULT  'Cep',
             Cidade TYPE c LENGTH 40 DEFAULT 'Digite sua Cidade',
             Estado TYPE c LENGTH 2.

WRITE – Abap

Publicado: 13 de fevereiro de 2014 em Abap
0

A declaração ABAP básica para exibir dados na tela é WRITE.

Sintaxe:

WRITE <campo>.

Exemplo:

ABAP

*&---------------------------------------------------------------------*
*& Report  ZSAIDA
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Saida de Tela
*&---------------------------------------------------------------------*

REPORT  ZSAIDA.

WRITE  10 'Saida1'.
*Saida começa na coluna 10.

WRITE (3) 'Saida2'.
*Saida tem apenas 3 caracteres.

WRITE (*) 'Saida3'.
*Saida é escrita em um tamanho suficiente sem espaços.

WRITE  10(3) 'Saida4'.
*Combinação das tecnicas acima.

WRITE / 'Saida5'.
*Saida é escrita na proxima linha.

WRITE /10(3) 'Saida6'.
*Combinação das tecnicas acima.

CONSTANTS – Abap

Publicado: 13 de fevereiro de 2014 em Abap
0

Constantes são chamados objetos de dados que você cria estaticamente usando uma instrução declarativa. Eles permitem que você armazene dados sob um nome específico dentro da área de memória de um programa. O valor de uma constante deve ser definida ao declará-lo. Ele não pode ser alterado posteriormente. O valor de uma constante, não pode ser alterado durante a execução do programa. Se você tentar alterar o valor de uma constante, um erro de sintaxe ou erro de execução ocorre.

Existe um número de constantes mantidas pelo sistema Por exemplo, SY-MANDT irá exibir o número de cliente atual.

A sintaxe da instrução constantes é exatamente a mesma que a da declaração DATA, mas com as seguintes exceções:

  • Você deve usar a adição de valor na declaração de constantes. O valor inicial especificado na adição de valor não pode ser alterado durante a execução do programa.
  • Você não pode definir constantes para XSTRINGS, referências, tabelas internas, ou estruturas que contêm as tabelas internas.

Sintaxe:

 CONSTANTS nome TYPE tipo VALUE valor

Exemplos:

ABAP

*&---------------------------------------------------------------------*
*& Report  ZCONSTANTES
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Constantes
*&---------------------------------------------------------------------*
REPORT  ZCONSTANTES.

CONSTANTS chave_alpha_numerica TYPE string VALUE 'AKFDF43SD098EWE2739AA003'.

WRITE : / 'O valor da Chave Alpha Numerica é fixo e não pode ser alterado', CHAVE_ALPHA_NUMERICA.

Tipos de Variáveis – GLOBAL – Abap Dictionary (SE11) – Abap

Publicado: 13 de fevereiro de 2014 em Abap
0

 Tipos de Dados Globais

Para declarar dados globais você precisa acessar o dicionário ABAP através da transação se11. Para mais informações sobre os tipos built-in do Abap Dictionary clique aqui.

Declarando uma variável global

  1. Abra o ABAP Dictionary pela transação SE11.
  2. Clique na opção “Data type”.
  3. Para evitar a colisão de nomes para a classe, começe os nomes de tipo com Z
  4. Nome: zchavevalidade.
  5. Clique no botão Create e escolha a classe Data element.
  6. Em Short Description escreva: Chave de validade do programa.
  7. Clique em Predefined Type.
  8. Em Data Type escolha INT4 e Length de 30.
  9. Clique em Activate.
  10. Clique em Local Object,
  11. Abra a transação SE38  e digite o programa abaixo.

ABAP


*&---------------------------------------------------------------------*
*& Report  ZGLOBAL
*&
*&---------------------------------------------------------------------*
*&  Desenvolvimento Aberto
*&  Tipos de Variáveis Globais
*&---------------------------------------------------------------------*

REPORT  ZGLOBAL.

DATA chave TYPE ZCHAVEVALIDADE.

chave = 152626113.

WRITE : / 'Chave de validade do programa:', chave.

Criando Tipos de Variáveis – TYPES – Abap

Publicado: 13 de fevereiro de 2014 em Abap
0

TYPES:

Permite declarar tipos de dados locais que são mais específicos do que o tipo padrão.

Sintaxe:

TYPES  nome do tipo TYPE [tipo de variável]

Isso pode ser usado para criar um tipo padrão de variáveis  com um nome mais descritivo para a sua aplicação ou para definir mais especificamente a composição das variáveis.

TYPES – Não pode ter um valor default especificado pelo usuário.

TYPES –  São declarações  locais para  o programa. Declarações de tipos globais são possíveis através do uso do dicionário ABAP, permitindo uma gestão tipo em todo o sistema.

ABAP


*&---------------------------------------------------------------------*
*& Report  ZTIPOS2
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Declarando Tipos de Variáveis Locais.
*&---------------------------------------------------------------------*

REPORT  ZTIPOS2.

* Declara tipos de variáveis locais para o programa
TYPES :    valusuario  TYPE i,
           codusuario  TYPE n LENGTH 10,
           taxausuario TYPE p LENGTH 3 DECIMALS 2.

* Declara variáveis
 DATA : meuvalor  TYPE valusuario,
        meucodigo TYPE codusuario,
        minhataxa TYPE taxausuario.

* Alimenta Variáveis
meuvalor = 100.
meucodigo = 15262622.
minhataxa = '1.56'.

* Declara uma nova variável com base em outra ja existente
DATA novataxa LIKE minhataxa.

* Adiciona o valor da minha taxa na novataxa
ADD minhataxa TO novataxa.

* Modifica valor da variável
 novataxa novataxa = novataxa + '0.20'.

WRITE : / 'Taxa:', minhataxa, 'Nova Taxa:',novataxa.
WRITE : / 'Codigo:', meucodigo, 'Valor:', meuvalor.

SAP – Data Types – Tipos de variáveis – ABAP

Publicado: 12 de fevereiro de 2014 em Abap
0

ABAP –  Variáveis e Tipos de Dados

Os elementos de dados:

Objeto que descreve o tipo de dados e significado semântico de um campo da tabela.

Domínio:

Define intervalos de valores válidos para os campos. Campos semelhantes podem ser agrupados em um domínio. Mudar esse domínio muda todos os campos.

Tipo de dados:

Descrição do tipo de dados de uma variável pode ser titular e a faixa de valores aceitáveis ​​com base em armazenamento alocado.

Objeto de dados:

Variável real ou constante (de um tipo declarado) que foi definido.

Tipos de dados completos:

Tamanho fixo, armazenamento de dados de formato especificado.

Tipos de dados incompletos:

Tamanho de armazenamento pode variar, por isso deve ser definido após a declaração da variável.

Tipos de Dados Padrão ABAP

  • i –  integer 4 byte número inteiro + / – 2,1 bilhões
  • f –  floar 8 bytes, 15-16 dígitos significativos
  • c – string de até 65 mil caracteres
  • n – numeric string até 65 mil caracteres (número não-matemático)
  • string – de comprimento dinâmico até 2 GB de comprimento!
  • xstring –  hex string seqüêncial de byte comprimento de dinâmico
  • x –  byte seqüêncial de até 65k bytes
  • d –  Data 8 caracteres de formato AAAAMMDD
  • t –  tempo 6 caracteres de HHMMSS
  • p  – packed number preciso ou número flutuante de até 16 bytes

Comando :

DATA –   declarar suas próprias variáveis ​​ou atributos de instância de classes.

Sintaxe: DATA var [{TYPE type}|{LIKE dobj}] …

Arvore de tipos

Data Types - tree

Data Types – tree

Exemplo: Neste exemplo criamos um cadastro primitivo de um cliente fictício.

ABAP

*&---------------------------------------------------------------------*

*& Report  ZTIPOS

*&

*&---------------------------------------------------------------------*

*& Desenvolvimento Aberto

*& Variáveis ABAP

*&---------------------------------------------------------------------*

REPORT  ZTIPOS.

* DATA nome da variavel Type [tipo da variavel]

DATA nome   TYPE c LENGTH 50.

DATA rua    TYPE c LENGTH 50.

DATA bairro TYPE c LENGTH 30.

DATA cep    TYPE c LENGTH 9.

DATA cidade TYPE c LENGTH 50.

DATA estado TYPE c LENGTH 2 VALUE 'SP'. " Tipo de dados incompleto

DATA idade  TYPE i.                     " Tipos de dados completos

DATA irmaos TYPE i VALUE 7.             " Com Inicialização

* Variaveis podem ser decladas acorrentadas (chained)

DATA: codigo TYPE i,

numero TYPE i VALUE 15.

* LIKE é usado para declarar uma variavel baseado em outra declaração

* Apenas os tipos de dados são copiados

Data estado2 LIKE estado.

WRITE : / 'estado:', estado, 'estado2 tem o valor vazio:', estado2.

* Alimenta Variaveis

codigo = 14232.

nome = 'José Amaral da Silva'.

rua = 'Amazonas'.

bairro = 'Vila das Torres'.

cep = '50100-000'.

cidade = 'São Paulo'.

idade = 18.

" Imprimindo as variaveis

"

WRITE : / 'Código:', codigo.

WRITE : / 'Nome:', nome.

WRITE : / 'Rua:', rua, 'Numero:', numero.

WRITE : / 'Bairro:', bairro, 'Cep:', cep.

WRITE : / 'Cidade:', cidade, 'Estado:', estado.

WRITE : / 'Idade', idade, 'Irmãos:', irmaos.

Como Capturar Senhas do Internet Explorer – (Internet Explorer Password)

Publicado: 12 de fevereiro de 2014 em Hacking
0

Window 8.1 (Modo Fácil)

Com o fracasso obvio do Windows 8 (não de vendas) a Microsoft foi obrigada as pressas a resolver alguns desentendimentos que a versão gerou entre seus usuários e sua nova interface chamada Metro, com um visual minimalista inspirado na comunicação visual de estações de metrô, muito se falou a respeito desta nova interface e muitos também reprovaram suas novas funcionalidades deixando um grande abismo de compatibilidade entre a nova interface Metro e a clássica interface do Windows agora chamada de Desktop.

Então lá vai a Microsoft em sua maior especialidade, resolver bugs que custam o controle total de nossos computadores Windows em todas suas versões, desta vez é obrigada a dar um “tapa” naquilo que sempre fez de melhor, a interface visual.

Nasce o Windows 8.1 renovado já com o famoso e unanime botão iniciar de volta (talvez mais aclamado do que um pop star) e uma união mais harmoniosa entre a interface Metro e a Desktop pode ser a única diferença que a maioria dos usuários puderam notar.

Mas o que pouco se comentou foi outro tipo de harmonia que a Microsoft gerou entre hackers e desenvolvedores mal intencionados, o que antes exigia conhecer profundamente C e C++, APIs, arquivos headers(.h) e dlls do sistema, agora pode ser feito diretamente de linguagens de alto nível como  C#, Visual Basic e outras.

Windows RUNTIME API

O Windows RUNTIME API (Windows API para Windows 8.1 Store Apps) disponibiliza todo o núcleo do Windows, basta usar os namespaces Windows e você acessa uma gama de APIs de um modo simples e fácil.

O que realmente mudou é que agora um grande numero de desenvolvedores podem se aproveitar da fragilidade de como as senhas são guardadas pelo Windows Vault e seu antecessor o Credential Store,  deixando assim vulnerável todas as senhas  de usuários dentro do contexto do computador local. Pode se agora criar um virus ou um Malware pessoal sem precisar usar receitas de bolo ou hacker tools para descobrir senha de sites como Facebook, Gmail, Hotmail ou qualquer outra senha guardada pelo browser do usuário.

Requisitos (Para utilizar o código disponibilizado Open Source):

Sistema Operacional Windows 8.1

Microsoft Visual Studio Professional (versão Express não suportada)

Referencias e Downloads:

Windows STORE API RUNTIME Reference: http://msdn.microsoft.com/en-us/library/windows/apps/br211377.aspx

Exemplos Cross-Plataform: http://msdn.microsoft.com/en-us/library/gg597391(v=vs.110).aspx

 O que Acontece?

No contexto do usuário ou seja na maquina local em que o usuário efetuou o Login é possível recuperar as senhas guardadas pelo Internet Explorer, seja de um programa em um pen drive ou por um aplicativo de console e utilizar as urls e senhas do modo que bem entender, enviar pela internet, exportar para um arquivo texto, html, xml e etc.

Windows RUNTIME API fornece acesso ao namespace Windows.Security.Credentials que fornece todas as funcionalidades que precisamos para enumerar as credenciais do usuário.

Windows.Security.Credentials: http://msdn.microsoft.com/en-us/library/windows/apps/windows.security.credentials.aspx

 

DA – Windows Vault/Network Password Recovery – V 1.0 – Betha

Modo Nativo (Avançado)

Nós disponibilizamos a ferramenta escrita por nós utilizando o modo tradicional para acessar as APIs por meio da linguagem de programação Visual C++, você pode utilizar a ferramenta gratuitamente e em breve o código será disponibilizado em um projeto OpenSource:

É uma pequena ferramenta de recuperação de senha que permite visualizar os nomes de usuário e senhas armazenadas pelo navegador Internet Explorer, recuperando os endereços e senhas armazenados pelo Windows Credential Store e pelo Windows Vault. Para cada entrada de senha, a seguinte informação é exibida: URL, Nome de Usuário, Campo de senha. Você pode selecionar um ou mais itens e, em seguida, salvá-los em arquivo de texto.

Download: DA – Internet Explorer – Vault/Network Password Recovery

Project (Google Code): http://code.google.com/p/da-ie-vault-credential/source/browse/

DA - Windows Vault/Network Password Recovery - V 1.0 - Betha

DA – Windows Vault/Network Password Recovery – V 1.0 – Betha

 

 Windows Credential Store e  Windows Vault

Internet Explorer 7

O Windows fornece o Credencial Store que é uma estrutura para armazenar senhas de rede em um formato seguro e criptografado. Isso proporciona mecanismo conveniente e confiável de armazenar as senhas para logins de rede para que o usuário não tenha que digitar a senha toda vez que acessar os recursos da rede.

Não só o Windows usa para armazenar senhas de autenticação de rede, mas também outras aplicações como o Outlook, Windows Live, Remote Destktop, GMail Notifier e etc.

O Windows também permite que os aplicativos gerenciem perfeitamente o Credencial Store usando funções da API de gerenciamento de credenciais, as credenciais são armazenadas localmente no contexto do usuário no seguinte diretório:

Local:

  • C:\Users\User\AppData\Local\Microsoft\Credentials
  • C:\Users\User\AppData\Roaming\Microsoft\Credentials

Internet Explorer 10

O IE10 mudou a maneira de como  armazenar senhas. Agora, todas as senhas de preenchimento automático são armazenados no Gerenciador de Credenciais em um local chamado de “Credenciais da Web”. Parece algo como o seguinte:

credenciais

Windows Vault

Por incrível que pareça, o Windows Vault foi introduzido pela primeira vez ao público com o lançamento do Windows 7, mas ainda não há informações devido  sua descrição na rede. A documentação sobre este assunto,  interessantemente é completamente ausente, ou, para dizer o mínimo, é superficial. Então, o que é Vault?

Assim, o Windows Vault é um estrutura de armazenamento de dados privados que veio para substituir o Gerenciador de Credenciais. A Microsoft em mais uma tentativa de criar um armazenamento universal de segredos que o Windows parece ter tanta falta.

Existem dois tipos de localização Vault:

Usuário:

  • C:\Users\Usuario01\AppData\Local\Microsoft\Vault\4BF4C442-9B8A-41A0-B380-DD4A704DDB28

Sistema:

  • С:/Windows/System32/config/systemprofile/AppData/Roaming/Microsoft/Vault/…
  • С:/Windows/System32/config/systemprofile/AppData/Local/Microsoft/Vault/…
  • C:/ProgramData/Microsoft/Vault/AC658CB4-9126-49BD-B877-31EEDAB3F204

Exemplo Open Source: 

Vamos utilizar como base um código aberto liberado pela licença MIT (Instituto de Tecnologia de Massachusetts) que mostra como é simples capturar as senhas do Internet Explorer 10 de uma linguagem como C# o que antes era somente era possível com complexos códigos em C.

Este exemplo é disponibilizado de modo Open Source, é utilizado através do namespace Windows e o programa tem a saída no console:

Obs: O código abaixo funciona apenas para computadores com o sistema operacional Windows 8  e só pode ser compilado do sistema operacional Windows 8.1, caso queira experimentar nossa ferramenta gratuita que pode ser utilizada no Windows Vista ou superior utilize os links para download que podem ser encontrados logo acima.

Obs 2: Apesar do código abaixo utilizar a linguagem de programação C#, internamente não é classificado como uma compilação .Net Framework e sim Windows Core, incompatibilizando assim qualquer tentativa de referenciar assemblers de código gerenciados entre eles.

C#

/*The MIT License (MIT)
Copyright (c) 2012 Jordan Wright <jordan-wright.github.io>

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.*/

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Windows.Security.Credentials;

namespace PasswordVaultTest
{
class Program
{
static void Main(string[] args)
{
// Create a handle to the Widnows Password vault
Windows.Security.Credentials.PasswordVault vault = new PasswordVault();

// Retrieve all the credentials from the vault
IReadOnlyList<PasswordCredential> credentials = vault.RetrieveAll();

// The list returned is an IReadOnlyList, so there is no enumerator.
// No problem, we'll just see how many credentials there are and do it the
// old fashioned way

for (int i = 0; i < credentials.Count; i++)
{
// Obtain the credential
PasswordCredential cred = credentials.ElementAt(i);

// "Fill in the password" (I wish I knew more about what this was doing)
cred.RetrievePassword();

// Print the result
Console.WriteLine(cred.Resource + ':' + cred.UserName + ':' + cred.Password);
}
Console.ReadKey();
}
}
}

Exemplos Windows Store: http://code.msdn.microsoft.com/windowsapps/Windows-8-Modern-Style-App-Samples

Entradas mais Antigas
Entradas mais Recentes