Segurança eletrônica

Reproduzido do site da Polícia Civil do Estado de São Paulo, seguem algumas dicas de segurança eletrônica:

1. Evite abrir e-mails de remetentes desconhecidos; se forem abertos e estiverem acompanhados de arquivos anexos, não abra tais anexos em hipótese alguma. Geralmente são arquivos executáveis que se infiltram no seu computador.
2. Evite abrir e-mails de bancos e órgãos oficiais como Receita Federal, TRE, DETRAN e SERASA. Essas instituições não enviam e-mails, a não ser que seja solicitado pelo usuário.
3. Faça instalação de programas antivírus, de preferência fabricantes conhecidos, e evite programas piratas.
4. Fazer uso de Backup (cópia de segurança) em arquivos importantes.
5. Escolha sites conhecidos.
6. Certifique-se da segurança do site. Ele deve ter um ícone de cadeado na parte inferior da tela.
7. Só digite números pessoais como identidade, CPF ou cartão de crédito em sites criptografados (essa técnica de segurança ‘‘embaralha’’ as informações para que só os computadores do site consigam desvendar o real significado de suas informações pessoais). Para saber se a empresa conta com esse processo, procure o link que descreve as formas de pagamento e condições de segurança.
8. Verifique se os dados do seu cartão de crédito ficam armazenados no banco de dados da loja virtual. Os melhores sites são os que não salvam esses dados.
9. Imprima todas as etapas da negociação feita pela Internet. Inclusive a descrição do produto, os termos de pagamento, condições e a garantia.
10. Evite deixar em seu computador pessoal (PC) senhas gravadas ou o uso da função auto-completar.
11. Crie senhas aleatórias, mesclando letras e números e procure alterá-la periodicamente, evite usar nomes que possam facilitar a ação de Hackers como data de aniversário, numero do telefone, datas comemorativas e nomes de familiares ou animais de estimação.
12. Não forneça dados pessoais em salas de relacionamento ou bate-papos on-line. Os criminosos são capazes de desvendar senhas com apenas algumas informações pessoais.
13. Nunca divulgue número de cartão, conta bancária ou senha por e-mail.
14. Os pais devem ficar atentos e monitorar os contatos e relacionamentos que envolvem crianças e adolescentes, principalmente durante a madrugada.

Fonte: Polícia Civil do Estado de São Paulo (http://www2.policiacivil.sp.gov.br/x2016/modules/mastop_publish/?tac=Seguran%E7a_eletr%F4nica)

Tipografia no Wolfram Mathematica

O Mathematica (http://www.wolfram.com/mathematica/) é um software matemático computacional para cálculo desde a matemática elementar até sistemas de equações complexos. Possui uma interface de entrada de expressões semelhante à notação humana. Sua completa tipografia permite a entrada de qualquer expressão e símbolo matemático.

Neste artigo apresento algumas teclas de atalhos para digitação das expressões matemáticas, em relação a caracteres especiais e símbolos da notação matemática, tabulação e expressão bi-dimensional. Analogamente, toda esta tipografia pode ser editada pelo menu "Palettes", onde encontram-se assistentes de entrada de caracteres matemáticos.

A digitação funciona da seguinte forma; em alguns casos pela combinação de duas ou mais teclas pressionadas simultaneamente, por exemplo Ctrl+7; em outros casos teclando Esc, seguido da abreviação do símbolo e concluindo com outro Esc, por exemplo Esc dd Esc. Segue a tipografia:

Expressões bi-dimensionais:

Ctrl + /                     Fração
Ctrl + 6 ou Ctrl + ^         Potência ou sobrescrito
Ctrl + 2 ou Ctrl + @         Raiz
Ctrl + 5 ou Ctrl + %         Radical da raiz
Ctrl + - ou Ctrl + _         Subescrito
Ctrl + 7 ou Ctrl + &         Escrita em cima
Ctrl + 4 ou Ctrl + $         Escrita embaixo

Símbolos de matemática básica:

Esc cross Esc                Cruz
Esc * Esc                    Vezes
Esc div Esc                  Divisão
Esc != Esc                   Diferente
Esc <= Esc                   Menor igual
Esc >= Esc                   Maior igual
Esc +- Esc                   Mais ou menos
Esc deg Esc                  Grau

Notação tabulada para o cálculo:

Esc intt Esc                 Integral indefinida
Esc dintt Esc                Integral definida
Esc dt Esc                   Derivada parcial
Esc sumt Esc                 Somatório
Esc prodt Esc                Produto

Caracteres especiais:

Esc ee Esc                   Número exponencial
Esc pi Esc                   Número pi
Esc ii Esc                   Número imaginário
Esc inf Esc                  Infinito
Esc int Esc                  Integral
Esc dd Esc                   Diferencial
Esc pd Esc                   Diferencial parcial
Esc sum Esc                  Somatório
Esc prod Esc                 Produto

Esc dsN Esc                  Números naturais
Esc dsZ Esc                  Números inteiros
Esc dsQ Esc                  Números racionais
Esc dsR Esc                  Números reais
Esc dsC Esc                  Números complexos

Símbolos de teoria dos conjuntos:

Esc el Esc                   Pertence
Esc !el Esc                  Não pertence
Esc ex Esc                   Existe
Esc !ex Esc                  Não existe
Esc sup Esc                  Contém
Esc !sup Esc                 Não contém
Esc sub Esc                  Contido
Esc !sub Esc                 Não contido
Esc fa Esc                   Para todo
Esc un Esc                   União
Esc inter Esc                Intersecção
Esc es Esc                   Conjunto vazio

Símbolos de lógica:

Esc && Esc ou Esc and Esc    E
Esc || Esc ou Esc or Esc     Ou
Esc ! Esc ou Esc not Esc     Negação
Esc nand Esc                 Nand
Esc nor Esc                  Nor
Esc xor Esc                  Xor
Esc xnor Esc                 Xnor

Esc === Esc                  Congruente
Esc => Esc                   Implica
Esc equiv Esc                Equivalente
Esc tf Esc                   Então/portanto

Isto não é tudo, existem muito mais teclas de atalhos. Além do mais, muitos símbolos somente são acessíveis pelo nome do caractere (ex. \[Because]), pelo código unicode (ex. 2235) ou pelos assistentes do menu "Palettes".

Com a expressão devidamente digitada, é possível computá-la, afinal é um software para cálculo matemático. A seguir as teclas de atalhos para computação:

Shift + Enter                Computa a expressão;
                             (ou apenas o Enter do teclado numérico)
Shift + Ctrl + Enter         Computa somente a expressão selecionada;
Alt + .                      Aborta uma computação

O ícone deste software pode ser digitado com as teclas Esc math Esc. Conheça outros softwares matemáticos em: http://dan-scientia.blogspot.com/2009/08/softwares-matematicos-poderosos.html

Automatizando a execução do Autopsy com o chkconfig

O Autopsy é uma interface gráfica para as ferramentas do The Sleuth Kit. Para ter acesso à interface é preciso iniciar o Autopsy, assim seus scripts geram as páginas da interface, que serão acessadas através de um navegador Web.

A linha de comando para iniciar o Autopsy é simples, pelo prompt do terminal podemos executar:

# autopsy -d /evidencia &

Entretanto, cada vez que o sistema for reiniciado, é preciso executar novamente este comando. Claro que é possível adicionar esta linha de comando no arquivo "/etc/rc.d/rc.local", contudo, esta não é a forma mais elegante para automatizar a execução do Autopsy, principalmente em uma distribuição Fedora.

O Fedora utiliza o comando "chkconfig" para automatizar a execução dos serviços. O chkconfig trabalha com scripts para controlar os serviços. O chkconfig controla quais serviços serão iniciados durante a inicialização da máquina. Cada serviço possui um script e para adequar o Autopsy ao comando chkconfig, é preciso criar o script. A seguir o conteúdo do script para o Autopsy (salve-o com o nome "autopsy"):

-----------------------corte aqui-----------------------
#!/bin/sh
#
# chkconfig: 2345 90 10
# description: Autopsy is a web interface for The Sleuth Kit
#

# Source function library.
. /etc/init.d/functions

[ -x /usr/bin/autopsy ]  || exit 1

RETVAL=0

start(){
    if [ ! -f /var/lock/subsys/autopsy ]; then
    echo -n $"Starting autopsy daemon: "
    daemon autopsy -d /evidencia &
    RETVAL=$?
    [ $RETVAL -eq 0 ] && touch /var/lock/subsys/autopsy
    return $RETVAL
    else
        echo $"Autopsy is already running."
    fi

}

stop(){
    if [ -f /var/lock/subsys/autopsy ]; then
    echo -n $"Stopping autopsy daemon: "
    killproc autopsy
    RETVAL=$?
    rm -f /var/lock/subsys/autopsy
    return $RETVAL
    else
        echo $"Autopsy is not running."
    fi
}

restart(){
    if [ -f /var/lock/subsys/autopsy ]; then
    stop
    start
    else
        echo $"Autopsy is not running."
    fi
}

case "$1" in
    start)
        start
        ;;
    stop)
        stop
        ;;
    restart)
        restart
        ;;
    status)
        status autopsy
        ;;
    *)
        echo $"Usage: $0 {start|stop|status|restart}"
        RETVAL=1
esac

exit $RETVAL
--------------------------------------------------------

Para adicionar o script e ativar o controle do serviço pelo gerenciamento do chkconfig, primeiro é preciso colocar o script no diretório "/etc/rc.d/init.d/" e então executar no prompt do terminal o comando "chkconfig --add nome_do_serviço":

# chkconfig --add autopsy

A partir deste ponto basta executar o comando "chkconfig nome_do_serviço on" para que a devida ligação simbólica seja criada nos diretórios "/etc/rc.d/rcN.d/", especificados no cabeçalho do script:

# chkconfig autopsy on

Com a execução do comando "chkconfig nome_do_serviço off" estas ligações são removidas. Do mesmo modo, pode-se remover o controle do serviço pelo gerenciamento do chkconfig executando o comando "chkconfig --del nome_do_serviço":

# chkconfig autopsy off
# chkconfig --del autopsy

Com a execução do comando "chkconfig autopsy on", o serviço do Autopsy será executado automaticamente na próxima inicialização do sistema. A execução imediata do serviço pode ser feita com a chamada do próprio script pela linha de comando, em algo como "/etc/rc.d/init.d/nome_do_serviço start":

# /etc/rc.d/init.d/autopsy start

Ou também utilizando o comando "service", em algo como "service nome_do_serviço start":

# service autopsy start

Lembrando que estas formas só funcionam para a seção atual, não mantendo para a próxima inicialização da máquina.

Estes scripts usualmente atendem aos argumentos "start", "stop", "status" e "restart", do mesmo modo os comandos que controlam os serviços. O argumento "stop" para o serviço, o argumento "status" mostra a situação atual do serviço e o argumento "restart" reinicia o serviço.

Mesmo para a execução manual do Autopsy, é muito mais elegante realizar através do script em "/etc/rc.d/init.d/". Saiba mais sobre "Configurando Serviços no Linux" em http://dan-scientia.blogspot.com/2009/09/configurando-servicos-no-linux.html e sobre "Computação forense com o Sleuth Kit e Autopsy" em http://dan-scientia.blogspot.com/2010/10/computacao-forense-com-o-sleuth-kit-e.html

Descobrindo senhas no Linux com o John the Ripper

O programa John the Ripper (http://www.openwall.com/john/) é capaz de quebrar senhas de usuários em diversos sistemas operacionais, incluindo Unix, Linux, Windows e DOS. Seu propósito inicial é detectar senhas fracas, para que o administrador do sistema solicite ao usuário que altere sua senha. O John the Ripper é capaz de identificar o algoritmo utilizado para gerar os hashes das senhas.

Um sistema Linux tradicional armazena as senhas das contas dos usuários no arquivo /etc/passwd. As distribuições modernas utilizam o arquivo /etc/shadow para armazenar as senhas. Desta forma, primeiramente é necessário combinar o /etc/passwd e o /etc/shadow em um único arquivo para que o programa john reconheça o conteúdo. Use uma linha de comando semelhante a apresentada a seguir:

# unshadow /etc/passwd /etc/shadow > senhas.txt

Neste primeiro momento é necessário acessar como root para ter permissão de leitura nos arquivos em /etc/. Se preferir, copie os arquivos /etc/passwd e /etc/shadow para um diretório de usuário e execute o comando unshadow por este usuário nas cópias do passwd e shadow:

$ unshadow passwd shadow > senhas.txt

Agora podemos executar o programa john neste arquivo combinado de senhas, para que o programa quebre as senhas encontradas:

$ john senhas.txt

Pode ser interessante, para não perder tempo, especificar determinado usuário para quebrar a senha. Há algumas formas para fazer isto, com a opção --users, especificando o nome do usuário, o número UID, ou excluindo os outros usuários. As três linhas abaixo são exemplos para cada uma das formas:

$ john --users=convidado senhas.txt
$ john --users=503 senhas.txt
$ john --users=-root,joao,pedro senhas.txt

Quando o programa john está em execução, ele não exibe as tentativas de quebra, mas uma linha de palpites pode ser exibida pressionando a tecla Espaço. Esta linha possui informações como tempo gasto, caracteres por segundo, tentativas de senhas etc. Para abortar pressione Ctrl+C.

Ao encontrar a senha, ela é exibida junto com o nome do usuário. As senhas quebradas serão armazenadas no arquivo ~/.john/john.pot, para consultas posteriores, com o comando:

$ john --show senhas.txt

Veja um exemplo completo de comando e resposta do programa john (a senha da conta convidado é 123):

$ john --users=convidado senhas.txt
Loaded 1 password hash (generic crypt(3) [?/64])
123              (convidado)
guesses: 1  time: 0:00:00:05 100% (2)  c/s: 146  trying: 12345 - missy

A senha 123 é muito simples e rápida de se quebrar. Entretanto, senhas com oito ou mais caracteres alfanuméricos, armazenadas com a função crypt(), podem demorar um bocado para serem quebradas.

Por exemplo, sem contar caracteres especiais e maiúsculas, pode-se usar as 26 letras e os 10 números para compor um dígito da senha. Uma senha com 8 dígitos pode ser formada de 36 elevado à 8 arranjos diferentes, ou seja, 2,82e+12 arranjos. Isto é relativamente imenso. Se um computador pudesse processar 10 milhões de senhas por segundo, apenas comparando o hash, a quebra desta senha por força-bruta poderia levar até 78 horas. É tempo razoável mas possível.

Com a necessidade de usar a função crypt(), o desempenho no número de senhas por segundo cai bastante. Pois felizmente, as distribuições Linux adicionam um "salt", forçando o uso da função crypt(), para dificultar a quebra por força-bruta com Hash Tables.

O modo de uso do programa john, apresentado neste artigo, não utiliza Hash Tables. Os arranjos são gerados e calculados com a função crypt() em cada tentativa. Isto atrasa bastante o processo.

O programa John the Ripper utiliza alguns modos para otimizar a quebra da senha e possui algumas opções para sua linha de comando. Consulte a documentação, normalmente localizada em /usr/share/doc/john-x.x.x/, para saber mais.

Problema de Lógica: A equipe do hospital

"A equipe do hospital consiste de 16 médicos e enfermeiros, incluindo eu. Os seguintes fatos se aplicam aos membros da equipe. Me incluindo ou não, nenhuma diferença faz. A equipe consiste de:

1. Mais enfermeiros do que médicos.
2. Mais médicos homens do que enfermeiros homens.
3. Mais enfermeiros homens do que enfermeiras mulheres.
4. Pelo menos uma médica mulher."

Qual é o sexo e a ocupação de quem está falando?





RESPOSTA





Pelos fatos 1 e 4, e do fato de que há 16 médicos e enfermeiros, existem nove ou mais enfermeiros e seis ou menos médicos homens. Assim, pelo fato 2, o número de enfermeiros homens precisa ser menor do que seis.

Pelo fato 3, o número de enfermeiras mulheres precisa ser menor que o número de enfermeiros homens. Assim, precisa ter mais de quatro enfermeiros homens.

Já que deve ter menos de seis e mais de quatro enfermeiros homens, é preciso ter exatamente cinco enfermeiros homens.

Assim, precisa ter não mais que nove enfermeiros, consistindo de cinco homens e quatro mulheres, e precisa ter não menos do que seis médicos homens. Então, precisa ter somente uma médica mulher para chegar ao total de 16.

Se um médico homem não está incluído, o fato 2 é uma contradição. Se um enfermeiro homem não está incluída, o fato 3 é uma contradição. Se uma médica mulher não está incluída, o fato 4 é uma contradição. Se uma enfermeira mulher não está incluída, nenhum fato se contradiz. Então, quem está falando é uma mulher e é uma enfermeira.

Posição atual da Estação Espacial Internacional

A Estação Espacial Internacional (ISS) viaja em uma velocidade média de 27,7 mil quilômetros por hora, realizando 15,7 órbitas por dia, numa altitude entre 278 km e 460 km. A estação leva até 6 minutos para cruzar o céu de um observador terrestre.

A ISS é o maior e mais brilhante objeto feito pelo homem em órbita, apresenta uma magnitude que varia de acordo com a distância à terra e com o reflexo da luz solar. Algumas estimativas apontam para um brilho de magnitude até -8, com a luz do Sol brilhando diretamente pelos painéis solares.

O site AstroViewer (http://www.astroviewer.com/), além de conter um mapa interativo do céu noturno, possui uma página que mostra a posição atual da ISS (http://iss.astroviewer.net/) e seu caminho sobre a superfície terrestre, com atualizações a cada segundo.

Neste site, também é possível especificar a localização do observador terrestre, e assim, obter uma lista das oportunidades de observação da ISS, com data, hora, duração, magnitude e direção. Tudo muito bem ilustrado através de um mapa da localização e com o caminho da ISS.

Ah! Ainda é possível gerar um código HTML para incorporar o mapa em sua página.

A observação da Estação Espacial Internacional depende de alguns fatores como altura em relação ao horizonte, reflexão da luz solar e céu noturno. As melhores condições de observação ocorrem antes do nascer do Sol e depois do pôr do Sol.

Brincadeira de adivinhar um número na calculadora

Algumas calculadoras, mesmo as simples, possuem uma funcionalidade na tecla = (igual), talvez associada à função de repetição ou função de cálculo contínuo, que quando pressionada, após a exibição do resultado de um cálculo, repete a última operação.

Para testar se a calculadora possui esta funcionalidade, por exemplo, tecle 1 + 1 e tecle = repetidamente. Se o resultado receber incrementos de 1 a cada pressionamento da tecla = então a calculadora possui esta funcionalidade.

Nestas calculadoras é possível fazer uma brincadeira de adivinhação de um número. Uma pessoa programa a calculadora, escolhendo um número de quantos dígitos desejar e passa a calculadora para outra pessoa, a qual irá descobrir o número digitando seus palpites.

Para programar a calculadora nesta brincadeira, entre com um número de quantos dígitos preferir. Um bom tamanho é um número de quatro dígitos. Divida este número por ele mesmo e tecle =. O resultado será obviamente 1. Pronto, a calculadora está programada. Não tecle mais nada e passe a calculadora para a outra pessoa.

Exemplo, sequência de teclas para programar o número 3647:

3 6 4 7 : 3 6 4 7 =

Para realizar as tentativas a pessoa deve digitar os números e teclando = após cada palpite. Se o palpite for menor que o número correto, o resultado será menor que 1 (zero vírgula alguma coisa). Se o palpite for maior que o número correto, o resultado será maior que 1 (um vírgula alguma coisa). Quando acertar o número, o resultado será exatamente 1.

Exemplo, adivinhando o número acima:

[Palpite 1] 5 5 5 5 = (a calculadora retorna 1,5232 - o palpite é maior)
[Palpite 2] 3 3 3 3 = (a calculadora retorna 0,9139 - o palpite é menor)
[Palpite 3] 3 6 4 7 = (a calculadora retorna 1 - o palpite está certo)

A brincadeira se desenvolve nestas tentativas, digitando um número e teclando =, para que o resultado se aproxime de 1. Quanto maior o número de dígitos, maior a dificuldade. Pode-se informar ao adivinhante quantos dígitos tem o número, ou não.

Ainda não encontrei uma documentação que explique esta funcionalidade das calculadoras, não é exatamente a função de cálculo contínuo pois esta função aproveita o resultado na operação seguinte. Nas tentativas, quando digita-se o palpite e a tecla =, o resultado das operações é o palpite dividido pelo número certo.

Infelizmente não é toda calculadora que aceita esta brincadeira. Nas mais simplezinhas costuma funcionar. Numa científica, toda poderosa, provavelmente não. Em uma com RPN, acredito que não.