Gerenciando suas Chaves no Android de forma Eficiente

Padrão

Olá pessoal! Depois de um bom tempo sumido, estou de volta para falar de gerenciamento de chaves de assinatura no Android.

Beleza, você já desenvolveu seu aplicativo matador, que vai te gerar milhões em 2 dias, e agora vai gerar a sua build de release para publicar no Google Play. Nesse caso, precisamos criar a nossa assinatura de release no arquivo build.gradle do nosso projeto. Alguma coisa mais ou menos assim:

signingConfigs {
    release {
        storeFile file('/home/rafael/minha_key.jks')
        storePassword 'senha secreta'
        keyAlias 'app_android'
        keyPassword 'senha mais secreta ainda'
    }
}

Mas… tem alguma coisa errada aí. Principalmente se estamos utilizando algum controle de versão, como o Git ou SVN, não é uma boa prática enviarmos dados sensíveis para eles (como senhas, keystores e coisas do tipo). Durante algum tempo, a saída utilizada por mim foi adicionar esses dados ao arquivo gradle.properties na raiz do projeto, e não enviá-lo para o controle de versão.

STORE_FILE=/home/rafael/minha_key.jks
STORE_PASSWORD=senha secreta
KEY_ALIAS=app_android
KEY_PASSWORD=senha mais secreta ainda

Dessa forma, a nossa configuração de assinatura ficaria algo assim:

signingConfigs {
    release {
        storeFile file(STORE_FILE)
        storePassword STORE_PASSWORD
        keyAlias KEY_ALIAS
        keyPassword KEY_PASSWORD
    }
}

Funciona bem, não temos dados sensíveis no nosso controle de versão mas… temos basicamente dois problemas principais nessa abordagem:

  • No clone do projeto, você terá um erro de build. Ou seja, se entrou alguém na equipe e clonar o projeto, baterá com a cara na porta logo de cara. Isso já vai atrasar um pouco o join no projeto. Esse problema também se aplica quando o código está em um servidor de CI (Jenkins, Travis, CircleCI, etc.)
  • Tem o agravante humano, ou seja, sempre há o risco de, sem querer, você enviar o arquivo original por algum motivo. Obviamente que você pode adicionar este arquivo no .gitignore ou equivalente no SVN, mas nesse caso caímos no primeiro cenário problemático.

Então… qual a saída?

Depois de pensar um pouco, acabei encontrando, hoje, a melhor saída com o uso de variáveis de ambiente! Como assim?

Vamos lá: o primeiro passo é criarmos uma assinatura default para o projeto. No meu caso, eu simplesmente copio a debug.keystore (que fica dentro da pasta .android do  usuário) e coloco, por exemplo, dentro de um diretório chamado distribution na raiz do meu projeto. Essa chave vai garantir que a build não vai quebrar, por exemplo, quando alguém clonar o projeto ou em um servidor de CI, num primeiro momento.

Agora, na configuração da minha assinatura, podemos fazer algo do tipo:

signingConfigs {
    release {
        storeFile file(System.getenv('STORE_FILE') != null ? System.getenv('STORE_FILE') : '../distribution/debug.keystore')
        storePassword System.getenv('STORE_PASSWORD') != null ? System.getenv('STORE_PASSWORD') : 'android'
        keyAlias System.getenv('KEY_ALIAS') != null ? System.getenv('KEY_ALIAS') : 'androiddebug'
        keyPassword System.getenv('KEY_PASSWORD') != null ? System.getenv('KEY_PASSWORD') : 'android'
    }
}

Nota: caso seu servidor de CI esteja gerando builds de release, você pode setar as variáveis de ambiente nele também para gerar builds assinadas corretamente.

E pronto! Agora, para gerar a build corretamente, você pode exportar as variáveis de ambiente ou, como eu faço, colocar os dados da chave no comando apenas na hora de gerar a build de release:

$ STORE_FILE='/home/rafael/minha_key.jks' STORE_PASSWORD='senha secreta' KEY_ALIAS='app_android' KEY_PASSWORD='senha mais secreta ainda' ./gradlew clean assembleRelease

 E é isso! Espero que a dica seja útil para vocês e, caso tenham sugestões, podem postar aí nos comentários!

Até a próxima! 😀

Tutorial Mentawai #4 – Autorização

Padrão

Olá pessoal! Tudo certo?

No último tutorial sobre o Mentawai, vimos como implementar facilmente autenticação em um aplicativo web. No post de hoje, vamos complementar o conceito, mostrando o que o Mentawai pode oferecer em se falando de Autorização.

De fato, Autenticação e Autorização são conceitos complementares. Não faz sentido se falar em Autorização (o que cada usuário tem acesso) se o aplicativo não implementa Autenticação (apenas usuários autênticos podem ter acesso ao aplicativo).

Continue lendo!

Esteganografia com Arquivos Bitmap em C++

Padrão


Olá, pessoal! Este ano na faculdade tivemos um trabalho sobre esteganografia. Pra quem não conhece, a esteganografia é uma técnica no qual você esconde uma mensagem, de forma que, se ela for interceptada, o intruso nem saberá que ela existe. Combinada com técnicas de encriptação, ela se torna uma ótima forma de se transmitir conteúdo sigiloso.

Este trabalho consistia em ler um arquivo texto, escondê-lo em um arquivo Bitmap (o arquivo Bitmap é um dos mais utilizados na esteganografia pelo fato de não possuir compactação) e depois possibilitar-se extrair a mensagem do arquivo novamente.

Bom, como podem ver, o código está meio “poluído” (confesso que no começo tentei fazer uma coisa bem organizada, mas de acordo que o código foi dando muito problema, acabou “desandando” :D). Então, disponibilizo aqui a classe em C++ que implementa esteganografia em arquivos Bitmap.

// Arquivo esteganografia.h

#ifndef ESTEGANOGRAFIA_H
#define ESTEGANOGRAFIA_H

#include <string>
#include <iostream>
#include <cstdlib>
#include <cstdio>
using namespace std;

struct RGB
{
    char verde;
    char vermelho;
    char azul;
};

struct CabecalhoBitmap
{
    char identificador[2]; // Os símbolos que definem o arquivo como bitmap (0x42 e 0x4D)
    int tamanho; // O tamanho do bitmap em bytes
    short int areaReservada1; // Reservado
    short int areaReservada2; // Reservado
    int enderecoInicial; // Offset
};

struct CabecalhoMapaBits
{
    int tamanho; // O tamanho deste cabeçalho - 40 bytes
    int largura; // Largura do bitmap em pixels
    int altura; // Altura do bitmap em pixels
    short int planosCor; // A quantidade de planos de cor utilizados. Deve ser setado para 1
    short int bpp; // Bits por pixel
    int metodoCompressao; // Método de compressão
    int tamanhoImagem; // O tamanho da imagem. Este é o tamanho bruto dos dados do bitmap. Não deve ser confundido com o tamanho da imagem
    int resolucaoHorizontal; // Resolução horizontal da imagem
    int resolucaoVertical; // Resolução vertical da imagem
    int coresNaPaleta; // O número de cores na paleta de cores
    int coresImportantes; // O número de cores importantes usadas, ou 0 se todas são importantes. Geralmente ignorado.
};

class Esteganografia
{
private:
    FILE *arquivo;
    FILE *mensagem;
    CabecalhoBitmap cabecalho;
    CabecalhoMapaBits cabDados;
    string nomeArquivo;
    char bytesDeAjuste; // 0 a 3 - o número de bytes a serem adicionados para criar uma "linha divisível por 4"

    void esconderMensagem(string mensagem);
    string extrairMensagem(void);
    void salvarBitmap(void);
public:
    RGB *pixels;
    int qtdePixels;
    Esteganografia();
    ~Esteganografia();
    void inserirMensagem(string mensagem, string arquivo);
    string extrairMensagem(string arquivo);
    void imprimirInfoArquivo(void);
};

#endif // ESTEGANOGRAFIA_H
// Arquivo esteganografia.cpp

#include "esteganografia.h"

Esteganografia::Esteganografia()
{

}

Esteganografia::~Esteganografia()
{

}

void Esteganografia::inserirMensagem(string arqmensagem, string arquivo)
{
    this->arquivo = fopen(arquivo.c_str(), "rb");
    if(!this->arquivo)
    {
        cout << endl << " Arquivo nao encontrado...";
        system("pause");
        return;
    }

    string mensagemArquivo;
    char caract;
    this->mensagem = fopen(arqmensagem.c_str(), "r");
    if(!this->mensagem)
    {
        cout << endl << " Arquivo nao encontrado...";
        system("pause");
        return;
    }
    caract = fgetc(this->mensagem);
    while(caract != EOF)
    {
        mensagemArquivo += caract;
        caract = fgetc(this->mensagem);
    }
    fclose(this->mensagem);

    nomeArquivo = arquivo;

    // Preenchimento do cabeçalho do Bitmap
    fread(&cabecalho.identificador, sizeof(cabecalho.identificador), 1, this->arquivo);
    fread(&cabecalho.tamanho, sizeof(cabecalho.tamanho), 1, this->arquivo);
    fread(&cabecalho.areaReservada1, sizeof(cabecalho.areaReservada1), 1, this->arquivo);
    fread(&cabecalho.areaReservada2, sizeof(cabecalho.areaReservada2), 1, this->arquivo);
    fread(&cabecalho.enderecoInicial, sizeof(cabecalho.enderecoInicial), 1, this->arquivo);

    // Preenchimento do Mapa de Bits
    fread(&cabDados.tamanho, sizeof(cabDados.tamanho), 1, this->arquivo);
    fread(&cabDados.largura, sizeof(cabDados.largura), 1, this->arquivo);
    fread(&cabDados.altura, sizeof(cabDados.altura), 1, this->arquivo);
    fread(&cabDados.planosCor, sizeof(cabDados.planosCor), 1, this->arquivo);
    fread(&cabDados.bpp, sizeof(cabDados.bpp), 1, this->arquivo);
    fread(&cabDados.metodoCompressao, sizeof(cabDados.metodoCompressao), 1, this->arquivo);
    fread(&cabDados.tamanhoImagem, sizeof(cabDados.tamanhoImagem), 1, this->arquivo);
    fread(&cabDados.resolucaoHorizontal, sizeof(cabDados.resolucaoHorizontal), 1, this->arquivo);
    fread(&cabDados.resolucaoVertical, sizeof(cabDados.resolucaoVertical), 1, this->arquivo);
    fread(&cabDados.coresNaPaleta, sizeof(cabDados.coresNaPaleta), 1, this->arquivo);
    fread(&cabDados.coresImportantes, sizeof(cabDados.coresImportantes), 1, this->arquivo);

    this->bytesDeAjuste = cabDados.largura % 4;

    // Posiciona no fim do arquivo
    fseek(this->arquivo, 0, SEEK_END);

    // Calcula a quantidade de pixels da imagem
    qtdePixels = cabDados.largura * cabDados.altura;
    pixels = new RGB[qtdePixels];

    // Posiciona no início da área de dados da imagem
    fseek(this->arquivo, cabecalho.enderecoInicial, SEEK_SET);

    // Jogando os pixels da imagem no vetor de RGB
    for (int larg = 0, pix = 0; pix < qtdePixels;)
    {
        // Se larg chegou ao tamanho da largura da imagem
        if (larg == cabDados.largura)
        {
            fseek(this->arquivo, bytesDeAjuste, SEEK_CUR); // "Pula" os bytes faltantes na linha
            larg = 0;
            continue; // Volta no início do for
        }

        fread(&pixels[pix++], sizeof(RGB), 1, this->arquivo); // Lê o pixel e atribui os valores à estrutura RGB
        larg++;
    }

    fclose(this->arquivo);

    unsigned long capacidade = (cabecalho.tamanho - cabecalho.enderecoInicial)/3;
    if(mensagemArquivo.size() > capacidade)
    {
        cout << "Arquivo de texto muito grande!" << endl;
        system("pause");
        return;
    }
    // Agora temos o bitmap estruturado dentro da nossa classe

    if(cabecalho.enderecoInicial != 0x36)
    {
        cout << "Tipo de arquivo invalido!" << endl;
        system("pause");
        return;
    }
    this->esconderMensagem(mensagemArquivo);
    this->salvarBitmap();

    imprimirInfoArquivo();

    delete pixels;
}

string Esteganografia::extrairMensagem(string arquivo)
{
    this->arquivo = fopen(arquivo.c_str(), "rb");
    if(!this->arquivo)
    {
        cout << endl << " Arquivo nao encontrado...";
        system("pause");
        return string("");
    }

    nomeArquivo = arquivo;

    // Preenchimento do cabeçalho do Bitmap
    fread(&cabecalho.identificador, sizeof(cabecalho.identificador), 1, this->arquivo);
    fread(&cabecalho.tamanho, sizeof(cabecalho.tamanho), 1, this->arquivo);
    fread(&cabecalho.areaReservada1, sizeof(cabecalho.areaReservada1), 1, this->arquivo);
    fread(&cabecalho.areaReservada2, sizeof(cabecalho.areaReservada2), 1, this->arquivo);
    fread(&cabecalho.enderecoInicial, sizeof(cabecalho.enderecoInicial), 1, this->arquivo);

    // Preenchimento do Mapa de Bits
    fread(&cabDados.tamanho, sizeof(cabDados.tamanho), 1, this->arquivo);
    fread(&cabDados.largura, sizeof(cabDados.largura), 1, this->arquivo);
    fread(&cabDados.altura, sizeof(cabDados.altura), 1, this->arquivo);
    fread(&cabDados.planosCor, sizeof(cabDados.planosCor), 1, this->arquivo);
    fread(&cabDados.bpp, sizeof(cabDados.bpp), 1, this->arquivo);
    fread(&cabDados.metodoCompressao, sizeof(cabDados.metodoCompressao), 1, this->arquivo);
    fread(&cabDados.tamanhoImagem, sizeof(cabDados.tamanhoImagem), 1, this->arquivo);
    fread(&cabDados.resolucaoHorizontal, sizeof(cabDados.resolucaoHorizontal), 1, this->arquivo);
    fread(&cabDados.resolucaoVertical, sizeof(cabDados.resolucaoVertical), 1, this->arquivo);
    fread(&cabDados.coresNaPaleta, sizeof(cabDados.coresNaPaleta), 1, this->arquivo);
    fread(&cabDados.coresImportantes, sizeof(cabDados.coresImportantes), 1, this->arquivo);

    this->bytesDeAjuste = cabDados.largura % 4;

    // Posiciona no fim do arquivo
    fseek(this->arquivo, 0, SEEK_END);

    // Calcula a quantidade de pixels da imagem
    qtdePixels = cabDados.largura * cabDados.altura;
    pixels = new RGB[qtdePixels];

    // Posiciona no início da área de dados da imagem
    fseek(this->arquivo, cabecalho.enderecoInicial, SEEK_SET);

    // Jogando os pixels da imagem no vetor de RGB
    for (int larg = 0, pix = 0; pix < qtdePixels;)
    {
        // Se larg chegou ao tamanho da largura da imagem
        if (larg == cabDados.largura)
        {
            fseek(this->arquivo, bytesDeAjuste, SEEK_CUR); // "Pula" os bytes faltantes na linha
            larg = 0;
            continue; // Volta no início do for
        }

        fread(&pixels[pix++], sizeof(RGB), 1, this->arquivo); // Lê o pixel e atribui os valores à estrutura RGB
        larg++;
    }

    fclose(this->arquivo);

    // Agora temos o bitmap estruturado dentro da nossa classe
    string mensagem;

    mensagem = this->extrairMensagem();

    return mensagem;
}

void Esteganografia::esconderMensagem(string mensagem)
{
    /*
     * Este método pega 3 pixels da imagem por vez. Dessa forma, teremos 9 bytes.
     * Desses 9 bytes, pegamos o bit menos significativo de 8 deles e repartimos
     * os caracteres da mensagem, letra a letra.
     */

    for(unsigned int numCaracter = 0, indice = 0; numCaracter <= mensagem.size(); numCaracter++)
    {
        this->pixels[indice].vermelho &= 254;
        this->pixels[indice].verde &= 254;
        this->pixels[indice].azul &= 254;

        this->pixels[indice].vermelho |= (mensagem[numCaracter] & 1 ? 1 : 0);
        this->pixels[indice].verde |= (mensagem[numCaracter] & 2 ? 1 : 0);
        this->pixels[indice].azul |= (mensagem[numCaracter] & 4 ? 1 : 0);
        indice++;

        this->pixels[indice].vermelho &= 254;
        this->pixels[indice].verde &= 254;
        this->pixels[indice].azul &= 254;

        this->pixels[indice].vermelho |= (mensagem[numCaracter] & 8 ? 1 : 0);
        this->pixels[indice].verde |= (mensagem[numCaracter] & 16 ? 1 : 0);
        this->pixels[indice].azul |= (mensagem[numCaracter] & 32 ? 1 : 0);
        indice++;

        this->pixels[indice].vermelho &= 254;
        this->pixels[indice].verde &= 254;

        this->pixels[indice].vermelho |= (mensagem[numCaracter] & 64 ? 1 : 0);
        this->pixels[indice].verde |= (mensagem[numCaracter] & 128 ? 1 : 0);
        indice++;
    }
}

void Esteganografia::salvarBitmap(void)
{
    arquivo = fopen(nomeArquivo.c_str(), "wb");
    if (!arquivo)
    {
        cout << " Impossivel criar/sobrescrever o arquivo." << endl;
        system("pause");
        exit(1);
    }

    fwrite(&cabecalho.identificador, sizeof(cabecalho.identificador), 1, arquivo);
    fwrite(&cabecalho.tamanho, sizeof(cabecalho.tamanho), 1, arquivo);
    fwrite(&cabecalho.areaReservada1, sizeof(cabecalho.areaReservada1), 1, arquivo);
    fwrite(&cabecalho.areaReservada2, sizeof(cabecalho.areaReservada2), 1, arquivo);
    fwrite(&cabecalho.enderecoInicial, sizeof(cabecalho.enderecoInicial), 1, arquivo);

    fwrite(&cabDados.tamanho, sizeof(cabDados.tamanho), 1, arquivo);
    fwrite(&cabDados.largura, sizeof(cabDados.largura), 1, arquivo);
    fwrite(&cabDados.altura, sizeof(cabDados.altura), 1, arquivo);
    fwrite(&cabDados.planosCor, sizeof(cabDados.planosCor), 1, arquivo);
    fwrite(&cabDados.bpp, sizeof(cabDados.bpp), 1, arquivo);
    fwrite(&cabDados.metodoCompressao, sizeof(cabDados.metodoCompressao), 1, arquivo);
    fwrite(&cabDados.tamanhoImagem, sizeof(cabDados.tamanhoImagem), 1, arquivo);
    fwrite(&cabDados.resolucaoHorizontal, sizeof(cabDados.resolucaoHorizontal), 1, arquivo);
    fwrite(&cabDados.resolucaoVertical, sizeof(cabDados.resolucaoVertical), 1, arquivo);
    fwrite(&cabDados.coresNaPaleta, sizeof(cabDados.coresNaPaleta), 1, arquivo);
    fwrite(&cabDados.coresImportantes, sizeof(cabDados.coresImportantes), 1, arquivo);

    char fimDeLinha[bytesDeAjuste];

    for (int i = 0; i < bytesDeAjuste; i++)
        fimDeLinha[i] = 0;

    for (int pix = 0, larg = 0; pix < qtdePixels;)
    {
        if (larg == cabDados.largura)
        {
            fwrite(&fimDeLinha, bytesDeAjuste, 1, arquivo);
            larg = 0;
            continue;
        }
        fwrite(&pixels[pix++], sizeof(RGB), 1, arquivo);
        larg++;
    }

    fclose(arquivo);
}

string Esteganografia::extrairMensagem(void)
{
    string mensagem;
    char caracter;
    int indice = 0;

    /*
     * A cada 3 pixels (9 bytes), pegamos os bits menos significativos
     * dos 8 primeiros bytes - da mesma forma como foi gravado
     */

    do
    {
        caracter = (pixels[indice].vermelho & 1) +
                   ((pixels[indice].verde & 1) * 2) +
                   ((pixels[indice].azul & 1) * 4) +
                   ((pixels[indice+1].vermelho  & 1) * 8 ) +
                   ((pixels[indice+1].verde & 1) * 16) +
                   ((pixels[indice+1].azul & 1) * 32) +
                   ((pixels[indice+2].vermelho & 1) * 64) +
                   ((pixels[indice+2].verde & 1) * 128);

        mensagem += caracter;
        indice += 3;
    }
    while (caracter != '\0');

    mensagem = mensagem.substr(0, mensagem.length() - 1);
    return mensagem;
}

void Esteganografia::imprimirInfoArquivo(void)
{
    printf("\n INFORMACOES DO BITMAP\n\n");
    printf(" Identificador: %c%c\n", cabecalho.identificador[0], cabecalho.identificador[1]);
    printf(" Tamanho: %i\n", cabecalho.tamanho);
    printf(" Endereco Inicial: 0x%X\n", cabecalho.enderecoInicial);
    printf(" Area Reservada 1: %hi\n", cabecalho.areaReservada1);
    printf(" Area Reservada 2: %hi\n", cabecalho.areaReservada2);
    printf(" Altura: %i\n", cabDados.altura);
    printf(" Largura: %i\n", cabDados.largura);
    printf(" Pixels: %i\n", qtdePixels);
    printf(" Bytes de ajuste: %i\n ", bytesDeAjuste);
    system("pause");
}