Mensagem falsa sobre a Receita Federal pode hospedar vírus de computador

Uma mensagem eletrônica falsa, em nome da Secretaria da Receita Federal do Brasil, voltou a circular na internet. No texto, os criminosos alertam para uma suposta suspensão da declaração do Imposto de Renda, e os procedimentos a adotar. Na mensagem, consta também um link, que remete os usuários a um endereço desconhecido onde provavelmente pode estar hospedado um vírus de computador.

A Receita Federal, órgãos públicos e bancos, de maneira geral, não enviam e-mails, e quando remetem pedem antes a autorização dos usuários da internet por questões de segurança.

No caso da Receita Federal, o conselho é para que os contribuintes não abram a mensagem em hipótese nenhuma nem respondam mensagens que chegam em suas caixas postais eletrônicas em nome do órgão.

Segundo comunicado da Receita Federal, mensagens falsas permitem que quadrilhas especializadas em crimes pela internet tentam obter ilegalmente informações fiscais, cadastrais e principalmente financeiras dos contribuintes.

O método mais usado é o que induz o contribuinte a responder em páginas falsas questionários, como se fossem originados em órgãos ou entidades privadas. Outra técnica utilizada pelos criminosos é instalar, sem que o usuário saiba, vírus de computador que rouba os dados.

A Receita lista três cuidados básicos a serem seguidos para evitar acidentes de segurança em computadores:

1. não abrir arquivos anexados, pois normalmente são programas executáveis, que podem causar danos ao computador ou capturar informações confidenciais do usuário;

2. não acionar os links para endereços da internet, mesmo que lá esteja escrito o nome da RFB, ou mensagens como "clique aqui", pois não se referem Receita Federal; e

3. excluir imediatamente a mensagem.

Usuário terá de pagar por portabilidade de número

SÃO PAULO (Reuters) - O recurso da portabilidade numérica, que começa a ser implantada no Brasil em 1o de setembro, prevê que o usuário pague uma taxa sempre que quiser trocar de operadora e manter o número da linha.

Acompanhe mais detalhes do processo, que estará finalizado até 10 de março de 2009 em todo o país:

-- A taxa para manter o número da linha, que a Anatel espera que fique em algo como 10 reais, será paga sempre para a nova operadora. Os recursos servirão para custear o trabalho da entidade administradora, organização que fará o gerenciamento desse processo de uma operadora para outra. A taxa será paga de uma única vez, na fatura seguinte.

-- A portabilidade vai ser possível tanto na telefonia fixa como na móvel, mas não de uma para outra (um número de telefone fixo não poderá ser usado como de telefonia móvel, por exemplo).

-- A portabilidade numérica só pode ser feita dentro de uma mesma região. Um assinante de Brasília, por exemplo, não pode se mudar para São Paulo e esperar trazer o mesmo número da linha já que, como explica a Anatel, aquele número deve ter o seu equivalente em São Paulo e, por isso, já estar sendo usado por outro usuário.

-- As operadoras terão até 5 dias úteis para garantir a portabilidade ao usuário, a partir da sua solicitação. Esse prazo fica menor após o primeiro ano da implantação, para três dias úteis.

-- Segundo a Anatel, o consumidor pode desistir do pedido de portabilidade, se informar em até dois dias úteis. Dessa forma, receberá um número de linha novo.

-- O pedido do assinante pode ser recusado em três circunstâncias: se os dados fornecidos estiverem incorretos ou incompletos, se o número da linha estiver temporariamente indisponível ou designado para outro serviço ou se outra solicitação para o mesmo número já estiver am andamento.

-- O usuário pode carregar seu número quantas vezes quiser, desde que pague a tarifa sempre que mudar de operadora.

BRASIL LIVRE DA RUBÉOLA

Fazendo minha parte galera:

Campanha Nacional de Vacinação

Homens e mulheres entre 20 e 39 anos devem se vacinar contra a Rubéola.

Procure os centros de saúde, no período de 9 de agosto a 12 de setembro de 2008 .

Ministério da Saúde

Brasil adota sistema unificado de registro civil

O governo federal apresentou nesta terça-feira (8), durante o Encontro Nacional de Identificação, realizado em Brasília, o Cartão de Registro de Identidade Civil (RIC). O novo sistema permitirá a integração de diversos dados e inibir falsificações. O Cadastro de Pessoa Física (CPF), o título de eleitor e a carteira da Previdência Social convergirão em um único documento. O RIC começará a ser implantado em janeiro e a meta é atender toda a população em até nove anos.
A nova carteira de identidade contará com um chip microprocessador, responsável pelo armazenamento dos dados do cidadão, além de outros dispositivos modernos. Gravação a laser de informações em camadas internas do cartão e marcas d´água visíveis apenas na luz negra têm por objetivo coibir fraudes. A Polícia Federal estima que 16 milhões de documentos de identidade falsos circulem no Brasil atualmente.
A ferramenta para execução do projeto RIC foi adquirida em 2004, quando o governo investiu U$ 35 milhões no Sistema Automatizado de Identificação de Impressões Digitais (AFIS), colocado sob a responsabilidade do Ministério da Justiça.
Palestras - Com o objetivo de explicar o funcionamento e demonstrar as vantagens do novo sistema, o Encontro Nacional de Identificação, promovido pelo Departamento de Polícia Federal e Ministério da Justiça, promove esta semana diversas palestras e debates com especialistas nacionais e internacionais, em Brasília.
No local, foi criada a “cidade digital”, onde os participantes do evento poderão conhecer o funcionamento do AFIS. O mecanismo tornará o cadastramento por meio de impressões digitais mais rápido e seguro, já que unificará os banco de dados de todo o território nacional, impedindo que uma mesma pessoa possua mais de um RIC. Além disso, o AFIS vai agilizar a identificação de qualquer cidadão, auxiliando as investigações policiais. O projeto ainda prevê parcerias com órgãos regionais, criando estações de coleta por todo o País, além de facilitar o processo de centralização dos dados. Com a medida, a segunda via do documento poderá ser requisitada em qualquer unidade da Federação. A expectativa do governo é, a partir do terceiro ano de implantação, realizar 80 mil cadastramentos por dia e alcançar a meta de 20 milhões de cadastros anuais. Em nove anos, 150 milhões de brasileiros terão o seu número de RIC.

Desenho 2D em Java - A Classe Basic Stroke e outras

A CLASSE BASICSTROKE.

A classe de BasicStroke define um jogo básico de atributos para os esboços dos gráficos primitivos, os mesmos tem um rendimento com ao de um objeto de Graphics2D, onde tem seu atributo do curso ajustado ao BasicStroke.
Os atributos definidos por BasicStroke descrevem a forma da marca feita por uma pena extraída ao longo do esboço de uma forma e das decorações aplicadas nas extremidades e juntam-na de segmentos do trajeto da forma, incluindo a largura, onde a largura da pena, é perpendicular a sua medida.
Classes Principais do BasicStroke são:

java.lang.Object
java.awt.Component
java.awt.Container
javax.swing.JComponent
javax.swing.JPanel

Image

A classe Image define uma imagem gráfica simples, genérica e bidimensional. A classe Graphics (usada pelo método paint) pode desenhar imagens com o método drawImage :
Image minhaImagem;
minhaImagem = createImage(50, 50);
g.drawImage(minhaImagem, 0, 0, this);
O método drawImage recebe quatro parâmetros - a imagem, as coordenadas x e y e a referência para ela mesma através da variável especial (this). Os formatos de gravura suportados pelos browsers, os mais comuns são os que possuem extensão GIF (Graphics Interchange Format) e o Joint Photographic Experts Group (JPEG). Essas imagens podem demorar um tempo para serem descarregadas.

import java.applet.*;
import java.awt.*;
public class draw_image extends Applet {
Image img;
public void init() {
img = getImage(getCodeBase(), "cow.gif");
}
public void paint(Graphics g) {
g.drawImage(img, 0, 0, this); } }
// Adiciona imagens
Formas, fontes e cores
Os recursos gráficos como formas, fontes e cores são utilizados a partir da classe java.awt, que proporciona o melhor acabamento visual da linguagem Java.
A maioria das operações básicas de desenho é composta de métodos definidos na classe Graphics. Não é necessário criar um objeto "Graphics" para desenhar algo, basta lembrar que um dos argumentos do método paint() é um objeto Graphics, como é demonstrado logo abaixo no exemplo que vai nos acompanhar por todo esse capítulo, demonstrando todo o processo de criação de um mapa da Flórida:

import java.awt.Graphics;
import java.awt.Polygon;
public class Map extends java.applet.Applet {
public void paint(Graphics screen) {
screen.drawString("Florida", 185, 75);
. . . . . . .} }

Esse applet usa o método drawString() do objeto screen para desenhar o string "Flórida" nas coordenadas 185,75. Assim como acontece com drawString(), todos os métodos de desenho possuem argumentos que indicam coordenadas x, y. Alguns exigem mais do que um conjunto de coordenadas, como uma linha que possui uma coordenada x, y para identificar seu ponto inicial e outra para seu ponto final. Lembrando que todos os valores em pixel são inteiros, não podendo ser usados números decimais para apresentar algo entre os valores inteiros.

Linhas

O método drawLine() é usado para desenhar uma linha entre dois pontos. O método recebe quatro argumentos: as coordenadas x e y do ponto inicial e as coordenadas x e y do ponto final. A espessura da linha fica fixa em 1 pixel. Será inserida a seguinte linha no código do Map:

screen.drawLine(185, 80, 222, 80);

Retângulos

Para desenhar um retângulo normal, use o método drawRect para os contornos e o método fillRect para as figuras preenchidas. Esses métodos recebem os seguintes argumentos - coordenadas x e y do canto superior esquerdo do retângulo, a largura e a altura do retângulo. Insira a seguinte instrução no applet:

screen.drawRect(2, 2, 345, 345);

Os retângulos cm cantos arredondados exigem os métodos drawRoundRect() e fillRoundRect() que recebem os quatro primeiros argumentos que os normais, com dois argumentos incluídos no final que definem a largura e a altura da área onde os cantos são arredondados, insira a seguinte instrução no applet:

screen.drawRoundRect(182, 61, 43, 24, 10, 8);

Polígonos

Podem ser desenhados com os métodos drawPolygon() e fillPolygon(), onde são necessárias as coordenadas x, y de cada ponto. São considerados como uma série de linhas unidas, onde ficam declarados o início e o fim de cada uma. Adicione as seguintes instruções ao método paint() do applet Map para ver os polígonos em ação :

int x[] = { 10, 234, 253, 261, 344, 336, 295, 259, 205, 211,
195, 191, 120, 94, 81, 12, 10 };
int y[] = { 12, 15, 25, 71, 209, 278, 310, 274, 188, 171, 174,
118, 56, 68, 49, 37, 12 };
int pts = x.length;
Polygon poly = new Polygon(x, y, pts);
screen.drawPolygon(poly);

Elipses

Essa forma segue a mesma novela das formas anteriores, possui os métodos drawOval() e fillOval() usados para desenhar círculos e elipses, possuem os quatro argumentos que definem as coordenadas x e y, a largura e a altura. Inclua as seguintes instruções para o applet:

screen.fillOval(235,140,15,15);
screen.fillOval(225,130,15,15);
screen.fillOval(245,130,15,15);
Exemplo - Formato de uma carinha através dos círculos preenchidos

Arcos

De todas as formas de desenho, os arcos são os mais complexos de se construir, possuindo seis argumentos - as coordenadas x e y, a largura e a altura da elipse, o ângulo em que se deve iniciar o arco e o número de graus percorrido pelo arco. Verifique a sintaxe para esses métodos através do código completo do programa Map.java :

import java.awt.Graphics;
import java.awt.Polygon;
public class Map extends java.applet.Applet {
public void paint(Graphics screen) {
screen.drawString("Florida", 185, 75);
screen.drawLine(185,80,222,80); //linha
screen.drawRect(2, 2, 345, 345);//retângulo
screen.drawRoundRect(182,61,43,24,10,8);//retangulo arredondado
int x[] = { 10, 234, 253, 261, 344, 336, 295, 259, 205, 211,
195, 191, 120, 94, 81, 12, 10 };
int y[] = { 12, 15, 25, 71, 209, 278, 310, 274, 188, 171, 174,
118, 56, 68, 49, 37, 12 };
int pts = x.length;
Polygon poly = new Polygon(x, y, pts);
screen.drawPolygon(poly);
screen.fillOval(235,140,15,15);//círculo preenchido
screen.fillOval(225,130,15,15);
screen.fillOval(245,130,15,15);
for (int ax = 50; ax < 150; ax += 10)
for (int ay = 120; ay < 320 ; ay += 10)
screen.drawArc(ax, ay, 10, 10, 0, -180);//Arco
}
}
Exemplo- Utilização das formas através de um mapa

Textos

Os objetos da classe java.awt.Font são usados para se utilizar o método drawString() com diferentes fontes. Os objetos Font representam o nome, o estilo e o tamanho em pontos de uma fonte. Outra classe, FontMetrics, fornece métodos para se determinar o tamanho dos que caracteres que estão sendo apresentados com uma fonte específica, o que pode ser usado para detalhes com formatação e centralização do texto.
Um objeto fonte é criado enviando-se três argumentos para o seu construtor :

Nome - pode ser específico como as fontes internas da linguagem Java: TimesRoman, Helvetica, Courier, Dialog e DialogInput;
Estilo - podem ser definidos como Font.PLAIN, Font.BOLD e Font.ITALIC;
O tamanho em pontos da fonte.
As fontes apresentam, portanto, a seguinte sintaxe :
Font f = new Font("Dialog", Font.ITALIC, 36);
Depois é só definir a fonte atual através do método setFont() que segue a sintaxe:
screen.setFont(f);
O applet SoLong apresenta um string no centro da janela Applet, usando FontMetrics para medir a largura do string com a fonte atual

import java.awt.Font;
import java.awt.Graphics;
import java.awt.FontMetrics;
public class SoLong extends java.applet.Applet {
public void paint(Graphics screen) {
Font f = new Font("Courier", Font.BOLD, 18);
FontMetrics fm = getFontMetrics(f);
screen.setFont(f);
String s = "So long, and thanks for all the fish.";
int x = (size().width - fm.stringWidth(s)) / 2;
int y = size().height / 2;
screen.drawString(s, x, y);
}
}

Utilização das fontes através do applet SoLong

O método size() pode não estar compatível com a versão 1.2, se durante a compilação ou execução do programa houver alguma rejeição referente a esse método, basta substituí-lo pelo método getSize().
Cores
As classes Color e ColorSpace do pacote java.awt pode ser usadas para tornar seus applets e aplicativos mais coloridos. Com essas classes, podem ser definidas a cor atual e ser usada nas operações de desenho, bem como a cor de fundo de um applet e de outras janelas. Também podem ser convertidas uma cor de um sistema de descrição de cores para outro.
Por definição, Java usa cores de acordo com um sistema de definição de cores chamado RGB ( essas letras provém das palavras Red, Green e Blue). Cada um dos três componentes pode ser representado por um inteiro de 0 a 255. Como será visto posteriormente no quadro de cores.
A cor atual do desenho é designada pelo método setColor() da classe Graphics. Uma forma de definir a cor é usando uma das cores padrão disponíveis, como as variáveis de classe na classe Color que apresentam os seguintes parâmetros :

black(0,0,0)
blue(0,0,255)
cyan(0,255,255)
darkGray(64,64,64)
orange(255,200,0)
pink(255,175,175)
gray(128,128,128)
red(255,0,0)
green(0,255,00)
white(255,255,255)
yellow(255,255,0)
lightGray(192,192,192)
Tabela -- Cores para applets

A instrução a seguir define a cor atual do objeto screen usando as variáveis de classe padrão:
screen.setColor(Color.orange);
Para criar um objeto cor com definições próprias, deve ser introduzido um código semelhante a esse:
Color novacor = new Color(255,204,102);
screen.setColor(novacor);

O método setBackground() define a cor de fundo de uma janela e o método setForeground() altera a cor de um componente de interface como um botão ou uma janela. Esses métodos recebem como argumento o objeto cor.
setBackground(Color.blue);

Ex:
import java.awt.*;
import java.awt.event.*;
public class janelaDesenho2 extends Frame {
private final int startPos = 50;
private int incremento = 15;
private int tamanho = 40;
class WindowHandler extends WindowAdapter {
public void windowClosing(WindowEvent we) {
dispose();
System.exit(0);
}
}
public janelaDesenho2() {
setTitle("Janela e desenho 2");
setSize(320,200);
addWindowListener(new WindowHandler());
}
public void paint(Graphics g) {
int x=startPos;
int y=startPos;
Dimension d = getSize();
int finalPos = Math.min(d.width, d.height)-tamanho;
Graphics2D g2 = (Graphics2D) g;
g2.setStroke(new
BasicStroke(10.0f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
g2.drawString("Desenhando...", 10, 40);
while (x < finalPos) {
g2.setColor(new Color((float)Math.random(),
(float)Math.random(),
(float)Math.random()));
g2.drawRect(x, y, tamanho, tamanho);
x += incremento;
y += incremento;
}
g2.setFont(g.getFont().deriveFont(Font.BOLD));
g2.setColor(Color.red);
g2.drawString("...pronto!", 100, 40);
}
public static void main(String[] args) {
janelaDesenho2 j = new janelaDesenho2();
j.setVisible(true);
}
}

import java.awt.*;
import java.awt.event.*;
public class janelaDesenho2 extends Frame {
private final int startPos = 50;
private int incremento = 15;
private int tamanho = 40;
class WindowHandler extends WindowAdapter {
public void windowClosing(WindowEvent we) {
dispose();
System.exit(0);
}
}
public janelaDesenho2() {
setTitle("Janela e desenho 2");
setSize(320,200);
addWindowListener(new WindowHandler());
}
public void paint(Graphics g) {
int x=startPos;
int y=startPos;

Dimension d = getSize();
int finalPos = Math.min(d.width, d.height)-tamanho;
Graphics2D g2 = (Graphics2D) g;

g2.setStroke(new
BasicStroke(10.0f, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
g2.drawString("Desenhando...", 10, 40);
while (x < finalPos) {
g2.setColor(new Color((float)Math.random(),
(float)Math.random(),
(float)Math.random()));
g2.drawRect(x, y, tamanho, tamanho);
x += incremento;
y += incremento;
}
g2.setFont(g.getFont().deriveFont(Font.BOLD));
g2.setColor(Color.red);
g2.drawString("...pronto!", 100, 40);
}
public static void main(String[] args) {
janelaDesenho2 j = new janelaDesenho2();
j.setVisible(true);
}
}