Como criptografar ou descriptografar um texto com AES

As redes como a Internet não fornecem um meio de comunicação seguro entre as pessoas. Esta é suscetível de ser lida ou modificada por terceiros não autorizados. A criptografia ajuda a proteger os dados de exibição, fornece maneiras de detectar se os dados foram alterados e ajuda a fornecer um meio seguro de comunicação sobre os canais não seguros.

Por exemplo, os dados podem ser criptografados usando um algoritmo criptográfico, transmitido em um estado criptografado e posteriormente ser descriptografado pelo destinatário. Se outra pessoa intercepta os dados criptografados, será difícil entender o que foi transmitido. O Padrão de Criptografia Avançada (AES) é uma forma de criptografia adotada pelo governo dos Estados Unidos em 2001. O AES fornece uma criptografia mais segura do que seu predecessor (padrão NIST), o Padrão de Criptografia de Dados (DES) ou mesmo 3DES.

É este padrão que mostrarei neste post. Para que esta criptografia funcione, o padrão AES pressupõe que as duas partes (emissor e receptor da mensagem/arquivo/etc) concordaram em uma chave e IV, e comunicaram seus valores. O IV não é considerado confidencial e pode ser transmitido em texto não criptografado com a mensagem.

O procedimento para criptografar ou descriptografar consiste basicamente em 3 passos:
1) conseguir a classe que faz a criptografia via:

        Cipher c = Cipher.getInstance(ALGORITMO); // vamos precisar da mesma string para decriptar

2) inicializar a classe com a chave desejada, com o IV desejado e informar se irá criptografar (Cipher.ENCRYPT_MODE) ou descriptografar (Cipher.DECRYPT_MODE)

        c.init(Cipher.ENCRYPT_MODE, chaveAES, ivps);
        c.init(Cipher.DECRYPT_MODE, chaveAES, ivps);

3) executar o método

        byte [] msg = c.doFinal(textoComoArrayDeBytes);

Vamos ver a construção da nossa classe:

O vídeo com toda a construção do nosso exemplo é:

Configurando textos em uma aplicação JavaFX utilizando CSS

Neste post irei mostrar como carregar um arquivo de configuração CSS que será aplicado aos componentes de uma tela JavaFX.

Vamos utilizar o CSS para adicionar um gradiente no fundo da tela, alterar a cor de um texto, acrescentar uma sombra a outro texto. Obtendo no final a tela abaixo:

Vamos ao vídeo

Nossa classe final é:

O arquivo CSS utilizado neste exemplo foi:

Novidades com java.nio - Parte IV

Vamos ver uma nova aplicação que permite buscar diretórios a partir de um diretório raiz utilizando duas interfaces:

• PathMatcher: cria uma verificação baseada em um padrão que pode seguir o mesmo padrão que já utilizados nas linhas de comando do sistema operacional (como por exemplo *.java) ou podemos utilizar expressões regulares.
• DirectoryStream: retorna um conjunto de diretórios como uma stream que pode ser lida por um iterator.

PathMatcher é implementado em FileSystems.getDefault().getPathMatcher.
DirectoryStream é implementado em Files.newDirectoryStream.

No vídeo vemos como estas classes podem ser utilizadas:

Nossa classe pode ser implementada para ler como argumentos de passagem o diretório e o padrão. Esta nova classe é apresentada abaixo:

Novidades com java.nio - Parte III

Continuando nossas experiências com java.nio vamos ver como ler e gravar um arquivo texto. Vamos utilizar dois recursos BufferedReader e BufferedWriter para fazer isto. Note que as instâncias destas classes são obtidas diretamente de Files com:

• BufferedReader criada por Files.newBufferedReader
• BufferedWriter criada por Files.newBufferedWriter

Estes métodos recebem Path e Charset.

Vamos ver como isto se comporta no nosso vídeo

Nossa classe é

Novidades com java.nio - Parte II

Continuando nossa exploração de Java NIO que começamos no post Novidades com java.nio vamos ver agora como fazer para:

• copiar um arquivo
• apagar um arquivo
• criar um diretório
• apagar um diretório

Para isto utilizaremos as classes Path, File e Files.

Vejam o vídeo:

Nossa classe é

Continuando com JavaFX - Parte V

Vamos fazer agora uma aplicação utilizando um outro container. Vamos utilizar desta vez o GridPane para ser o container principal de nossa aplicação que é uma tela de login simples.

Os containers que apresentarei neste post são:

• javafx.scene.layout.GridPane
• este gerenciador de layouts permite que criemos um layout baseado em linhas e colunas, formando como o próprio nome indica um grid onde nossos componentes podem ser colocados de acordo com um índice de (coluna, linha). Os componentes podem ainda ocupar duas ou mais colunas (ou linhas) adjacentes como fazemos em uma tabela HTML.
• javafx.scene.layout.HBox
• este gerenciador de layout distribui os componentes automaticamente em uma única linha. É interessante notar que conseguimos gerar um espaçamento do conteúdo (isto é dos componentes dentro do HBox), considerando valores diferentes para o espaçamento no topo, na esquerda, na direita e na área de baixo do HBox.

Dentro da aplicação utilizamos os seguintes componentes:

• javafx.scene.control.Button
• é um botão. temos que implementar EventHandler para que o clique funcione.
• javafx.scene.control.Label
• apresenta um texto na tela, são os rótulos de nossos campos de entrada de dados
• javafx.scene.control.TextField
• cria uma área para a entrada de dados. No nosso exemplo, utilizei para os dois campos esta classe. Em uma aplicação real, a entrada de dados de senha deveria ser feita por PasswordField (esta é uma classe filha de TextField).
• javafx.scene.image.ImageView
• permite mostrar na tela uma imagem carregada pela classe Image.
• javafx.scene.text.Text
• apresenta um texto na tela. No nosso caso utilizo para mostrar a mensagem de login.

O exemplo que irei apresentar é do layout de uma tela de login simples, com um texto de apresentação, uma logo, 2 campos de entrada de dados com seus respectivos labels e um botão para logar. A aplicação efetivamente só coloca os componentes na tela e quando clicamos o botão é gerada uma mensagem.

Continuando com JavaFX - Parte IV

Vamos ver mais um conjunto de alterações na nossa classe base agora apresentando alguns textos no formato de Label na nossa tela principal JavaFX. Para isto vamos utilizar algumas classes interessantes:

• javafx.scene.control.ContentDisplay
• javafx.scene.control.Label;
• javafx.scene.image.Image;
• javafx.scene.image.ImageView
• javafx.scene.paint.Color
• javafx.scene.text.Font

Neste nosso exemplo continuo a utilizar o container StackPane. Você verá que ele não é muito adequado quando colocamos diversos componentes nele.

A classe principal é

Vamos ver então o nosso exemplo funcionando no vídeo abaixo:

Continuando com JavaFX - Parte III

Vamos alterar a nossa classe para poder gerar uma nova janela. Veja o vídeo neste post:

Continuando com JavaFX - Parte II

Vamos alterar a nossa primeira classe colocando algo no StackPane que criamos. Neste caso vamos explorar algumas coisas:

1. vamos colocar um Node que é um botão
2. vamos fazer este botão funcionar quando clicamos nele

O funcionamento de nossa classe está mostrado no vídeo abaixo:

Novidades com java.nio

No Java 7 temos algumas novidades na manipulação de arquivos e diretórios utilizando o pacote java.nio. No exemplo que apresento no vídeo a seguir vamos ver como utilizar algumas das funcionalidades apresentadas pela classe Path.

Nossa classe de exemplo é:

Nossa primeira aplicação JavaFX

O JavaFX é uma plataforma de UI lançada pelo Java para criação de aplicativos ricos para internet (os tais RIA - Rich Internet Applications) mas o JavaFX não é somente isto, como ele podemos criar aplicações standalone para os ambiente onde roda o Java. Com ele conseguimos ainda gerar código compatível com dispositivos móveis.

A arquitetura apresentada pelo Java para o JavaFX está representada no diagrama abaixo:

Fonte: http://docs.oracle.com/javafx/2/architecture/jfxpub-architecture.htm

Quer dizer que o JavaFX é uma mistura de Swing, JavaME e Internet? Mais ou menos isto. O código ainda não é 100% portável de uma plataforma para outra, exigindo do competência do programador para prever as alterações necessárias nos arquivos de configuração como CSS (é o JavaFX usa css para configurar tela). Mas com o JavaFX você pode fazer uma aplicação para desktop, internet, dispositivos móveis (celular , tablet), set-top box, etc.

Vamos ao nosso exemplo. No vídeo você vai ver que o netbeans permite criar automaticamente um "Hello World". Vou mostrar esta criação e também um passo a passo de como construímos a classe manualmente:

Veja o vídeo

Você já pensou por o método main() é public static?

O método Main() na linguagem Java é uma dos primeiros métodos que nós programadores temos contato. Normalmente não pensamos porque ele é declarado como public, static e void. Para aqueles que vêm do C++ fica evidente uma diferença, nesta linguagem existe um método semelhante porém este retorna valor - um int.

Para que precisamos de um método main()? Esta é uma convenção criada para designar o ponto de entrada de qualquer programa Java. É importante destacar que estamos falando de classes usuais, excluindo destas os Servlets, Midlets, JavaFX ou outro programa Java que normalmente está contido em container Java, onde outros métodos de controle do seu ciclo de vida existem.

Ao executarmos na linha de comando

java nome-da-classe

Invocamos a JVM, que carrega a classe principal e passa a execução para um método com a seguinte assinatura

public static void main(String args[])

Se este método não for encontrado é gerada uma exceção do tipo NoSuchMethodError:main e o programa é finalizado.

A assinatura apresentada acima é a tradicional do Java, mas a partir do Java 5 é possível utilizar um novo formato em função da utilização dos varargs com a sintaxe abaixo:

public static void main(String... args)

Das assinaturas acima destaco que

• public indica que o método main pode ser chamado por qualquer objeto e portanto pode ser chamada pela JVM.
• static indica que o método main é um método de classe. Isto é podemos chamá-lo como NomeDaClasse.main() sem ter que instanciar a classe.
• Alguns autores ressaltam que uma vez que C e C++ seguem esta convenção, isto favorece ao Java.
• Se este método não fosse static, a JVM teria que instanciar a classe principal. Isto faria com que fosse obrigatório que esta classe tivesse um construtor sem parâmetros, pois não haveria como a JVM informar parâmetros para outros construtores que tivessem sido sobrepostos.
• Tudo que é declarado em uma classe Java são acessados via referência e precisam ser instaciados (criados como objeto) para que possam ser utilizados. Métodos e dados estáticos são carregados em um espaço de memória separado dentro da JVM que é criado quando a classe é carregada (note que não é o instanciamento do objeto). Desta forma o método main sendo estático, ele fica imediatamente disponível quando a classe é carregada.
• void indica que o método main não retorna valor.
• args é um array de strings, constituindo um mecanismo através do qual o usuário pode enviar informações em runtime para a aplicação (durante a chamada do programa). Cada string (arg[0], arg[1], ...) é chamada de argumento de linha de comando. Isto nos permite fazer com que o programa execute tarefas diferentes ou com comportamentos diferentes sem ter que recompilar o programa.

Resumindo

1. O método main() deve ser declarado como public, static e void, caso contrário a JVM não será capaz de rodar o programa.
2. JVM envia uma exceção NoSuchMethodException:main se ela não achar o método main() com a assinatura (mostrada acima) na classe que é executada pelo comando java NomeDaClasse.*
3. O método main() é o ponto de entrada para qualquer programa Java Core.
4. O método main() é executado em uma thread especial denominada "main" em Java, de forma que o programa ficará executando enquanto esta thread estiver rodando ou enquanto alguma thread non-deamon criada pela thread "main" estiver rodando.**
5. A partir do Java 1.5 é possível utilizar uma nova sintaxe public static void main(String... args)
6. Além dos modificadores static, void e public, podemos utilizar os modificadores:
1. final
2. synchronized
3. strictfp
7. Você pode acrescentar na assinatura do método main() cláusulas throws para indicar as exceções que o método pode enviar.
8. O método main pode ser sobreposto (overloaded) como qualquer outro método, porém somente o método com a assinatura indicada acima.

OBS:
* Um bloco de inicialização estático é executado antes da JVM chamar o método main(). Este bloco é executado quando a classe é carregada na memória.
** Uma thread daemon fica rodando residente, mesmo quando a thread principal é terminada.

Tratamento de exceções

Vamos verificar alguns pontos do tratamento de exceções no Java. O primeiro tópico que vou tratar neste post é a diretiva assert. Ela é utilizada para nos permitir gerar paradas na execução do programa baseado em uma condição booleana. Esta diretiva existe desde a versão 1.4 do Java. Este recurso permite que testemos alguma pré suposição durante o desenvolvimento ter que escrever manipuladores para exceções que provavelmente não ocorrerão quando o programa tiver saído da fase de desenvolvimento.

As assertivas permitem que você teste suas suposições durante a fase de desenvolvimento.

A estrutura do comando é

assert Expressao_booleana : método_não_void;


Como por exemplo:

assert (boolean) : string;

O comando funciona da seguinte maneira: o valor (boolean) deve ser sempre verdadeiro. Quando este valor for avaliado como falso, é gerado uma exceção tipo AssertionError.

Por padrão, assert vem desabilitado. Para desfrutar do recurso é necessário ativá-lo. Os passos são:

1.Colocar as clausulas assert nos locais desejados no nosso programa

2.Compilar as classes (devemos solicitar que a compilação seja feita para uma versão superior a 1.4)

javac -source 1.5 classe.java

3.Habilitar o uso de assert durante a execução utilizando um dois dois parâmetros do java

java –ea classe
java –enableassertions classe

Para desabilitar as assertivas usamos os parâmetros

java –da classe
java –disableassertions classe

Regras de uso assert:

• Assert não pode ser usado no lugar do IF
• Assert não pode testar métodos públicos ou argumento digitado pelo usuário
• Não pode apresentar efeitos colaterais no programa, ou seja, o seu programa deve rodar tanto com ele habilitado ou não.

Como recomendação nós devemos utilizar assert quando escreveríamos um comentários por exemplo em uma cláusula if-then-else. Vamos ver um exemplo abaixo:

    if (i % 3 == 0) {
        ...
    } else if (i % 3 == 1) {
        ...
    } else {
        assert i % 3 == 2 : i;
        ...
    }

Note que esperamos que (i % 3) na última cláusula else sempre dê 2. Porém como o operador % não opera módulo, podemos eventualmente um valor negativo, que não estamos esperando neste local. Com isto uma exceção AssertionError pode ser utilizada.

Outro local onde poderíamos utilizar assert é em declarações switch...case sem cláusula default. A inexistência de uma cláusula default não é recomendada, mas vamos dizer que acreditamos que testamos os pontos cardeiais como no switch abaixo:

switch (direcao) {
  case PontoCardeal.NORTE:
    ....
    break;
  case PontoCardeal.SUL:
    ....
    break;
  case PontoCardeal.LESTE:
    ....
    break;
  case PontoCardeal.OESTE:
    ....
    break;
}

se a variável direcao for do tipo Enum PontoCardeal nunca teremos necessidade de uma cláusula default. Uma alteração possível é a colocação da seguinte cláusula default.

  default:
    throw new AssertionError(suit);



Se a variável aceitar um quinto valor, será gerada uma exceção AssertionError.