Lista de sites não recomendados

[]‘s

The post Procon SP atualiza lista de lojas online não recomendadas appeared first on 0fx66.

——————————————————————————–

CRIPTOGRAFIA RSA
ALGORITMOS E IMPLEMENTACOES

By RoOtLiQuiD
rootliquid@m…
www.motdlabs.org

——————————————————————————–

————-
INDICE:
————-

1.0 :: INTRODUÇÃO CHATA QUE NINGUÉM LÊ …………………………. LINE 39
2.0 :: Breve comentário sobre Curvas Elípticas ………………….. LINE 100
3.0 :: Introdução ao RSA ……………………………………… LINE 128
4.0 :: Funcionamento do RSA …………………………………… LINE 212
4.1 :: Gerando as chaves ……………………………………… LINE 220
4.2 :: Encriptando …………………………………………… LINE 283
4.3 :: Desencriptando ………………………………………… LINE 308
4.4 :: Resumo do funcionamento do RSA ………………………….. LINE 325
5.0 :: Breve Comentário sobre “DELAYED CODES” …………………… LINE 360
6.0 :: SOURCE CODES ………………………………………….. LINE 403
6.1 :: Simple RSA in C ……………………………………….. LINE 432
6.2 :: Simple RSA in LISP …………………………………….. LINE 720
6.3 :: COMPLETE RSA IN C USING GNU MP LIBRARY …………………… LINE 907

——————————————————————————–
1.0 :: INTRODUÇÃO CHATA QUE NINGUÉM LÊ
——————————————————————————–

Como vc já deve saber, a criptografia eh a arte de transformar informações em MULHER, ou seja, algo que você realmente não consegue entender. Existem dois tipos de criptografia, a chamada Criptografia Simétrica, e
Assimétrica.

——————————-
..:: Criptografia Simétrica :
——————————-

Durante a primeira guerra mundial o cientista Gilbert Vernam inventou um método para esconder as mensagens enviadas às tropas.

Uma palavra ou frase qualquer aleatoriamente escolhida servia de chave para esconder qualquer texto. O método era bem simples, as duas pessoas que queriam se comunicar deveriam ter essa mesma chave, e cada vez que uma fosse enviar um
texto para a outra, deveria ser feita uma operação lógica de XOR da chave com o texto, assim os dados do texto ficavam “misturados” com a chave, não sendo possível distinguir os dois. Para decifrar o texto, a outra pessoa deveria
possuir a mesma chave, bastando para isso apenas fazer o XOR novamente no texto cifrado fazendo-o virar novamente o texto original.

Esse método é chamado de simétrico porque os dois lados da comunicação precisam ter a mesma chave, exatamente igual, tanto para encriptar, quanto para desencriptar. Isso é um grande problema pois você precisa entregar essa chave de
modo seguro a pessoa certa, pois qualquer um que tiver a mesma chave poderá decifrar a mensagem. Apesar disso, ainda hoje ele é usado, pois com esse método podemos encriptar dados em O(1), pois basta uma operação (XOR) para cada bit a
ser encriptado, no método assimétrico a coisa já eh bem diferente…

Para gerar chaves para criptografia simétrica existem muitos algoritmos como o DES, MD5, SHA, etc…
Particularmente quem se interessar pode dar uma olhada no algoritmo SKIPJACK da NSA, veja mais em: http://www.tropsoft.com/strongenc/skipjack.htm ou procure no google: Skipjack NSA algorithm

———————————
..:: Criptografia Assimétrica :
———————————

Nela, você tem duas chaves, uma chamada de chave pública, que é usada apenas para encriptar os dados e com ela não eh possível desencripta-los, e uma chave chamada de privada, que eh usada para desencriptar os dados. Nesse método você
entrega para a outra pessoa a sua chave pública para que ela possa te mandar mensagens cifradas com a sua chave.

Para você mandar mensagens cifradas para a outra pessoa você precisa da chave pública dela, e vice-versa. Na criptografia assimétrica os dados não são encriptados com XOR, mas sim com cálculos matemáticos, e por isso encriptar uma grande quantidade de dados com esse método pode ser muito lento.

A criptografia RSA usa o método assimétrico, eu vou explicar como funciona, mas antes um breve comentário sobre as Curvas Elípticas (que também usam o método assimétrico).

——————————————————————————–
2.0 :: Breve comentário sobre Curvas Elípticas
——————————————————————————–

Atualmente o que há de mais avançado em cifragem de dados eh a criptografia baseada em Curvas Elípticas. O único algoritmo que conheço que usa isso, chama-se ECC.

Para o RSA, o tamanho do problema é o tamanho do módulo que deve ser fatorado. Já nas curvas elípticas, o tamanho do problema é o número de pontos N no grupo em que se está trabalhando.

A segurança das curvas elípticas se baseia na intratabilidade do problema do logaritmo discreto em grupos aritméticos definidos sobre os pontos de uma curva elíptica (Caraio! Foda hein!). Oferece o mesmo nível de segurança que os
sistemas baseados em corpos de inteiros como o RSA, mas com tamanho de chave menor.

Um ECC de 160 bits equivale a um sistema RSA de 1024 bits (Putz!!!).

Para mais informações sobre Criptografia baseada em Curvas Elípticas acesse:http://www.lockabit.coppe.ufrj.br/downloads/academicos/ECCMono.pdf Ou então digite no google Criptografia+Curvas+Elípticas

——————————————————————————–
3.0 :: Introducao ao RSA
——————————————————————————–

O algoritmo RSA foi inventado pelos professores do MIT: Ronald L. Rivest, Adi Shamir, e Leonard Adleman em 1977.

A empresa RSA Security que originalmente era controlada pelos inventores, detêm a patente do algoritmo. Mas pelo que eu sei essa bosta de patente só é válida nos EUA, portanto pode ficar tranquilo que o FBI não vai bater à sua
porta porque vc fez um programa que usa esse algoritmo!

Leia mais sobre essa patente em: http://www.cyberlaw.com/rsa.html
Ah, eu ouvi dizer que essa patente expirava em junho de 2000, só que eu não consegui achar nada que confirmasse… Se alguém souber ….

Como já foi dito, o RSA usa criptografia assimétrica. Para que haja segurança nesse método, devemos ter um algoritmo que gera uma chave pública e uma privada de modo que seja impossível (ou quase, hehe) de determinar a chave
privada mesmo sabendo a chave pública.

Para isso, a chave pública eh gerada através de uma “one-way function“, uma função matemática onde dado uma certa entrada é relativamente fácil de determinar o resultado, porém sabendo o resultado, é praticamente impossível
determinar a entrada.

Matematicamente falando: dado X, computamos F(x) facilmente, porém, dado F(x), é impossível computar X.
Funções não inversíveis são um exemplo de uma “one-way function“.

No caso do RSA, a função usada é a multiplicação de dois números primos. Dae, você deve estar pensando: “mas essa função eh inversível, se eu fatorar o resultado eu acho os dois números primos”. Pois eh, isso funciona se tivermos
números pequenos, como 7 e 13, que dá 91. Se dividirmos 91 por todos os primos anteriores vamos acabar descobrindo que 91/13 dah 7 e não sobra resto, o que quer dizer que encontramos a entrada (7 e 13).

Apesar dessa função ser inversível, se multiplicarmos números primos muito grandes, a quantidade de números que precisaremos testar para descobrir a entrada vai ser tão grande, que torna esse trabalho impraticável. Por isso, para
que essa função seja segura, devemos estar certos de que os dois números escolhidos são realmente primos e que sejam números muito grandes.

Por exemplo, quando dizemos que estamos trabalhando com uma chave de 1024 bits no RSA, isso quer dizer, que a chave pública tem 1024 bits, ou seja, precisamos de 1024 bits para representar o número que foi gerado pela multiplicação dos dois primos, portanto cada número primo deveria ter 512 bits.

Para se ter uma ideia, um número de 1024 bits é da ordem de 1 x 10^308 na representação decimal, imagine quantos números antes desse devemos testar para encontrar os dois números primos que o geraram!!! Com o computador que está na
sua frente agora, você levaria mais tempo do que a idade do universo para conseguir fatorar esse número, heheheh que exagero, na verdade eu não sei quanto tempo levaria, mas seria tanto tempo que mesmo com os computadores mais modernos
existentes, fatorar esse número seria uma tarefa quase impossível. O problema, é que com a computação quântica, o poder computacional seria aumentado muito, pois seria possível fazer vários cálculos ao mesmo tempo usando os vários estados que podem ter um qbit.

Certamente a criptografia atual não eh páreo para a computação quântica. Um cálculo que no computador comum poderia levar milhares de anos para ser concluído, com um processador quântico esse tempo pode ser reduzido para algumas horas.

Para tentar driblar esse problema de fatorar uma multiplicação de dois números primos existem algoritmos e teoremas que otimizam e diminuem o trabalho, não sendo preciso testar o número com todos os primos anteriores, porém ainda
assim não foi encontrada uma fórmula que consiga fatorar números grandes de forma suficientemente eficiente para que ameace a criptografia atual.

Na prática para se fazer um sistema de criptografia seguro que usa o RSA, você vai enfrentar 3 problemas principais:

1. Como pegar dados verdadeiramente aleatórios, para gerar os números primos.
2. Como saber se um número qualquer é realmente primo.
3. Como fazer cálculos numéricos com números de representação maior que 32 bits.

Mais a frente isso será explicado.

——————————————————————————–
4.0 :: Funcionamento do RSA
——————————————————————————–

O algoritmo RSA é muito simples, ele usa apenas 3 fórmulas matemáticas, uma para gerar as chaves,uma para encriptar, e outra para desencriptar.

————————————————–
4.1 :: Gerando as chaves
————————————————–

Primeiro devemos gerar a chave publica e a privada, essa é a parte mais complicada. Para gerar as chaves devemos ter dois números primos aleatórios P e Q.

———————–
..:: A chave pública:
———————–

A chave pública é composta por dois números, N e E. O número N é a multiplicação dos dois números primos P e Q:

N = P * Q

Para calcular o número E, precisamos ainda calcular outro número que vai nos auxiliar, o número PHI. Que é calculado pela multiplicação dos dois primos menos 1, veja:

PHI = (P-1)*(Q-1)

O número E deve ser calculado de maneira que o MDC (máximo divisor comum) entre E e PHI seja 1, ou seja, de maneira que E seja relativamente primo de PHI. O número E deve satisfazer a condição:

MDC( E, PHI ) == 1

Para conseguir fazer isso, vamos ter que usar algumas gambiarras matemáticas.

OBS: O número E , sempre resulta num número pequeno (com um pequeno # de bits) como 3, 17, 50003 e etc..

A chave pública são apenas os números E e N, o PHI não deve de maneira nenhuma ser fornecido, pois com ele geramos o número D que é a chave privada.

———————–
..:: A chave privada:
———————–

A chave privada eh composta pelo número D e o N também. O número D eh o número que multiplicado por E, módulo PHI, eh igual a 1, ou seja:

O número D deve satisfazer a condição:

( E*D ) % PHI == 1

O D é também chamado de o inverso de E módulo PHI. No código exemplo eu calculo isso usando o “Bizarre Extended Euclidian Algorithm” ;-) Mas eu não sei bem como esse treco funciona, eu só peguei o algoritmo no google e usei! hehehe, eu sou um geek não um matemático pervertido! Veja mais em: http://www.grc.nasa.gov/WWW/price000/pfc/htc/zz_xeuclidalg.html

————————————————–
4.2 :: Encriptando
————————————————–

Para encriptar qualquer tipo de dados, seja texto, imagem ou o que for, você deverá transformar tudo em números, trabalhando com 32 bits, fica fácil de fazer isso, basta pegar 4 bytes de cada vez dos dados que você quer encriptar. O número deve ser sempre unsigned long.

Para encriptar uma mensagem qualquer, convertemos ela em um número M, e fazemos o seguinte cálculo:

Mensagem encriptada (C) é igual a (Mensagem Original elevado a E) módulo N:

C = M^E mod N

Devemos fazer isso para todos os pedaços da mensagem. Se dividirmos uma mensagem de 20 bytes em 5 partes de 4 bytes, devemos fazer isso 5 vezes e guardar separadamente o número encriptado que foi gerado.

Veja que na encriptação usamos os dois números gerados para a chave pública, o N e o E.

————————————————–
4.3 :: Desencriptando
————————————————–

Para desencriptar a mensagem basta fazer o seguinte cálculo:

Mensagem Original é igual (Mensagem Encriptada elevada a D) módulo N.

M = C^D mod N

Depois de feito isso vc terá o número M original que faz parte da mensagem. Veja que para desencriptar precisamos saber o número D gerado para a chave pública e o N.

————————————————–
4.4 :: Resumo do que acabou de ser dito
————————————————–

Gerando as chaves:

Chave Pública: E e N
Chave Privada: D e N

N = P * Q
PHI = (P-1)*(Q-1)

E satisfaz a condição: MDC( E, PHI ) == 1
D satisfaz a condição: ( E*D ) % PHI == 1

Encriptando:

C = M^E mod N

Desencriptando:

M = C^D mod N

Observe que para desencriptar você precisa saber o número D, e para saber o número D você precisa saber o número PHI, e para saber o número PHI vc precisa saber os primos P e Q. Portanto, esses números não devem de forma alguma serem revelados para terceiros. Obtendo quaisquer um dos números D, PHI, P e Q vc pode desencriptar a mensagem.

Na chave pública, é distribuído apenas os números E e N, o método mais comum para se atacar uma criptografia RSA é tentar fatorar o número N (que é conhecido) nos dois números primos P e Q para que assim se possa gerar a chave
privada D.

——————————————————————————–
5.0 :: Breve Comentário sobre “DELAYED CODES”
——————————————————————————–

Deve-se notar que o tempo de processamento necessário para encriptar é muitas vezes menor do que o tempo necessário para desencriptar. Isso se deve por que na desencriptação, elevamos um número grande C ao expoente D que também
é um número grande, enquanto na encriptação elevamos um número grande M ao expoente E, que como vimos anteriormente, é um numero pequeno, portanto o cálculo é muito mais rápido. Essa característica do RSA é pervertidamente aproveitada para gerar os chamados “DELAYED CODES“.

Quando surge um novo vírus, rapidamente os fabricantes de antivírus criam um código para detectá-lo e depois de algum período de tempo, todos os computadores infectados serão curados, o “DELAYED CODE” é usado para prolongar
o período de tempo que os computadores ficam infectados.

Para que o antivírus não detecte o vírus pode-se mudar partes do código do vírus ou alguma característica do vírus após 2 meses por exemplo. Mas nesse caso o antivírus poderia ter duas versões da vacina, sendo uma com o código
modificado, aí é que entra o Delayed Code. Para esconder o código fará a modificação basta criptografá-lo de maneira que demore 2 meses (ou qualquer período de tempo) para descriptografar.

Usando o RSA, encripta-se n vezes o código a ser escondido, e coloca-se a chave privada junto do código original do vírus, usando a chave privada o próprio vírus pode descriptografar o código escondido, ou ainda, os próprios fabricantes de antivírus podem descriptografar, porém, levará 2 meses para conseguir isso, pois o código foi encriptado n vezes e terá que ser descriptografado o mesmo número de vezes, como o tempo de encriptação eh muitas vezes menor do que o de desencriptação, isso torna possível gerar um código que leva algumas horas ou dias para criptografar mas leva meses para descriptografar. Com isso, consegue-se atrasar a análise do código do vírus
para que este possa ter mais tempo para infectar computadores.

Essa é a ideia básica do Delayed Code, para saber mais detalhes leia: http://z0mbie.host.sk/dpgn_eng.txt

——————————————————————————–
6.0 :: SOURCE CODES
——————————————————————————–

Os tópicos seguintes trazem códigos de programas que eu fiz para implementar a criptografia RSA de 3 maneiras.

Na primeira ( 6.1 ) eu fiz de maneira simples usando apenas as funções aritméticas padrão do C e sem otimizar nada, por isso é lento e não consegue gerar chaves RSA maiores que 32 bits, e gera números primos aleatórios (devem
ser definidos com #define antes).

Na segunda ( 6.2 ) eu fiz usando os mesmos algoritmos usados na 6.1, ou seja, sem otimização nenhuma, mas eu fiz em LISP e por isso podemos usar a aritmética de precisão infinita que a própria linguagem tem, e portanto podemos
gerar chaves RSA maiores que 32 bits, mas eu reparei que chaves maiores q 64 bits deixam os cálculos muiiiiiito lerdos.

Na terceira eu fiz em C e usei a biblioteca GNU MP( http://www.swox.com/gmp/ ). Por isso podemos usar chaves de qualquer tamanho e eu usei funções da
biblioteca para gerar os números primos aleatórios. Além disso, por ter todos os cálculos otimizados pela própria biblioteca, o programa consegue gerar chaves de 2048 bits por exemplo e encriptar/desencriptar os dados rapidamente.

————————————————–
6.1 :: Simple RSA in C
————————————————–

/******************************************************************************/
/* SIMPLE RSA IN C */
/* BY RoOtLiQuId */
/******************************************************************************/
/* */
/* NESTA VERSAO EU IMPLEMENTEI O RSA BEM SIMPLES DE MANEIRA QUE FIQUE FACIL */
/* DE ENTENDER */
/* NAO USEI NENHUMA BIBLIOTECA, E POR ISSO A MAIOR CHAVE RSA QUE PODEMOS TER */
/* VAI SER DE 32 BITS DEVIDO A LIMITACAO DA ARITMETICA PADRAO DA LINGUAGEM C */
/******************************************************************************/
#include <stdlib.h>
#include <stdio.h>
#include <math.h>

#define ULONG unsigned long long
#define LONG long long

/* como nao ensinei um jeito de achar numeros primos,
aki vao 2 numeros primos predefinidos*/
#define PRIMO1 17863
#define PRIMO2 17851

typedef struct RSA_PublicKEY {
ULONG N;
ULONG E;
} RSA_PublicKEY;


typedef struct RSA_KEY {

/* Private Key : */ ULONG D;

RSA_PublicKEY publicKey;

} RSA_KEY;


/******************************************************************************/
/* Aqui se faz o calculo do "modular inverse of an integer when that integer */
/* is relatively prime to the modulus" */
/* hehehehe, ou seja: */
/* Devemos achar D tal que : ( E*D ) % PHI == 1 */
/* Portanto usamos o Fuckin Bizzarre "Extended Euclidian Algorithm" */
/*Veja mais em http://www.grc.nasa.gov/WWW/price000/pfc/htc/zz_xeuclidalg.html*/
/******************************************************************************/
ULONG RSA_extend(ULONG E, ULONG PHI) {
LONG q, u2, u3, v2, v3, t2, t3;

u2 = 0;
u3 = (LONG)PHI;
v2 = 1;
v3 = (LONG)E;

while (v3 != 0)
{
q = u3/v3 ;
t2 = u2 - q * v2;
t3 = u3 - q * v3;

u2 = v2;
u3 = v3;

v2 = t2;
v3 = t3;
}
printf("u2 = %d u3 = %d\n", u2, u3);

if (u2 < 0)
return (ULONG)u2 + PHI;
else
return (ULONG)u2;
}

/******************************************************************************/
/* Calculo do GREATEST COMMON DIVISOR */
/* ou seja, Maior Divisor Comum ou MDC */
/******************************************************************************/
ULONG RSA_GCD( ULONG e, ULONG PHI ) {
ULONG a, great;

if (e > PHI) {
while (e%PHI != 0) {
a = e%PHI;
e = PHI;
PHI = a;
}
great = PHI;
} else {
while (PHI%e != 0) {
a = PHI%e;
PHI = e;
e = a;
}
great = e;
}
return great;
}

/******************************************************************************/
/* Calculo necessario para encontrar o E da formula: */
/* E satisfaz a condição: MDC( E, PHI ) == 1 */
/******************************************************************************/
ULONG RSA_tofindE( ULONG PHI, ULONG P, ULONG Q ) {
ULONG great;
ULONG e;

great = 0;
e = 2;

while (great != 1) {
e = e + 1;
great = RSA_GCD(e,PHI);
}
return e;
}


/******************************************************************************/
/* Aqui vamos usar os numeros primos PRIMO1 e PRIMO2 definidos lah em cima */
/* para gerar as chaves publicas e privadas */
/******************************************************************************/
void RSA_generateKey( RSA_KEY * key ){
ULONG P, Q, PHI;

P = PRIMO1 ;

Q = PRIMO2 ;

PHI = (P - 1) * (Q - 1);
key->publicKey.E = RSA_tofindE( PHI, P, Q );
key->publicKey.N = P * Q;
key->D = RSA_extend( key->publicKey.E, PHI );


printf( "PHI %u ", PHI );
printf( " N %u ", key->publicKey.N );
printf( " E %u ",key->publicKey.E );
printf( " D %u ",key->D );
printf( "\n\n" );
}

/******************************************************************************/
/* Funcao usada para encriptar um numero ULONG data */
/* precisamos apenas da chave publica */
/* */
/* Cripted = Message^E mod N; */
/******************************************************************************/
ULONG RSA_PublicEncrypt( ULONG data, RSA_PublicKEY publicKey ){
ULONG C, F, i;


/* Metodo ruin:
C = (ULONG)pow(data, publicKey.E) % publicKey.N;

Este metodo eh ruin pois vc vai elevar um numero grande a outro muito
grande e depois com esse resultado vai fazer um modulo pelo numero N
Ao inves de fazer assim, podemos simplismente fazer um loop onde vamos
multiplicando o numero por ele mesmo e jah vai fazendo modulo por N
Assim economizamos precisao, pois nunca teremos um numero super
gigantesco, ele vai ficar sempre no maximo do tamanho de N
*/

if ( publicKey.E % 2 == 0) {
C = 1;
F = (data*data) % publicKey.N;

for ( i = 1; i <= publicKey.E/2; i++) {
C = (F*C) % publicKey.N;
}

} else {
C = data;
F = (data*data) % publicKey.N;

for ( i = 1; i <= publicKey.E/2; i++) {
C = (F*C) % publicKey.N;
}

}


printf( " %u Encripted is:", data );
printf(" %u \n", C );

return C;
}


/******************************************************************************/
/* funcao usada para desencriptar um numero ULONG C */
/* Precisaremos da chave privada */
/* */
/* Message = Cripted^D mod N */
/******************************************************************************/
ULONG RSA_PrivateDecrypt( ULONG C, RSA_KEY key ){
ULONG G, F;
ULONG i;

/* metodo Ruin:
G = (ULONG)(pow( C, key.D )) % key.publicKey.N;
pelo mesmo motivo anterior
*/

if ( key.D % 2 == 0) {
G = 1;
F = (C*C) % key.publicKey.N;
for ( i = 1; i <= key.D/2; i++) {
G = (F*G) % key.publicKey.N;
}
} else {
G = C;
F = (C*C) % key.publicKey.N;
for ( i = 1; i <= key.D/2; i++) {
G = (F*G) % key.publicKey.N;
}
}

printf( " %u Decripted is:", C );
printf( " %u \n\n", G );

}

/* Fuckin Main Function */
int main(){

RSA_KEY key; /* declaracao da nossa chave */

printf("\n");

RSA_generateKey( &key ); /* Geramos a chave */

/* Encriptamos o numero 123456789 */
ULONG c = RSA_PublicEncrypt( (ULONG)(123456789), key.publicKey );

/* Pegamos o numero encriptado e descriptografamos para ver se fica
igual ao inicial */
RSA_PrivateDecrypt( c, key );

printf("\n");

return 0;
}
/******************************************************************************/
/* END OF SIMPLE RSA IN C */
/******************************************************************************/

--------------------------------------------------
6.2 :: Simple RSA in LISP
--------------------------------------------------


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; SIMPLE RSA IN LISP ;;
;; By RoOtLiQuId ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;;
;; ESTA VERSAO ESTA IMPLEMENTADA DE FORMA BEM SIMPLES, MAS O LISP USA ;;
;; ARITMETICA ABITRARIA POR PADRAO, POR ISSO PODEMOS GERAR CHAVES RSA DE ;;
;; QUAISQUER TAMANHOS DE BITS: 512, 1024, 2048, MAS EU PERCEBI QUE CHAVES ;;
;; MAIORES QUE 64 BITS FAZEM OS CALCULOS FICAREM MUITO LENTOS, POIS NESSA ;;
;; IMPLEMENTACAO EU NAO OTIMIZEI NADA ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Esquema do RSA: ;;
;; Chave P?blica: E e N ;;
;; Chave Privada: D e N ;;
;; ;;
;; N = P * Q ;;
;; PHI = (P-1)*(Q-1) ;;
;; E satisfaz a condi??o: MDC( E, PHI ) == 1 ;;
;; D satisfaz a condi??o: ( E*D ) % PHI == 1 ;;
;; ;;
;; Encriptando: ;;
;; C = M^E mod N ;;
;; ;;
;; Desencriptando: ;;
;; M = C^D mod N ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; findE_helper
;;; Desc: Funcao auxiliar de findE
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun findE_helper ( phi p q great e )
(if (= great 1)
(- e 1)
(findE_helper phi p q (GCD e phi) (+ e 1) )
)
)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; findE
;;; Desc: Funcao usada para encontrar o valor de E que satizfaz a
;;; condicao MDC( E, PHI ) == 1
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun findE ( phi p q )
(findE_helper phi p q 0 2 )
)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; extend_helper
;;; Desc: Funcao auxiliar de extend
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun extend_helper( e phi u2 u3 v2 v3 )
(let ( (q (floor (/ u3 v3 ) ) ) )
(let ( (t2 (- u2 (* q v2 ) ) )
(t3 (- u3 (* q v3 ) ) )
)

(if (not (= t3 0) )
(extend_helper e phi v2 v3 t2 t3 )
(if (< v2 0)
(+ v2 phi)
v2
)
)
)
)
)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; extend
;;; Desc: Funcao baseada no extended euclidian algorithm para
;;; encontrar D tal que D satisfaz a condi??o: ( E*D ) % PHI == 1
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun extend( e phi )
(extend_helper e phi 0 phi 1 e )
)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; expt_mod_helper
;;; Desc: Funcao auxiliar de expt_mod
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun expt_mod_helper( x y n k )
(if (= y 1)
k
(expt_mod_helper x (- y 1) n (mod (* k x ) n ) )
)
)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; expt_mod
;;; Desc: Funcao gambiarra matematica usada pra fazer x^y % n
;;; sem precisar calcular o valor de x^y, pois esse valor poderia
;;; ser muito alto.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun expt_mod( x y n )
(expt_mod_helper x y n x )
)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; encript
;;; Desc: Funcao usada para encriptar um dado numero com a chave
;;; publica E e N previamente calculada
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun encript ( number e n )
;(mod (expt number e) n)
(expt_mod number e n )
)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; decript
;;; Desc: Funcao usada para desencriptar um dado numero com a chave
;;; privada D e N previamente calculada
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun decript ( number d n )
;(mod (expt number d) n)
(expt_mod number d n )
)


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; chamadas e calculos:
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;Numeros Primos definidos
(setf P 1021 )
(setf Q 2689 )


(setf N (* P Q) )

(setf PHI (* (- P 1 ) (- Q 1 ) ) )
(setf E (findE PHI P Q ) )
(setf D (extend E PHI ) )


'Encriptando_o_numero_1234567
(setf enc (encript 1234567 E N ) )

'Decriptando
(setf dec (decript enc D N ) )

'resultado
dec



(quit)

————————————————–
6.3 :: COMPLETE RSA IN C USING GNU MP LIBRARY
————————————————–

/******************************************************************************/
/* COMPLETE RSA IN C USING GNU MP LIBRARY */
/* BY RoOtLiQuId */
/******************************************************************************/
/* NESTA VERSAO EU USO A GNU MP LIBRARY PARA FAZER OS CALCULOS COM PRECISAO */
/* ABITRARIA, OU SEJA, PODEMOS FAZER CALCULOS COM NUMEROS MAIORES QUE 64 BITS */
/* PORTANTO DAH PRA FAZER RSA COM CHAVES BEM GRANDES, 512, 1024, */
/* 2048 BITS E MAIORES */
/* */
/* PARA SABER MAIS E BAIXAR A GNU MP ENTRE EM: */
/* http://www.swox.com/gmp/ */
/******************************************************************************/
/* */
/* OBSERVACOES: */
/* Esse programa pode usar qualquer quantidade de bits para */
/* gerar as chaves RSA */
/* Ele apenas encripta e desencripta um numero qualquer com o tamanho maximo */
/* de bits da chave RSA */
/* Para encriptar um texto ou um arquivo qualquer voce vai ter que fazer uma */
/* funcao que quebre o texto ou arquivo em varios pedacos e codifique esses */
/* pedacos em numeros que serao encriptados, de forma que posteriormente esses*/
/* numeros possam ser convertidos novamente no texto ou no arquivo original */
/* */
/* Se eu tiver tempo, depois vou fazer uma versao completa que pode encriptar */
/* e descriptar qualquer arquivo ou texto ou outro tipo de dados */
/******************************************************************************/

#include <stdio.h>
#include <gmp.h>
#include <stdlib.h>

typedef struct RSA_PublicKEY {
mpz_t N;
mpz_t E;
} RSA_PublicKEY;

typedef struct RSA_KEY {

/* Private Key : */ mpz_t D;

RSA_PublicKEY publicKey;

} RSA_KEY;


/******************************************************************************/
/* Gerar os dois numeros primos randonomicos */
/******************************************************************************/
void genRandomPrimes( mpz_t* prime1, mpz_t* prime2, char* seed_num,
unsigned long int seed_tick, unsigned int keySize )
{
gmp_randstate_t state;
mpz_t rand_number;
mpz_t seed;


mpz_init ( rand_number );
gmp_randinit_default( state );

printf( "%s", seed_num );

if( mpz_init_set_str (seed, seed_num, 10) != 0 ){
printf( "Erro fazendo mpz_init_set_str \n" );
exit(0);
}

if( seed_tick <=0 )
seed_tick = 1;
mpz_mul_ui( seed, seed, seed_tick );


gmp_randseed( state, seed );

mpz_urandomb( rand_number, state, keySize/2 );
mpz_nextprime( *prime1, rand_number);

mpz_nextprime( *prime2, *prime1);


gmp_randclear( state );
mpz_clear( seed );
mpz_clear( rand_number );

}


/******************************************************************************/
/* Calcular o E */
/******************************************************************************/
void toFindE( mpz_t* PHI, mpz_t* e )
{
mpz_t great;

mpz_init_set_ui ( great , 0 );
mpz_set_ui ( *e, 2 );


while ( mpz_cmpabs_ui( great, 1) != 0 ) {
mpz_add_ui ( *e, *e, 1);
mpz_gcd ( great, *e , *PHI);
}

mpz_clear( great );
}

/******************************************************************************/
/* Calcular o D */
/******************************************************************************/
void extend( mpz_t* E, mpz_t* PHI, mpz_t* D) {
mpz_t q, u2, u3, v2, v3, t2, t3;
mpz_init( q );
mpz_init( u2 );
mpz_init( u3 );
mpz_init( v2 );
mpz_init( v3 );
mpz_init( t2 );
mpz_init( t3 );


mpz_set_ui (u2, 0);
mpz_set (u3, *PHI);
mpz_set_ui (v2, 1);
mpz_set (v3, *E);


while ( mpz_sgn( v3 ) != 0 )
{
mpz_cdiv_q ( q, u3, v3);

mpz_set (t2, u2);
mpz_submul (t2, q, v2); /* t2 = t2 - q times v2. */

mpz_set (t3, u3);
mpz_submul (t3, q, v3); /* t3 = t3 - q times v3. */

mpz_set (u2, v2);
mpz_set (u3, v3);

mpz_set (v2, t2);
mpz_set (v3, t3);
}

if ( mpz_sgn( u2 ) < 0)
mpz_add ( *D, u2, *PHI);
else
mpz_set (*D, u2);

mpz_clear( q );
mpz_clear( u2 );
mpz_clear( u3 );
mpz_clear( v2 );
mpz_clear( v3 );
mpz_clear( t2 );
mpz_clear( t3 );
}



/******************************************************************************/
/* Gerar a chave, sem verificar se eh uma chave que funciona */
/******************************************************************************/
void makeKey( RSA_KEY* key, char* seed_num,
unsigned long int seed_tick, unsigned int keySize )
{
mpz_t prime1, prime2, prime1b, prime2b;
mpz_t PHI;


mpz_init ( prime1 );
mpz_init ( prime2 );
mpz_init ( PHI );
mpz_init ( key->publicKey.N );
mpz_init ( key->publicKey.E );
mpz_init ( key->D );



genRandomPrimes( &prime1, &prime2, seed_num, seed_tick, keySize );

printf( "Prime1 = %s \n", mpz_get_str (NULL, 10, prime1) );
printf( "Prime2 = %s \n", mpz_get_str (NULL, 10, prime2) );



/* N = P * Q */
mpz_mul ( key->publicKey.N, prime1, prime2);
printf( "N = %s \n", mpz_get_str (NULL, 10, key->publicKey.N) );



/* PHI = (P-1)*(Q-1) */
mpz_init ( prime1b );
mpz_init ( prime2b );
mpz_sub_ui( prime1b, prime1, 1);
mpz_sub_ui( prime2b, prime2, 1);
mpz_mul ( PHI, prime1b, prime2b );
mpz_clear( prime1b );
mpz_clear( prime2b );
printf( "PHI = %s \n", mpz_get_str (NULL, 10, PHI) );




/* E satisfaz a condição: MDC( E, PHI ) == 1 */
toFindE( &PHI, &key->publicKey.E );
printf( "E = %s \n", mpz_get_str (NULL, 10, key->publicKey.E) );



/* D satisfaz a condição: ( E*D ) % PHI == 1 */
extend( &key->publicKey.E, &PHI, &key->D );


printf( "D = %s \n", mpz_get_str (NULL, 10, key->D) );




mpz_clear( prime1 );
mpz_clear( prime2 );
mpz_clear( PHI );
}




/******************************************************************************/
/* Encriptar */
/******************************************************************************/
void publicEncrypt( mpz_t data, RSA_PublicKEY publicKey, mpz_t cripted )
{
mpz_powm ( cripted, data, publicKey.E, publicKey.N);
}

/******************************************************************************/
/* Decriptar */
/******************************************************************************/
void publicDecrypt( mpz_t cripted, RSA_KEY key, mpz_t data )
{
mpz_powm ( data, cripted, key.D, key.publicKey.N);
}




/******************************************************************************/
/* Gerar a chave, e verificar se eh uma chave que funciona, se nao for, */
/* gera outra aumentando o seed_tick */
/* Eu tive que fazer isso, pois a funcao que gera os dois numeros primos pode */
/* errar, ela nao eh 100% confiavel, ela pode gerar um numero que nao eh primo*/
/* e o algoritmo do RSA soh funciona quando os dois numeros sao primos */
/* verdadeiros, por isso temos que testar se a chave funciona */
/******************************************************************************/
void InitAndMakeValidKey( RSA_KEY* key, char* seed_num, unsigned int keySize )
{
unsigned long int seed_tick = 1;
mpz_t data, cripted, decripted;


mpz_init( cripted );
mpz_init( decripted );
mpz_init_set_str( data, "12345", 10);

do{
makeKey( key, seed_num, seed_tick, keySize );

publicEncrypt( data, key->publicKey, cripted );
publicDecrypt( cripted, *key, decripted );

seed_tick++;
}while( mpz_cmp( data, decripted ) != 0 );
}









/* Fuckin Main Function */
int main()
{
/* OBS: a random seed deve ser uma string de um numero bem grande */
/* O melhor seria pedir pro usuario entrar com um numero aleatorio */
#define RANDOM_SEED "9423477068029340805793923728080760045047333655414855309485"

/* Tamanho em BITS da chave RSA */
#define KEY_SIZE 1024


RSA_KEY key;
InitAndMakeValidKey( &key, RANDOM_SEED, KEY_SIZE );
mpz_t data, cripted, decripted;

mpz_init( cripted );
mpz_init( decripted );

/* Inicializar os dados que serao encriptados */
mpz_init_set_str( data, "55555555555555555555555555555555555555555555", 10);


printf( "\n\n\n" );
printf( "N = %s \n", mpz_get_str (NULL, 10, key.publicKey.N) );
printf( "DATA = %s \n", mpz_get_str (NULL, 10, data) );

/* encriptar */
publicEncrypt( data, key.publicKey, cripted );
publicDecrypt( cripted, key, decripted );

/* decriptar */
printf( "CRIPTED = %s \n", mpz_get_str (NULL, 10, cripted) );
printf( "DECRIPTED = %s \n", mpz_get_str (NULL, 10, decripted) );

return 0;
}


/******************************************************************************/
/* END OF COMPLETE RSA IN C USING GNU MP LIBRARY */
/******************************************************************************/

The post Criptografia RSA – Algoritmos e Implementações appeared first on 0fx66.

FLISOL? Que diabos é isso?

O Festival Latino Americano de Instalação de Software Livre – FLISol é um evento internacional, realizado anualmente, e que ocorre de forma simultânea em diversas cidades da América Latina. O Flisol é um evento descentralizado, onde diversas comunidades organizam e realizam seu festival, de forma voluntária, tendo como principal objetivo promover o uso de software livre, apresentando sua filosofia, alcance, avanços e desenvolvimento ao público em geral.

O Flisol acontece, historicamente, no 4º sábado de abril (em 2006 foi no 25 de março; em 2007, 28 de abril; 2008, 26 de abril; 2009 e 2010, no dia 24 de abril; 2011, no dia 9 de abril; 2012, no dia 28 de abril). O Flisol 2013 está marcado para o dia 27 de abril.

O evento é gratuito e aberto a todo o público: curiosos, interessados e amantes do Software Livre. Nesse dia os voluntários propõe a instalação de Software Livre, como distribuições de Gnu/Linux, sistemas BSD, e aplicativos livres para Windows em geral. Alguns eventos também contam com palestras, oficinas, sala de degustação e gravações de mídias (live-CD/DVD e/ou pendrives).

Aonde vai ser nesse ano?

IESB OESTE – Ceilândia Norte QNN 31 – Áreas Especiais B/C/D/E – Ceilândia – DF, aqui o mapa.

Quando vai ser?

Vai ser 27 abril 2013 das 09 às 17 horas xD

Mais informações aqui.

Vejo vocês lá :)

The post FLISOL DF 2013 appeared first on 0fx66.

Podemos encontrar outros benchmarks aqui e aqui também!

Até o momento tive boas experiências utilizando mongoDB.

[]‘s

The post CouchDB vs MongoDB appeared first on 0fx66.

O termo shuhari tem origem nas artes marciais, e a principal e mais utilizada forma de aprendizado neste campo. Que significa:

• Shu: obedecer/protejer;
• Ha: romper/modificar;
• Ri: separar/superar;

Só pelo significado podemos observar que ela é segmentada em três pontos ou etapas.

Na primeira etapa o shu, o aprendiz deve apenas observar e repetir o que foi visto, repete o movimento/ação nos mínimos detalhes sem questionamentos, pois o importante nesta etapa é obter uma base dos movimentos ou seja ter um ponto de partida. Por exemplo um karateca vai repetir o kata igual ao demonstrado pelo seu sensei.

Na segunda etapa o ha, o discípulo começa a questionar aqueles movimentos que foram aprendiz na etapa anterior, pensa na real motivação daquele movimento/ação ou seja vai começar a pensar. Por exemplo é realizado um movimento durante a execução é o karateca vai pensar na necessidade daquele golpe dentro do kata, entender a aplicação dele dessa forma ele começa a entender por que aquele golpe e desferido naquela etapa do katar e qual o próximo golpe que melhor se encaixa naquele katar.

Na terceira é etapa o ri, também chamada de etapa da transcendência, e onde com base na experiência, princípios, instintos o aprendiz deixa de ser um aprendiz e agora é um mestre de si mesmo, não mais repetindo o caminho do mestre, mas definindo o seu próprio.

Como podem observar esta metodologia pode muito bem aplicada para o aprendizado de programação, matemática, física, filosofia entre outras ciências.

Referências:

http://techbot.me/2011/05/criando-um-programador/
http://www.cao.pt/surya/jc_5_1.htm

[]‘s

The post Aprendo utilizando a técnica shuhari appeared first on 0fx66.

Anda rolando um meme entre os desenvolvedores pela internet a fora, onde ele descrevem o seus ambientes de desenvolvimento. Até o momento ninguém me convidou mas como sou um bom intrometido então vamo que vamo :)

Sistema Operacional/Máquina

Meu sistema operacional oficial e o Ubuntu, sou ex-slacker, estou utilizando a versão 10.10 dele com o ambiente XFCE (ahh XFCE me acompanha desde os tempos do slackware 11…), meu notebook é um humilde Lenovo modelo g475, sua configuração bastante modesta: AMD Vision Dual-Core C50, 8GB ram DDR3, 50GB, Gravador de DVD, Leitor de Cartões de 14”. Costuma me atender bem, já que desenvolvimento de verdade uso o desktop.

O meu desktop com AMD Phenom 2 x4 925 (2.8Ghz com overclock em 3.7Ghz), sua placa-mãe e uma ASUS M4N68T-M LE, 16GB de memória DDR3 (4x pente Kingston DDR3 1333), 2TB de HD (com um Seagate 2.0TB 5900RPM), minha VGA é uma AMD/ATI Radeon Hd4850.

Como puderam notar uso um kit AMD completo, o notebook está com xubuntu 12.10, e no desktop tem slackware 14 com windows 7 em dual boot (para os jogos hehe).

Editor

Vim: Uso o vim para editar qualquer texto simples ou programar em C/C++, asm e shellscript.

Geany: Venho usando cada vez mais o geany para programa em C/C++, encontrei essa IDE ano passado e a apresentei aos meus amigos de faculdade que buscavam uma alternativa ao Dev-C++ no Linux, acabei me apaixonando pelo geany e sua simplicidade.

Eclipse: Sinto muito amantes do netbeans, mas o eclipse e melhor (lá vem os flames) como ganho a vida desenvolvendo na plataforma Java não tem IDE melhor para esta tecnologia que o eclipse, utilizo ele combinado com o subeclipse e Jboss tools consigo produtividade várias vezes superior ao netbeans.

Browser

Meu navegador oficial e o Firefox, utilizo diversas extensões (já fiz uma lista das extensões que uso, aqui), o meu navegador alternativo é o Chromium ou o opera.

Terminal e Workspaces

Uso o bash, trabalho com 2 monitores simultaneamente além do notebook, então as vezes fico meio perdido kkkk

Controle de versão

Uso o SVN para os sistemas java e o git para os pessoaos, para compartilhar arquivos (pdf, teses, monografias, textos em geral com outras pessoas) uso o 4shared ou hospedo via ftp aqui no blog mesmo.

Música

Uso o amarok, até hoje não encontrei nenhum player superior ao amarok, com posso organizar de forma simples e rápida minhas playlist além de integra-lo com o mySQL (futuramente irei escrever um texto explicando como fazer isso) para deixá-lo ainda mais veloz :)

Outros

Uso o freemind para criar mapas mentais, gFTP para acessar FTP, nmap, wireshark, netcat além dos obrigatórios (ping, tracerout, whois, ssh), quando programando em C uso o GDB em conjunto com valgrind para poder encontrar vazamentos de memória, o Astah para trabalhar com UML.

[]‘s

The post Meu ambiente de desenvolvimento em 7 itens appeared first on 0fx66.

Sim não leram errado! Estou abandonando os serviços da Google. Tomei esta decisão depois do fim do seu serviço de leitura de feeds, o ultimamente tão aclamado Google Reader. Foi para min um choque da mesma forma que a morte do Google Wave, sendo este um serviço que eu utilizava muito, em especial quando precisava lidar com projetos em equipe a distância. A Google nunca valorizou o Reader como deveria. Ele contava com recursos sociais que eram muito bons, e que forma removido na reformulação deste.

O anuncio do fim do Reader pegou todo mundo surpresa, os usuários deste ficaram boquiaberto, causam uma certa repercussão pela internet afora, no dia posterior foram surgindo enumeras alternativas, algumas bastante bonitas como o feedly outras alternativas como o Tiny Tiny RSS que permitiam maior liberdade para os usuários. Mas nenhuma me agradou, tentei até utilizar o Thunderbird (sim ele também lê RSS, como também é um ótimo cliente para chat do Facebook), acabei começando a utilizar o liferea, sendo este o que mais me agradou.

Com o fim do Reader, comecei a repensar algumas coisas, principalmente quando ao buzz da cloud computing, conforme já descrevi nesta publicação, a cloud computing e bastante perigosa e precisar ser utilizada com cuidado…

Tomei a decisão de abandonar o uso de serviços em nuvem, vou abandonando o uso de pouco em pouco, primeiro abandonei o meu Gmail e Calendar, estou utilizando o e-mail da minha hospedagem mesmo, até que eu compre um servidor e o deixe operacional na minha casa.

Quando ao serviço de buscas resolvei da seguinte forma: montarei um script para realizar as buscas em vários buscadores, as vezes quando o Google cai (sim isso já aconteceu) fiquei praticamente perdido, então quero obter maior independência de serviços de busca, eis o motivo pelo qual trabalhei em um script desses, caso tenha algum interessado em participar do projeto iniciarei ele dentro de alguns dias no meu github.

The post Por que estou abandonando os serviços da Google appeared first on 0fx66.

Um vídeo muito bem produzido e contando com excelentes argumentos, minha ao vídeo critica só vai pela ausência da conversão dos valores para a mesma moeda, entretanto essa conversão pode realizada com facilidade por qualquer um, basta pegar a cotação do dia em algum site (como esse ou esse) e faze-la de cabeça mesmo.

Mesmo que no brasil tive-se a mesma qualidade em serviços públicos que o Canadá tem estaríamos pagando muito caro, um valor absurdo!

Mas a questão que proponho para debate neste tópico não é somente o custo com impostos, mas o por que os impostos são tão altos? O primeiro culpado disso é a maquina estatal que é super inchada, e muito pouco eficiente com gastos astronômicos.

Na mesma semana que o Brasil aumentou o número de Ministérios para 39, a China cortou para 25. #Acorda_Brasil

— Ricardo Amorim (@Ricamconsult) 15 de março de 2013

Um uma entrevista publicada recentemente na Folha de São Paulo. Ele explica exatamente por que é uma burrice trabalhar com esse tanto de ministérios. Mas é claro isso não é burrice, o governo é bastante esperto, pois assim ele obtém mais poder, influência atrás dos cabides de empregos. É nos da população é claro tomamos no #$%*$3#w.

Se não bastasse da quantidade de ministérios que o governo tem, ainda possui um número enorme de cargos de confiança, que muitas vezes não fazem nada só servem para aumentar o poder e influência do governo, o número de cargos de confiança no Brasil chega a ser 3 (três) vezes maior que no EUA!

Se não bastasse a máquina estatal inchada, temos um alto índice de corrupção, o Brasil ocupa a posição 68, é no mesmo ranking temos países com o Chile e Uruguai ocupando a 20º posição!

O outro fator é a população burra, que não discute política como deveria, discutem ela como se fosse futebol, como se fosse uma torcida ao invés de debate de forma séria sem fanatismos, por exemplo vemos petistas fanáticos defendendo José Dirceu e outros mensaleiros (que diga-se de passagem falou esses tempos um dos maiores absurdos sobre a lei da ficha limpa). O fanatismo politico chegou a um ponto tão grande que as pessoas se esquecem que o cara é um corrupto total, um mensaleiro condenado pelo STF, como e possível o cara receber um tratamento desses?

Fontes: Dispostas no corpo do texto.
[]‘s

The post Por que o Brasil tem tantos ministérios e tantos impostos? appeared first on 0fx66.

Abstract

We analyze the five remaining AES candidate algorithms MARS, RC6, Rijndael, Serpent, and Twofish as well as DES, Triple DES, and IDEA by examining independently developed Java implementations. We give performance measurement results on several platforms, list the memory requirements, and present a subjective estimate for the implementation difficulty of the algorithms. Our results indicate that all AES ciphers offer reasonable performance in Java, the fastest algorithm being about twice as fast as the slowest.

Resumo

Neste artigo escrito por Andreas Sterbenz foi realizada uma analise sobre a performance, uso de memória, dificuldade na implementação dos candidatos ao AES.

Para ler o artigo clique aqui.

The post Performance dos algoritmos candidatos a AES implementados em Java appeared first on 0fx66.

1. “Network.dnsCacheExpiration” tipo inteira com valor 3600
2. “network.dnsCacheEntries” tipo inteira com valor 1000

Se você não usa ipv6, e interessante que altere a chave “network.dns.disableIPv6” mude para true. Reiniciei o firefox é você irá notar uma significativa melhoria no desempenho.

[]‘s

The post Otimizando requisições DNS no firefox appeared first on 0fx66.

No texto anterior expliquei com utilizava a função pow() para calcular potencias, e apresentei a função sqrt() e cbrt() para calcular raiz quadrada e cubica. Vou apresentar hoje uma dica de como calcular raízes usando a função pow(), existem momento onde precisamos calcular indices maiores que 2 e 3 nesses casos usamos a função pow().

Declaração: pow(radicando, 1/indice);

Sim e simples assim, podemos calcular qualquer raiz dessa forma.

Código exemplo:

//calcula raiz com pow()
#include <stdio.h>
#include <math.h>

int main() {
	
	double raiz,radicando,indice;

	printf("Digite o radicando: ");
	scanf("%lf",&radicando);

	printf("Digite o indice da raiz: ");
	scanf("%lf",&indice);

	//Calculo da raiz usando pow
	raiz=pow(radicando, 1/indice); //Aqui esta a magica!!! 

	printf("A raiz de %lf com indice %lf = %lf\n",radicando,indice,raiz);

	return 0;
}

Nota: Esta função só trabalha com valores double, caso não use variáveis do tipo double os resultados poderão ser desastrosos.Para evitar o bug da linkagem use o parâmetro “-lm” ao compilar.

[]‘s

The post Calculando raízes em C usando a função pow appeared first on 0fx66.

Uma dúvida bastante comum para quem é iniciante em C, como calcular potencias em c? Para calcular potencias usamos a função pow() que está contida na lib math.h, que e uma lib muito rica em funções para trabalhar com cálculos matemáticas, a função pow() calcula a base elevada à uma potencia. Para efetuamos cálculos de raiz quadrada usamos a função sqrt() calcula a raiz quadrada de um número.

Potencias

Em C existe uma função, a pow(), que realiza a exponenciação de um número por outro.
Declaração: pow(base,expoente)

Código exemplo:

#include <stdio.h>
#include <math.h>
int main() {
	//codigo de exemplo para a execucao da funcao pow()
	int base,expoente,resultado;

	printf("Digite a base: ");
	scanf("%d", &base);

	printf("Digite o expoente: ");
	scanf("%d",&expoente);

	//efetua a exponenciacao.
	resultado=pow(base,expoente);

	printf("O numero %i elevado a %i e igual a %i",base,expoente,resultado);

	return 0;
}

Observação: No gcc pode apresentar erro ao compilar o programa acima!

Adicione o parâmetro “-lm” indica que a lib math.h seja linkada ao binário, o parâmetro dependera do seu compilado, no meu caso e para quem usa o GCC o -lm resolverá este problema.

Raiz quadrada e Cubica

Para trabalhos com raízes temos duas opções a função ,e através da função sqrt() que também exige o uso da lib math.h.

Declaração:sqrt(radicando);

Código exemplo:

#include <stdio.h>
#include <math.h>

int main() {
	int radicando,raiz;

	printf("Digite o radicando: ");
	scanf("%i",&radicando);

	raiz = sqrt(radicando); //Aqui esta a magica!!!

	printf("A raiz quadrada de %i e igual a %i\n",radicando,raiz);

	return 0;
}

Para calcular a raiz cubica usando a função cbrt()

Declaração: cbrt(radicando);

Código exemplo:

#include <stdio.h>
#include <math.h>

int main() {
	int radicando,raiz;

	printf("Digite o radicando: ");
	scanf("%d",&radicando);

	raiz = cbrt(radicando); //Aqui esta a magica!!!

	printf("A raiz quadrada de %i e igual a %i\n",radicando,raiz);

	return 0;
}

Nota: e necessário usar o parâmetro “-lm” ao compilar os códigos acima com o gcc.

[]‘s

The post Trabalhando com potencias e raiz quadrada e cubica em C appeared first on 0fx66.

.:: Introdução ::.

Procuro abordar aqui o funcionamento de um sniffer, os riscos que este pode trazer a uma rede, alguns truques que invasores usam para oculta-lo e também formas de detecção. Ao longo do artigo, usarei a palavra ‘invasor’ quando me referir a pessoa que esta ‘sniffando’ uma rede que não seja sua. ‘Invasor’ neste caso, serve para hackers, crackers e kiddies. Vale lembrar, no entanto, que as diferenças entre os termos são enormes. Hackers são pessoas com conhecimento avançado, que estão sempre em busca de mais conhecimento, compartilham suas descobertas e seguem uma ética; Crackers violam sistemas com intenções maliciosas, causando problemas aos seus alvos; Kiddies são pessoas que não tem conhecimento técnico, apenas usam ferramentas criadas por outros como forma de conseguir seus 15 minutos de fama. Este eh um texto básico, portanto se você já eh ‘fera’, não espere encontrar algo novo por aqui.

.:: O que são Sniffers? ::.

Sniffers (farejadores) são dispositivos (podem ser programas ou algum hardware especifico) que capturam (a maioria também analisa) o trafego de uma rede de forma passiva,isto é, sem interferir nas comunicações, podem ser utilizados tanto por administradores como por invasores, obviamente com propósitos diferentes. Administradores podem usar um sniffer para detectar, ou pelo menos ajudar a detectar, a causa de um problema, assim como gerar logs do trafego da rede que podem ser consultados posteriormente caso necessário (devido ao comprometimento de uma maquina, por exemplo). Já invasores podem utiliza-lo para capturar informações confidenciais que circulem em ‘texto-puro’, ou seja, não criptografadas. Qualquer informação não criptografada, incluindo logins e senhas de serviços como FTP, Telnet e POP, estará acessível ao invasor. Usar criptografia é altamente recomendável, porem não impede totalmente o acesso por parte do invasor as informações.

.:: Como Funcionam ::.

Para entender o funcionamento dos sniffers, precisamos entender o funcionamento das redes. Aqui sera abordado o padrão Ethernet, o mais utilizado hoje em dia. Cada computador em uma rede Ethernet tem o seu endereço de hardware, o MAC (Media Access Control). O MAC, um número hexadecimal de 12 dígitos, único em toda a rede (teoricamente não existem duas placas de rede com o mesmo MAC), é utilizado para identificar as maquinas. Em cada pacote enviado, logo no começo, podemos encontrar dois endereços MACs, o endereço do computador que enviou o pacote, e o endereço do computador que deve recebe-lo.

Na verdade, todos os computadores da rede recebem os pacotes (salvo se a rede utilizar switches – isto sera abordado mais adiante), mas só responderão a pacotes destinados a elas, ou seja, apenas responderão caso o pacote em questão tenha o seu endereço MAC como destinatário; caso não possua, o pacote sera descartado(isso é feito a nível de hardware – interface de rede). Se conseguirmos fazer com que a interface não descarte os pacotes, poderemos capturar todo o trafego da rede! É assim que um sniffer funciona, ele faz com que a interface de rede aceite todos os pacotes. Quando uma interface se encontra nesta condição, dizemos que esta em ‘modo promiscuo’, estado que geralmente pode-se habilitar via software.

Na maioria dos sistemas operacionais atuais, para por uma interface de rede em modo promiscuo, deve-se ter privilégios de root (administrador). O sniffer pode ser utilizado com a interface em seu estado normal, mas neste caso só serão capturados os pacotes que tenham como origem (ou destino) o computador onde ele esta sendo executado. Pode não parecer tao interessante, mas se este computador for um roteador, o invasor terá acesso a todo o trafego que por ele passar.

Os pacotes capturados pelo sniffer geralmente são armazenados em arquivos salvos no disco rígido, para posterior analise. Em uma rede movimentada, este arquivo poderá ficar enorme, em poucas horas, o que facilitaria a detecção de um sniffer por parte do administrador. Por este motivo(e também para não perder tempo), sniffers instalados furtivamente são bem seletivos; gravam apenas o que é interessante ao invasor (geralmente logins e senhas). Como estas informações geralmente localizam-se no começo do pacote, muitos sniffers não analisam o pacote inteiro, mas apenas os seus primeiros 200-300 bytes. Outros sniffers vão ainda mais longe; enviam os logins/senhas capturados para um e-mail fornecido pelo invasor. Imaginemos a seguinte situação: Um invasor, localizado no RJ, quer interceptar a conversa pela internet de João e Maria, que estão em SP, usando um sniffer. E possível?

                         ----------------
                        /                \
                       /                  \
  ------       ----------                ----------        -------
 | João |---> | Provedor |   INTERNET   | Provedor | < --- | Maria |
  ------       ----------                ----------        -------
                       \                  /
                        \   ----------   /
                         --| Provedor |--
                            ----------
                                |
                            ---------
                           | Invasor |
                            ---------

Claro! Basta que ele consiga acesso ao computador de um dos dois (engenharia social, exploração de alguma falha, trojans…), ou a algum que esteja ‘no meio do caminho’ (Um servidor do provedor de Maria ou um roteador, por exemplo) e instale la o sniffer. O invasor pode ainda fazer com que os dados passem pelo seu computador ou seja ele redireciona o trafego. Apesar de ser muito mais trabalhoso, é possível.

.:: Sniffers em redes comutadas ::.

Logo acima foi dito que os pacotes em uma rede são distribuídos por todos os computadores; Isto é verdade se for utilizado um hub ou cabo coaxial para fazer a ligação dos PCs, mas não se for utilizado um switch (Lembrem-se que estamos falando de redes Ethernet). Os switches possuem tabelas onde são armazenados, entre outras coisas, endereços MACs encontrados em cada uma de suas portas. Por isso, o switch pode enviar os pacotes apenas para a porta onde esta o destinatário. Com isso, dificulta-se o sniffing (Porem não o torna impossível :P). Mas como o switch sabe em que porta o destinatário esta? Simples! Suponhamos que João e Maria agora estão ligados em uma rede comutada. Vejamos o que acontece se João ‘pingar’ (ICMP Echo Request) o computador de Maria.

João ---> ARP Request ---> Broadcast
João < --- ARP Response <--- Maria
João ---> ICMP Echo Request ---> Maria
João < --- ICMP Echo Response <--- Maria

O que acontece é o seguinte: João quer enviar o ICMP Echo Request (o famoso Ping) para Maria, mas para isso, ele precisa saber o endereço físico (MAC) do computador de Maria. Por isso, João ‘grita’, para todos os computadores da rede (Broadcast): “Qual o endereço MAC de Maria?”. Isto é um ARP Request (Address Resolution Protocol – o ARP traduz endereços IP para MAC). Maria então ouve o ‘grito’ de João e o responde (ARP Response). Agora que João já tem o endereço MAC, pode enviar o ‘ping’ (Echo Request), que é prontamente respondido pela Maria (Echo Response). Depois disso, caso João queira enviar mais algum pacote para Maria (e vice-versa), não precisara enviar primeiro outro ARP Request, pois o endereço MAC de Maria já sera conhecido, podendo ser localizado na cache ARP de seu PC. Quando passam ARP Requests e Responses pelo switch, este verifica de qual de suas portas o pacote foi originado e pega o endereço MAC de origem que esta escrito no pacote. Essas informações são então registradas nas tabelas do switch. Assim ele fica sabendo em que porta estão localizados cada computador, e pode repassar os pacotes apenas para a porta onde esta o destinatário do pacote. Em redes que operem nesta forma são chamadas de comutadas. Porém nem tudo são flores, e o sniffing ainda pode funcionar nestas condições. Vejamos algumas formas de fazer isso.

+ Table Flooding

Como já foi dito, o switch sabe para que porta enviar cada pacote devido a tabela que ele possui (CAM Table). (CAM) Table Flooding consiste em encher a tabela do switch com entradas falsas, para que ele passe a enviar os pacotes para todas as portas. Tabela do Switch ANTES do ataque:(apenas para ilustração, a tabela é mais ‘complexa’)

--------------------------
| Porta  |  Endereço MAC   |
|--------------------------|
|   01   |   MAC de Maria  |
|   02   |   MAC de João   |
|   ...  |       ...       |
|   10   |  MAC do Invasor |
--------------------------

Então o invasor, que quer capturar o trafego da rede, começa a enviar pacotes ARP para a rede, cada um com um endereço MAC – que não existe na rede – diferente. O switch armazena estes endereços em sua tabela, até que esta fica cheia – Sim, a CAM Table tem um limite de entradas. Tabela do Switch DURANTE o ataque:

----------------------------
| Porta |    Endereço MAC    |
|----------------------------|
|  01   | MAC inexistente 1  |
|  02   | MAC inexistente 2  |
|  ...  |        ...         |
|  10   | MAC inexistente 10 |
----------------------------

Assim, todo o pacote cujo destinatário não estiver listado na tabela do switch devera ser enviado para todas as portas. Ai, o invasor pode captura-los sem problemas. O macof é um programa que aplica esta técnica.

+ ARP Cache Poisoning

Esta técnica consiste em enviar pacotes ARP forjados para as maquinas-alvo, de forma com que todo o trafego entre elas passe pela maquina do invasor. Vejamos o caminho (normal) dos pacotes entre João e Maria:

 --------        --------        -------
|  João  | < --> | Switch | < --> | Maria |
 --------        --------        -------

Para poder sniffar o trafego entre João e Maria, o invasor envia pacotes ARP (que não requerem autenticação) para João fingindo ser Maria, e pacotes ARP para Maria fingindo ser João. Assim a tabela ARP de Maria e João fica envenenada (poisoned). Vejamos as tabelas:

Antes:

Tabela de João ANTES do ataque           Tabela de Maria ANTES do ataque
--------------------------------          --------------------------------
|  Endereço IP  |  Endereço MAC  |        |  Endereço IP  |  Endereço MAC  |
|--------------------------------|        |--------------------------------|
| IP de Maria   | MAC de Maria   |        |  IP de João   |  MAC de João   |
| IP do Invasor | MAC do Invasor |        | IP do Invasor | MAC do Invasor |
--------------------------------          --------------------------------

Durante:

Tabela de João DURANTE o ataque           Tabela de Maria DURANTE o ataque
--------------------------------          --------------------------------
|  Endereço IP  |  Endereço MAC  |        |  Endereço IP  |  Endereço MAC  |
|--------------------------------|        |--------------------------------|
| IP de Maria   | MAC do Invasor |        |  IP de João   | MAC do Invasor |
| IP do Invasor | MAC do Invasor |        | IP do Invasor | MAC do Invasor |
--------------------------------          --------------------------------

O invasor deve certificar-se que os pacotes enviados por João cheguem ao seu destinatário real, Maria, e vice-versa. Isso pode ser feito facilmente através do IP Forwarding, que é suportado por muitos sistemas operacionais. Alem disso, o invasor devera enviar regularmente novos pacotes ARP para Maria e João, pois as entradas nas tabelas ARP expiram. O caminho dos pacotes durante o ARP Poisoning:

 --------        --------        ---------        --------        -------
|  João  | < --> | Switch | < --> | Invasor | < --> | Switch | < --> | Maria |
 --------        --------        ---------        --------        -------

Com o ARP Cache Poisoning o invasor pode não somente capturar os pacotes enviados como também altera-los (assim como cria-los) antes de enviar para o verdadeiro destinatário. Imagine se o invasor se passar por um roteador…

+ ICMP Redirect

Pacotes ICMP Redirect são usados por roteadores para fazer com que os computadores enviem seus pacotes por um caminho diferente. Forjando ICMP Redirects o invasor pode alterar as tabelas de roteamento de uma maquina para que o trafego passe por ele.

+ Monitor Port (SPAN, Port Mirroring, Port Monitoring)

Muitos switches fornecem Monitor Ports, que permitem copiar todo o trafego da rede para uma (ou mais) portas. O problema – Ou solução, depende do ponto de vista – eh que muitos administradores não alteram as senhas-padrão, permitindo assim que o invasor faca com que o switch envie todo o trafego da rede para a porta em que ele esta conectado. Caso o switch suporte realizar esta configuração via SNMP, o invasor pode tentar adivinhar a senha. Mesmo que o administrador tenha configurado o switch para aceitar apenas pacotes SNMP vindos de um certo endereço IP, o invasor pode utilizar de spoofing.

+ Switch Port Stealing

Nesta técnica o invasor envia pacotes com o endereço MAC de origem da maquina-alvo. O switch então “aprende” que o invasor *eh* a maquina-alvo e passa a enviar os pacotes destinados a ela para o invasor. Temos dois problemas aih. O primeiro eh que se a maquina-alvo parar de receber os pacotes, a conexão se encerra, o outro problema é que a maquina-alvo continuara enviando pacotes, o que fara com que a tabela do switch volte ao seu estado normal. Para contornar o problema, podemos tirar a maquina-vitima da jogada(DoS) e enviar os pacotes com o MAC alterado. Assim podemos tomar conta de uma conexão já autenticada, como uma sessão Telnet. Outra possibilidade é enviar pacotes com o MAC alterado em intervalos regulares, e ao receber um pacote destinado a maquina-alvo, reenvia-lo para broadcast. Assim, a maquina-alvo continua recebendo os pacotes.

.:: Detectando Sniffers ::.

Por sua natureza passiva, a detecção de sniffers pode se tornar algo complicado. Contudo, formas de detecção existem, e podem ser divididas em duas categorias: locais e remotas. A detecção local consiste basicamente em utilizar ferramentas do sistema para verificar se existem interfaces em modo promiscuo, ou algum outro indicio da existência de sniffers na maquina. Podemos ver se uma interface esta em modo promiscuo usando o ifconfig:


bash-2.05b# ifconfig -a
eth0 Link encap:Ethernet HWaddr 00:50:56:40:2A:B9
inet addr:192.168.0.172 Bcast:192.168.0.191 Mask:255.255.255.224
UP BROADCAST NOTRAILERS RUNNING PROMISC MULTICAST MTU:1500 Metric:1
RX packets:10 errors:0 dropped:0 overruns:0 frame:0
TX packets:10 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:100
RX bytes:2282 (2.2 Kb) TX bytes:2707 (2.6 Kb)
Interrupt:10 Base address:0x10a0

lo Link encap:Local Loopback
inet addr:127.0.0.1 Mask:255.0.0.0
UP LOOPBACK RUNNING MTU:16436 Metric:1
RX packets:0 errors:0 dropped:0 overruns:0 frame:0
TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:0
RX bytes:0 (0.0 b) TX bytes:0 (0.0 b)

Repare a palavra “PROMISC” em eth0. Em maquinas Windows (NT, 2000, XP) pode-se utilizar o PromiscDetect. Outra ferramenta que pode ser utilizada é o lsof (list open files), em busca de network files abertos (sockets) ou ainda o arquivo onde o sniffer grave os dados capturados.

O problema da detecção local é que o invasor pode substituir as ferramentas como ifconfig ou ainda carregar módulos que façam o computador esconder as informações que poderiam entregar a presença do sniffer. Um checador de integridade, como o tripwire, pode ajudar a resolver o problema da alteração de binários, mas se o invasor inserir um modulo no kernel que faca o sistema mentir para você, o tripwire de nada adiantara. Existem ferramentas, como o rkscan, que podem localizar rootkits conhecidos, através de assinaturas (padrões). Novamente, o rkscan de nada adiantara contra um rootkit desenvolvido pelo próprio invasor, já que sua assinatura não constara no rkscan. E a brincadeira de gato e rato continua. A detecção remota é um processo heurístico, ou seja, o resultado não eh 100% confiável. Nesta detecção exploram-se certas características do sistema operacional e protocolos, que possam indicar a existência de um sniffer. Vejamos algumas das técnicas que IDS e ferramentas como o antisniff utilizam para tentar identificar sniffers na rede.

+ Método Ping

Sem duvida o método mais conhecido, consiste em enviar um ICMP Echo Request (ping) para a maquina a ser testada, mas com o endereço MAC diferente. Como o MAC não é o da maquina, não deve haver resposta ao ping; se houver, é porque a interface de rede não descartou o pacote, e portanto, esta rodando em modo promiscuo. Este método pode ser realizado com qualquer protocolo que gere resposta. Apesar de eficiente, pode ser contornado facilmente; de fato vários sniffers furtivos implementam uma especie de ‘filtro virtual de MAC’, que inutiliza esta técnica.

+ Método ARP

Existem basicamente duas possibilidades aqui. A primeira eh a mesma do Método Ping, só que utiliza-se o protocolo ARP. A segunda aproveita-se do ARP Cache. Lembram de como funciona isto? Se não lembram, releiam o texto, pois eu que não vou escrever novamente. Bem, o que se faz eh o seguinte: Envia-se um ARP para um endereço que não seja o de broadcast, e depois um Ping para broadcast. As maquinas que responderem o ping sem antes enviarem um ARP pedindo seu MAC *podem* te-lo obtido capturando o seu pacote ARP anterior, portanto *podem* estar executando um sniffer.

+ Honey Pot (aka Armadilha)

Honey Pots são utilizados para a detecção e estudo de ataques (apesar de existirem muitas criticas a respeito de seu uso). No caso da detecção de sniffers, pode-se enviar informações, senhas falsas na rede, simular conexões, e esperar que alguém tente usa-las. Pode ser uma boa forma de detectar um sniffer totalmente passivo.

+ DNS Reverso

Alguns sniffers realizam operações resolução reversão (Reverse DNS Lookups), isto eh, transformam endereços IP em nomes mais amigáveis (pelo menos para seres humanos normais), como google.com. Então, monitorando a utilização de resolução reversa na rede pode-se encontrar sniffers. Um exemplo pratico seria você enviar vários pings para endereços inexistentes na rede, e monitora-la, para ver se alguma maquina tenta realizar a resolução.

+ Inundacao ARP

Para sniffers em redes comutadas serem funcionais, frequentemente eles necessitarão gerar grande trafego ARP, seja para encher a tabela do switch ou para assumir o lugar de outra maquina (Man in the middle). O monitoramento do número de anúncios ARP pode revelar a existência de sniffers na rede.

+ Latência

Este método pode trazer problemas a rede, portanto deve ser empregado com cuidado, e apenas quando já existir a suspeita que uma maquina esteja executando um sniffer. Ele consiste em enviar uma grande quantidade de trafego na rede. Maquinas que não estiverem suas interfaces de rede executando em modo promiscuo não serão afetadas, apenas as que estiverem, sim. Como serão afetadas? Terão um aumento do seu tempo de resposta, devido ao fato do sniffer (a maioria) analisar todos os pacotes recebidos a fim de armazenar apenas as informações que forem interessantes. ‘Pingue’ a maquina suspeita antes de injetar grande quantidade de trafego na rede e anote o resultado. Depois, pingue novamente durante a ‘tempestade’ de pacotes. Se a diferença for grande, podemos ter um sniffer ai.

.:: Evitando o sniffing ::.

Existem formas de tornar as coisas mais complicadas para sniffers, como o uso de entradas ARP estáticas – a cache ARP não é modificada – ou o uso de Port Security, que ‘prende’ os endereços MAC a certas portas do switch, mas não são muito praticas. Existem ainda interfaces de rede que não suportam o modo promiscuo, mas são difíceis de serem encontradas. A solução mais efetiva contra sniffers é o uso de criptografia, desde que seja implementada de forma correta, com algoritmos seguros, além de ser muito mais fácil de ser administrado que as soluções anteriores.

.:: Finalizando ::.

Espero que este artigo tenha atingido seu objetivo de servir de introdução ao sniffing, um eterno (?) problema para admins. Fico devendo (mas na o garanto que farei :P) uma parte sobre sniffing de redes wireless. Ate a próxima! :>

hallz

.:: Links Relacionados ::.

http://www.packetstormsecurity.nl/sniffers/
http://stein.cshl.org/~lstein/talks/WWW6/sniffer/
http://www.linux-sec.net/Sniffer/
http://www.datanerds.net/~mike/dsniff.html
http://www.ntsecurity.nu/toolbox/promiscdetect/
http://www.securityfriday.com/ToolDownload/ScoopLM/scooplm_doc.html
http://ettercap.sourceforge.net/
http://www.oxid.it/cain.html
http://staff.washington.edu/dittrich/talks/agora/macof
http://www.robertgraham.com/pubs/sniffing-faq.html
http://www.nwo.net/osall/Methodology/Novice/Sniffer_FAQ/sniffer_faq.html
http://www.packetwatch.net/documents/papers/layer2sniffing.pdf
http://www.ebookhackers.net/kb/index.php?page=index_v1&c=15

.:: EOF ::.

The post Sniffing for Dummies appeared first on 0fx66.

-D: interfaces vistas pelo tcpdump

-c: captura c pacotes

-e: informação de camada de enlace

-A: imprime os pacotes em ASCII

-n: não resolve nomes (mostra endereços como são)

-v : modo verbose (pode-se aumenta-lo com -vv -vvv)

-x: mostra o PDU em hexadecimal

-S: mostra números de sequência em formato absoluto (por padrão o tcpdump
mostra os números relativos aos valores iniciais estabelecidos na conexão)

-s: tamanho do pacote

-t: retira a informação de timestamp do início da linha

-ttt: mostra a diferença de tempo para uma referência em us (microssegundos)
expressão – indica que pacotes devem ser mostrados (dumped) Ex.:
tcpdump -n icmp
tcpdump src <origem>
tcpdump dst <destino>
tcpdump host <máquina>

Agora vamos a algumas dicas o seu uso. Para armazenar a saída (em modo texto) em um arquivo digite:
tcpdump –c 100 > trace.txt

Com esse comando abaixo ele ira sniffar os pacotes que passam pela interface eth0:
#tcpdump -i eth0

Usando esse comando ele ira capturar todos os pacotes vindos de 192.168.0.2 (que também funciona com URL, que será explicado mais abaixo):
#tcpdump -i eth0 src host 192.168.0.2

É também e possível utiliza-lo com sites, por exemplo:
#tcpdump -i eth0 src host www.google.com

dessa forma ele ira capturar todos os pacotes que vem de www.google.com. Para verificar todo trafego que vem da porta de origem 666:
#tcpdump -i eth0 src port 666

O argumento -n evita name service queries, a resolução de DNS:
#tcpdump -n icmp

Para Scaneiar restritamente TCP ou UDP:
#tcpdump -n -t tcp or udp

Para scaneiar restritamente TCP port 22:
#tcpdump tcp port 22

Para scaneiar os dois IP (comunicação entre dois IP), excelente se o tcpdump estiver no gateway:
#tcpdump host \(10.10.100.100 and 10.10.200.200\)

Para scaneiar a porta 666 mas descarta host IP 192.168.0.1:
#tcpdump port 666 and not host 192.168.0.1

Capturando pacotes com origem em 172.25.50.1 e destino 201.XXX.XXX.XXX, com exceção da porta 666:
#tcpdump -i en1 -n src 172.25.50.1 and dst 201.XXX.XXX.XXX and port not 666.

Agora, um pouco mais chique, usando egrep – isso vai mostrar todos os seus pedidos da Web em tempo real:
#tcpdump-i eth0-Um porta-n 80 | egrep-i (GET. / | POST. / | Host:)

Se você esqueceu sua senha pop3, mas tê-lo guardado no cliente, isto também se aplica às senhas para a web, eu tenho utilizado este um lote, em vez de o “esqueci senha” mecanismo…
#tcpdump-i eth0-n port 110-A | egrep-i (user | pass)

Obtêm somente os segmentos com SYN ligado:
#tcpdump 'tcp[13] & 2==2'

Para filtrar pacotes com cabeçalhos maiores de 20 bytes:
#tcpdump 'ip[0] & 0x0f > 5'

Para filtra o 10º byte ou 9º offset (protocol field) – TCP = port 6 UDP = port 17, por exemplo:
#tcpdump ‘ip[9] = 6’

Capturar o tráfego de pacotes TCP que tenham o flag SYN ligado (ou seja apenas os pacotes de solicitações de conexão). Use o comando abaixo:
#tcpdump -i eth0 'tcp[13] & 2 == 2' –w syn.cap –c 5

Referências e links

• Site oficial do projeto.
• Guia de referência em português escrito por Ricardo Iramar dos Santos aka Agent Smith.
• http://www.ietf.org/rfc/rfc0791.txt
• http://www.ietf.org/rfc/rfc0793.txt
• Dicas aqui e aqui sobre o tcpdump
• Tradução da man page do tcpdump

[]‘s

The post Conhecendo o Tcpdump appeared first on 0fx66.

———————————–Índice————————————-

Introdução
Conteúdo:
Chipsets————-Uma visão Geral
circuitos componentes do chipset
Características
Pontes————–Ponte Norte
Ponte Sul

——————————–Introdução———————————–
Este artigo sobre Chipsets foi escrito por mim(_Dr4k0_),depois de muito esforço, Pesquisas,estudos…Este é um artigo que explica como funciona os *Chipsets* Para você que adora ou é um viciado em hardware leia que irá gostar…Porém se apenas “gosta” porém não pretende estudar mais afundo e gosta apenas do simples não recomendo..Pois irá achar um texto muito chato e monótomo. Porém é um texto bom que na minha opinião todos deveriam ler..não é grande, e você não tem nada a perder :D

——————————–Conteúdo————————————–

Chipsets:

Chipsets é um conjunto de circuitos eletrônicos montados num tablete de silício. Silício é um metal semicondutor. Chipsets são construídos com tecnologia VLSI (Very Large Scale Integration). As modernas placas de CPU trazem um chipset incorporado ou vários.O chipset engloba todos os circuitos adicionais. Por isso é também chamado de Circuito de Apoio ou Lógica Adicional.
O chipset contém circuitos de apoio ao processador as memórias as interfaces ao barramento. Esses circuitos geram os controles necessários para o trabalho do processador.

Entre os circuitos componentes do chipset, podemos citar:

-Circuito de Refresh
-Circuito de controle da memória cache
-Circuito de controle do bus de 16 bits
-circuito de controle do bus de 32 bits
-Circuito de DMA
-Circuito de IRQ

Características de Chipsets:

Memória RAM máxima que o chipset endereça.
Memória cache máxima que o chipset acessa.
Memória RAm máxima que o chipset acessa utilizando a memória cache externa L2, quando a placa-mãe possui L2 externa.
Tipos de memória RAM que o chipset acessa. Tipos de cache L2 que o chipset reconhece quando a placa mãe possui L2 externo.
Capacidade de operação com mais de um processador.
Padrões de disco rígido UDMA/33 UDMA/66 e UDMA/100.
Barramento que o chipset pode acessar como AGP USB e Firewire.
Frequência máxima de operação.
Modo de operação do baramento AGP/PCI-X.

As Principais caraterísticas de uma placa mãe estão relacionadas com o seu chipset. A diferença entre placas-mãe,está no chipset que elas utilizam. Placas-mãe de fabricantes diferentes possuem o mesmo desempenho quando utilizam o mesmo chipset. Isso é tão importante que as placas-mãe geralmente têm a marca do chipset se fose seu sobrenome. Ponte Norte e Ponte Sul são dois circuitos de grande importância para o funcionamento da placa mãe.

Ponte Norte

Esse circuito é de grande importância, ele controla o sistema, o desempenho da placa-mãe depende dele. O circuito Ponte Norte controla a memória a ponte barramento local-PCI e a ponte barramento local-AGP, em placas-mãe soquete 7 mais antigas a memória cache L2 era também controlada por esse circuito. Placas mais recentes trazem a ponte norte com dissipador de calor. Outras trazem um cooler acoplado ao dissipador(OMG!), ponte norte é um circuito de grande importância para o chipset pois faz controle da memória RAM e da memória Cache. Ele determina a quantidade máxima de memória RAM que a placa-mãe pode endereçar os padrões de memória que reconhece assim como a quantidade máxima de memória cache aceitável, cada chip utiliza uma quantidade de ciclos mínimos segundo as especificações técnicas cedidas pelo fabricantes. É possível aumentar a quantidade de pulsos de clock, conforme a configuração de wait states.

Ponte Sul

Esse circuito faz o controle de periféricos portanto é chamado de controlador de periféricos, ou seja, ele faz ponte entre o barramento PCI e o barramento ISA controla os periféricos onboard como as portas IDE 1 e IDE 2. Faz controle de barramentos externo de expansão. A ponte sul contém o controlador de DMA o controlador de interrupções a CMOS e o relógio de tempo real, o circuito super I/O controla o teclado unidades de disquete e portas serias e paralela. O super I/O está ligado a ponte sul. Em alguns chipsets as funções do super I/O estão integradas à ponte sul, em outros o circuito faz controle de outros periféricos integrados como vídeo som e modem. A ponte norte e ponte sul em alguns chipsets antigos vinham acompanhadas de dois circuitos chamados de buffers de dados entre o processador e a memória RAM chipsets atuais trazem esse circuito dentro da ponte norte

——————————————————————————–

The post O Entendo o funcionamento dos Chipsets. appeared first on 0fx66.

!AVISO!: O objetivo deste texto não é nem de longe dar todos os detalhes sobre este modelo de referência, porém fornecer uma visão básica sobre ele, permitindo a compreensão de onde entram protocolos como o TCP e o IP por exemplo, ou então sobre como os dados trafegam na rede.

=======================================
= .,ÍNDICE., =
=======================================
= =
= 1.0…Introdução =
= | =
= 2.0…Camadas =
= |-> 2.1…Aplicação =
= |-> 2.2…Apresentação =
= |-> 2.3…Sessão =
= |-> 2.4…Transporte =
= |-> 2.5…Rede =
= |-> 2.6…Enlace de dados =
= |-> 2.7…Física =
= | =
= 3.0…Exemplo prático =
= | =
= 4.0…Alegoria =
= | =
= 5.0…Os protocolos e o Modelo OSI =
= | =
= 6.0…Conclusão =
= | =
= 7.0…Referências bibliográficas =
= =
=======================================

–=[ 1.0 – Introdução

O modelo de referência OSI(Open Systems Interconnection) foi criado pela ISO (International Standards Organization) para interconexão de redes heterogêneas/sistemas abertos, visando por um fim à incompatibilidade até então enfrentada pelas redes de computadores da época.

–=[ 2.0 – Camadas

Basicamente, pode-se dividi-lo em sete camadas, classificadas de acordo com suas funções. Todo o processo de comunicação entre computadores, segue o padrão de encapsulamento, isto é, a camada de nível mais alto é encapsulada na de nível inferior. Cada camada não possui um protocolo específico, mas uma função determinada, que é preenchida por algum protocolo desenvolvido para tal.

–=–=[ 2.1 – Aplicação

Está é a camada mais superior do modelo OSI. É nela que as requisições a serviços são realizadas, como visualizar uma página web (HTTP), transferir arquivos(FTP), ou então receber e enviar emails(POP3 e SMTP). Também gerencia e administra os processos de aplicação, faz o controle de acesso, realiza o monitoramento e recuperação dos dados, etc.

–=–=[ 2.2 – Apresentação

É responsável pela interpretação e tradução dos dados vindos da camada precedente, cuidando da sintaxe das informações transmitidas. Quando se trata do receptor, as informações que vêm da camada 5 (Sessão) são preparadas na camada 6 (Apresentação) para a sua utilização por aplicativos presentes na camada 7 (Aplicação). Pode ter outras utilidades, como compressão de dados e criptografia. No caso da compressão, os dados serão descomprimidos na camada correspondente pelo receptor.

–=–=[ 2.3 – Sessão

Aqui é onde se inicia o verdadeiro processo de comunicação. A camada de sessão permite estabelecer a conexão entre computadores distintos. Ela inicia e termina a sessão de diálogo entre duas máquinas, assim como gerencia e sincroniza as informações trafegadas, também realizando a marcação dos dados para o caso de interrupção na comunicação, quando a conexão é restabelecida, sabe-se onde parou. Em outras palavras, permite que as máquinas se entendam. Fazendo uma analogia com a vida real, seria como um homem em meio a duas mulheres, administrando o momento certo de cada uma falar.

–=–=[ 2.4 – Transporte

Dentre as 7 camadas sintetizadoras do Modelo OSI, dois grupos podem ser formados. O primeiro composto pelas camadas 7, 6, 5 (Aplicação, Apresentação e Sessão respectivamente). Este primeiro grupo se preocupa apenas com os dados, não importando a maneira como estão sendo transportados. O segundo grupo, conta com as camadas 3, 2, 1 (Rede, Enlace de dados e Física respectivamente). Este grupo por sua vez, preocupa-se com a transmissão dos dados em si. Você deve ter notado a falta da camada 4 (Transporte). É ela quem interliga estes dois grupos.

A camada de transporte realiza a segmentação dos dados provenientes da camada de sessão. Após dividi-los em pacotes repassa à camada de rede. A camada de sessão estabelece a conexão, e a de transporte fornece e gerencia o canal para troca de dados. Exerce também o controle de fluxo (ordenação dos dados caso não estejam na ordem correta) e executa correção de erros, através de mensagens de recebimento do pacote. No receptor, realiza a junção dos pacotes (multiplexação) vindos da camada 3 para enviar a camada 5.

–=–=[ 2.5 – Rede

Realiza o encaminhamento dos pacotes entre redes distintas, roteando os pacotes e lidando com as adversidades que venham a surgir durante a transmissão, como congestionamentos. Portanto, faz a conversão dos endereços lógico em endereços físicos. Cabe a ela encontrar o computador destino no meio de tantos outros e controlar condições de tráfego e prioridade para o roteamento.

–=–=[ 2.6 – Enlace de dados

Também conhecida como camada de Link de Dados, tem por função pegar os pacotes fornecidos pela camada de rede e transformá-los em quadros, garantindo uma transmissão confiável através da rede. Esses quadros possuem informações pertinentes, como endereços da placa de rede do transmissor e receptor, payload (os dados em questão) e o CRC, para checar a integridade dos dados (caso não seja enviada nenhuma mensagem de sucesso no transporte, os quadros são reenviados pela camada 2). Um exemplo de protocolo que trabalha nesta camada é o Ethernet, largamente utilizado nas redes de computadores atuais.

–=–=[ 2.7 – Física

É a camada de mais baixo nível no modelo OSI, sendo o último elo de conexão entre duas máquinas. Sua função principal é fazer a conversão dos quadros que vêm da camada inferior em sinais elétricos ou luminosos (no caso das fibras ópticas), mantendo a compatibilidade com o meio de transmissão. Ou seja, a camada física faz a tradução dos quadros vindos da camada 2 em 0s e 1s e em seguida encaminha os bits através das interfaces de rede.

OBS.: A camada física não inclui o meio em que os dados trafegam, como cabos por exemplo.

–=[ 3.0 – Exemplo prático

Para facilitar o entendimento de como funciona o modelo de referência, irei propor uma situação hipotética, porém prática da utilização do mesmo para a construção de um arquitetura de rede. Lembrando que as camadas superiores são encapsuladas nas inferiores.

Supomos que um usuário gostaria de visualizar seus e-mails presentes em um servidor.

• Camada 7

O primeiro passo é abrir o cliente de e-mails, que entrará em contato com o servidor, utilizando o protocolo POP3. O ato de requisitar o servidor usando este protocolo, encaixa o mesmo na camada de aplicação do modelo OSI.

• Camada 6

A requisição feita pelo usuário usando a camada de aplicação é traduzida para uma linguagem padrão para que os dados sejam transportados.

• Camada 5

Na camada de Sessão a conexão é estabelecida com o host destino (200.124.1.66, *número fictício). Esta camada irá cuidar do diálogo entre as máquinas, interrupções na conexão, avisando o emissor caso alguma coisa aconteça.

• Camada 4

Aqui é criado o “túnel” fim-a-fim para o transporte dos dados, que serão segmentados em pacotes, e repassados para a camada 3. Protocolos que trabalham nesta camada são o TCP (Transmission Control Protocol) e UDP(User Datagram Protocol).

• Camada 3

Como sabido, esta camada é responsável pelo encaminhamento e roteamento dos pacotes, função essa exercida pelo IP (Internet Protocol) e roteadores. O ICMP(Internet Control Message Protocol) também age nesta camada, geralmente casado com o IP.

• Camadas 2 e 1

A camada 2, onde os pacotes são transformados em quadros para serem repassados a camada física, possui o Ethernet. Ele procura pelo endereço físico da interface de rede destino (MAC Adress) para então enviar os quadros, de acordo com as especificações de cabeamento e sinais elétricos.

Quando os bits chegam na interface de rede destino (placa de rede), estes percorrem o caminho inverso ao exercido na máquina emissora.

–=[ 4.0 – Alegoria

No tópico acima foi visto um exemplo prático da aplicação do modelo OSI para a construção de uma arquitetura, onde um usuário requisitou a um servidor ver os e-mails presentes no mesmo. Agora vou propor uma situação fora do mundo da informática, para quem sabe esclarecer ainda mais o funcionamento do OSI.

A Silvia Saint vai estrelar um novo filme, e precisa ir de uma cidade à outra para filmar. Por isso ela vai até a rodoviária e compra uma passagem de ônibus convencional, porque leito é mais caro. O ato de comprar a passagem, representa a camada de aplicação no modelo OSI. Ao chegar até a porta do ônibus, Silvia dá uma boa olhada no motorista, motorista dá uma boa olhada em Silvia, e então…pede a passagem dela para autenticar e suas malas para marcar. Esta é a camada de apresentação. Muito bem, começa a viagem e o ônibus se dirige até seu destino, estabelecendo a “conexão”. Aí temos a camada 5, Sessão. O ônibus não pode andar em cima do nada, para isso é preciso uma estrada, que representa o protocolo TCP ou UDP, presentes na camada 4 (Transporte). Todavia surge um problema, Silvia é a única passageira do ônibus (huhun) e está atrasadíssima para as filmagens. O motorista então tem de optar pela melhor rota para chegar até o destino. Encaixamos o IP. Caso algum imprevisto ocorra, como um pneu furado, o ICMP entra em ação, e avisa a Central Rodoviária que o ônibus quebrou. Agora, para representar as camadas remanescentes, como não encontrei nada melhor, vou utilizar o combustível do ônibus. O Ethernet cuidará para que o motorista não abasteça o veículo com Diesel ao invés de Gasolina. Fim.

–=[ 5.0 – Os protocolos e o Modelo OSI

A figura 1.0 mostra a estrutura do modelo de referência OSI. *Ilustração retirada do livro Redes de Computadores, 4ª Edição.

A figura 1.1 mostra os protocolos utilizados tanto na internet como em redes de computadores em geral. *Ilustração retirada do Wikipedia, vide referências bibliográficas.

###########################################################################################
#                                                                                         #
# Camada                                                             Nome da unidade      #
#                                                                     intercambiada       #
# ____________                                                        ____________        #
#|            |             Protocolo de aplicação                   |            |       #
#| Aplicação  |------------------------------------------------------| Aplicação  | APDU  #
#|____________|                                                      |____________|       #
# ______|_____                                                        ____________        #
#|            |             Protocolo de apresentação                |            |       #
#|Apresentação|------------------------------------------------------|Apresentação| PPDU  #
#|____________|                                                      |____________|       #
# ______|_____                                                        ____________        #
#|            |              Protocolo de sessão                     |            |       #
#|  Sessão    |------------------------------------------------------|  Sessão    | SPDU  #
#|____________|                                                      |____________|       #
# ______|_____                                                        ____________        #
#|            |             Protocolo de transporte                  |            |       #
#| Transporte |------------------------------------------------------| Transporte | TPDU  #
#|____________|            Limite da Sub-Rede de Comunicação         |____________|       #
# ______|_____      ___________________||_____________________        ____________        #
#|            |    |   PDRI = Protocolo da Sub-Rede Interna   |      |            |       #
#|   Rede     |--1-|       ******           ******            |------|   Rede     | Pacote#
#|____________|  | |       *Rede* ========= *Rede*            |      |____________|       #
# ______|_____   | |       ******           ******            |       ____________        #
#|            |  | |        PDRI                              |      |            |       #
#|   Enlace   |- 2-|       ********         ********          |------|   Enlace   | Quadro#
#|____________|  | |       *Enlace* ======= *Enlace*          |      |____________|       #
# ______|_____   | |       ********         ********          |       ____________        #
#|            |  | |        PDRI                              |      |            |       #
#|   Física   |--3-|       ********         ********          |------|   Física   | Bit   #
#|____________|  | |       *Física* ======= *Física*          |      |____________|       #
#                | |       ********         ********          |                           #
#  Host A        | |       Roteador         Roteador          |         Host B            #
#  ^^^^ ^        | |__________________________________________|         ^^^^ ^            #
#                |_________;1 Protocolo de roteador/host da camada de rede                #
#                |_________;2 Protocolo de roteador/host da camada de enlace de dados     #
#                |_________;3 Protocolo de roteador/host da camada física                 #
###########################################################################################
                                      Figura 1.0

#################################################
#            Protocolos de Internet             #
#################################################
# Aplicação   #   HTTP, SMTP, FTP, SSH, IRC,    #
#             #   SMTP, NNTP, POP3, IMAP, etc.  #
# ----------- # ------------------------------- #
# Transporte  #   TCP, UDP, SCTP, RTP, DCCP     #
# ----------- # ------------------------------- #
# Rede        #   IPv4, IPv6, ARP, ICMP         #
# ----------- # ------------------------------- #
# Ligação     #   Ethernet, 802.11 WiFi, Token  #
#             #   Ring, FDDI, PPP, etc.         #
# ----------- # ------------------------------- #
# Física      #   RS-232, EIA-422, RS-449, etc. #
#################################################
 Figura 1.1

–=[ 6.0 – Conclusão

Termino por aqui este pequeno artigo sobre o Modelo OSI. Como o próprio título do artigo propõe, foi exposto aqui apenas o básico, mas isso não significa que seja o necessário. Não se prenda e vá atrás de mais informações a respeito, dê uma olhada nos links do Referências Bibliográficas. É isso ae, qualquer coisa mail-me.

–=[ 7.0 – Referências Bibliográficas

Arquitetura OSI
http://penta.ufrgs.br/Marco/arqosi.html

Modelo de Referência OSI
http://www.forumweb.com.br/artigos/artigos.php?action=file&id=268

Entendendo os protocolos
http://www.clubedasredes.eti.br/rede0013.htm

Ethernet
http://pt.wikipedia.org/wiki/Ethernet

O Modelo OSI de Interconexão de Sistemas Abertos
http://www.teleco.com.br/tutoriais/tutorialosi/default.asp

Comunicação de dados (Normas)
http://www2.ufp.pt/~lmbg/textos/norma_osi.html#camadasois

Livro “Redes de Computadores”, 4ª Edição
Livro “Universidade H4CK3R”, 1ª Edição

|>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|| ||
|| d4rwin at motdlabs.org ||
|| http://www.d4rwin.cjb.net ||
|| ||
|| MSN/GoogleTalk > d4rwin@gmail.com ||
|| YahooMessenger > d4rwinetico@yahoo.com.br ||
|| IRC > irc.freenode.net -j #motd ||
|| ||
|>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

“Quem tem boca vai a Roma. Meu fogão tem 4 e não saiu da cozinha.”
(Desconhecido)

“Bill Gates não é Adão, mais comeu a Apple. E quem paga os pecados é o usuário
do Windows.”
(Desconhecido)

_EOF_

The post [Redes] Básico sobre o Modelo OSI appeared first on 0fx66.

#include <stdio.h>

int main() {
	char frase[50];
	printf("Digite a uma frase: ");
	scanf("s", &frase);
	printf("A frase digitada foi: %s\n", frase);
	
	return 0;
}

Compile: gcc frase.c -o frase

Resultado:

bash-3.1$ frase
Digite a uma frase: joao caiu feio
A frase digitada foi: joao
bash-3.1$

Para resolve esse problema do scanf não capturando o resto da frase usando o parâmetro %[^\n] ao invés de %s, por exemplo:

#include <stdio.h>

int main(){
	char frase[50];
	printf("Digite a uma frase: ");
	scanf("%[^\n]", frase);
	printf("A frase digitada foi: %s\n", frase);
	
	return 0;
}

Compile: gcc frase2.c -o frase2

Resultado:

bash-3.1$ ex6
Digite a uma frase: joao caiu feio
A frase digitada foi: joao caiu feio
bash-3.1$

Agora a frase foi devidamente capturando, para evitarmos overflows no uso desse parâmetro no scanf, colocando %limite[^\n], sendo limite igual ao valor máximo de caracteres que a função scanf ira armazenar na variável. Ficando desta forma.

#include <stdio.h>

int main() {
	char frase[50];
	printf("Digite a uma frase: ");
	scanf("%49[^\n]", frase);
	printf("A frase digitada foi: %s\n", frase);
	
	return 0;
}

Para limpar o buffer após o uso de scanf com este parâmetro, usamos getchar() após o scanf.

#include <stdio.h>

int main() {
	char frase[50];
	printf("Digite a uma frase: ");
	scanf("%49[^\n]", frase);
        getchar();
	printf("A frase digitada foi: %s\n", frase);
	
	return 0;
}

Espero que a dica sirva para poderem resolver seus problemas o uso de scanf e strings. Bons estudos a todos. Nas referências tem um link com um tabela informando uma serie de parâmetros interessantes para o uso de scanf, no segundo link tem uma artigo do com diversas dicas para printf e scanf a dupla dinâmica.

Referência:

Como usar o scanf() para strings com espaços
Parâmetros interessantes do scanf e do printf em C

The post [Linguagem C] Utilizando scanf em strings com espaço appeared first on 0fx66.

Primeiramente instalei o sqlite3. Após instalar o sqlite3,vá em:

 cd ~/.mozilla/firefox/perfil do firefox.default

Você vai ver que essa pasta possui vários arquivos com a extensão .sqlite, que é o que queremos otimizar. Para isso, feche o Firefox depois simplesmente digite, para cada arquivo:

sqlite3 nome_do_arquivo.sqlite vacuum

Tem como fazer em todos os arquivos de uma vez? Claro. Você está mexendo em um terminal Linux! Para fazer todos de uma vez, digite:

for i in *.sqlite; do sqlite3 $i vacuum; done

Basicamente o vacuum que isto faz é executar um “OPTIMIZE TABLE” nos arquivos do sqlite, como o firefox utiliza o sqlite para o armazenamento de suas informações, o vacuum irá dar uma geral nos arquivos .sqlite fazendo com o que firefox tenha uma leve melhoria em sua performance, principalmente se você possui muitos itens favoritados hehehe

Para saber mais sobre o vacuum recomendo ler a documentação do sqlite.

[]‘s

The post Otimizando o Firefox com sqlite3 appeared first on 0fx66.

###################################################
### Detalhando a função printf ###
###################################################

feito por Blood_Sucker!

OBS: Este texto eh destinado a comunidade newbie do planeta, portanto, se você se acha elite, não vera nada de bom aqui.

============
Sumario |
============

1. Introdução
2. Compreendendo o printf
3. Caracteres de escape definidos por C
4. Quebrando uma string de caracteres em duas linhas
5. Determinando o numero de caracteres que printf imprimiu
6. Exibindo valores do tipo INT usando printf
6.1. Imprimindo valores inteiros formatados
6.1.1. Deslocando a impressão para a direita
6.1.2. Precedendo de zeros um deslocamento
6.2. Imprimindo um valor inteiro Octal ou Hexadecimal
6.3. Imprimindo um prefixo antes dos valores Octais ou Hexadecimais
6.4. Imprimindo valores do tipo unsigned int usando printf
6.5. Imprimindo valores do tipo long int usando printf
7. Imprimindo valores do tipo float usando printf
7.1. Imprimindo valores do tipo float em formato exponencial
7.2. Imprimindo valores do tipo float de outras maneiras
7.3. Imprimindo valores float formatados
8. Imprimindo valores do tipo char usando printf
9. Imprimindo uma string de caracteres usando printf
9.1. Imprimindo uma string do tipo Near e Far
10. Imprimindo um endereço de um ponteiro usando printf
11. Imprimindo algo precedido de uma sinal de adição ou de subtração
12. ANSI
12.1. Usando o controlador ANSI para limpar a sua tela(clear)
12.2. Usando o controlador ANSI para exibir as cores da tela
12.3. Usando o controlador ANSI para posicionar o cursor
13. Considerações Finais

1. Introdução
=============

Bem amigos, eu estive lendo algumas coisas sobre C mas que nunca havia encontrado na net, e me empolguei a escrever detalhadamente sobre a função printf da linguagem C de programação, que apesar de ser uma simples função para impressão na tela contem vários macetes para se usá-la, ganhando assim tempo, espaço em código é claro, enxugando seu código ainda mais você terá um processamento mais rápido e tal…Apesar disso tudo, este texto não passa de um guia básico sobre esta função, para o compreendimento do mesmo, basta um conhecimento bem básico de C e ter noções sobre tipos de dados decimais, hexadecimais, binários e octais. Mas nada tão difícil. É um texto beeeem idiota, mas pode ser útil tanto pra quem esta começando, quanto para quem já sabe, porque apesar de simples, tem um monte detalhezinhos que eu nunca encontrei na net =]
E no final eu ensino a manipular ANSI para cores e tals…Vários amigos meu não sabiam que dava pra fazer isso. E como o nash diz, somos todos newbies, temos muito a aprender. Você pode estar pensando q eu sou um imbecil que só quer escrever um textinho ridículo desses pra sair falando “ohh, eu escrevi pra unsekurity”. Se você pensa isso cara, tudo bem, eu pensaria o mesmo. Mas não tem nada haver. Eu contribuo com o q posso.

2. Compreendendo o printf
=========================

Como eu já disse na introdução, o printf é uma simples função para exibir mensagens na tela. Pois o que detalharei aqui são os diversos parâmetros ou argumentos de printf, que são apenas informações que você passa para a função trabalhar de uma determinada maneira. Vamos começar do básico, o printf é uma função definida pelo header stdio.h, é por isso que temos de inclui-lo no começo de qualquer programa em C para usarmos o printf. Para isso, fazemos o seguinte:

#include <stdio.h>

Isso é bem básico, mas vou demonstrar um programa que imprime uma frase na tela:

#include <stdio.h>
main()    // main é uma função q declara o inicio da aplicação
{
	printf("Unsekurity Scene");
}

Este simples programa ira imprimir a frase Unsekurity Scene. Bom, vou tentar começar a explicar a estrutura de parâmetros de printf (estas regrinhas não se aplicam diretamente a função printf, mas sim a linguagem C, mas vou comentá-las para familiarizarmos, ok?) Em uma função C, podem ocorrer este formato de parâmetro: nome_da_funcao(“dado a ser movimentado, aqui pode conter variáveis, ponteiros e tudo mais, porem não de uma maneira direta, é ai que a coisa fica interessante”, parâmetros para as variáveis(se houver) ); compliquei? por exemplo, se formos acrescentar variáveis a nossa função printf, ficaria da seguinte maneira:

#include <stdio.h>
main()
{
	int numero = 10;
	printf("%d", numero);
}

Sacaram? Você deve acrescentar o tipo de variável que será definida e depois do fecho do argumento para a saída (tudo que fica entre chaves ” “) colocamos a virgula (,) para passar parâmetros para o tipo de variável definida. Atenção, na função printf, não adianta você definir um tipo de variável e depois passar parâmetro de um outro tipo de variável que não dará certo. Por exemplo:

#include <stdio.h>
main()
{
	char teste[] = "teste";
	printf("%p", teste);
}

Isso esta incorreto, porque você definiu um ponteiro como variável a ser chamada e usou uma string para atribui-la, isso daria erro de compilação. Apesar de ser um erro logico.

3. Caracteres de escape definidos por C
=======================================

Seria impossível não falar sobre isso quando se esta trabalhando com a função printf. Pois em C, existe uma tabela de caracteres de escape que podem ser usados pelas funções, principalmente por printf. Eis uma tabela com estes caracteres de escape:

==================================================================================
 Caractere  |	          Significado           
 de Escape  |                                   			      
==================================================================================
 \a |(alerta) Caractere ASCII de aviso sonoro. 				     
 \b |(backspace) Muda a posição atual 1 caractere antes.		             
 \f |(form feed) Move a posição atual para o inicio da próxima pagina.	     
 \n |(new line) Move a posição atual p/ posição inicial da próxima linha.	      
 \r |(carriage return) Move a posição atual p/ a posição inicial da linha.	      
 \t |(horizontal tab) Move a posição atual p/ na posição de tabulação definida.     
 \v |(vertical tab) -> Move a posição atual p/ na posição de tabulação vertical.    
 \\ |('\') Caractere para imprimir a barra invertida				     
 \' |(''') Caractere para imprimir o Apóstrofo				     
 \" |('"') Caractere para imprimir Aspas					      
 \? |("?") Caractere para imprimir o Ponto de Interrogação			     
 \nnn |Valor ASCII em octal							      
 \xnnn |Valor ASCII em hexadecimal 						      

Como você pode ver, estes caracteres são bastante uteis, não se preocupe se você não entendeu os 2 últimos, isso só sera discutido mais pra frente. Vamos dar um exemplo:

#include <stdio.h>
main()
{
	int nota = 10;
	printf("Unsekurity eh nota %d\n", nota);
}

Sem aquele \n no final do argumento, o programa ao ser executado iria imprimir a frase e logo após o ultimo caractere da frase iria aparecer já o prompt de comando. Fica meio feio né, com o acréscimo do \n o programa ao terminar de imprimir a frase, pula uma linha para voltar ao prompt de comando.

Atenção: O \n não tem nada haver com o %d que eu coloquei ali, só coloquei aquilo ali pra vocês irem se introduzindo com o printf para os nossos próximos tópicos. Outra coisa, nenhum caractere de Escape precisa de parâmetro depois da virgula. E padrão já.

Veja este outro exemplo para fixar legal:

#include <stdio.h>
main()
{
	printf("Linha 1\nLinha 2\nLinha 3");
}

Compile e veja no q vai dar.

4. Quebrando uma string de caracteres em duas linhas
====================================================

Bem, as vezes quando estamos programando, não queremos fazer com q nossas linhas sejam muito grandes para que quando estivermos lendo o programa, não ter que ficar indo pra la e cá com a barra de rolagem. Em C, é padrão de printf quebrar as linhas de acordo com o código. Por exemplo:

#include <stdio.h>
main()
{
	printf("Se nos digitarmos uma frase grande assim
	e nao quisermos ultrapassar o limite da barra de rolagem para nao fica
	ruim para ler depois, fazemos isso.\n");
}

Ei, mas este programa imprimira a frase de acordo com o fonte, em TRÊS linhas :/ E se não quisermos isso? e se quisermos quebrar a linha no fonte mas na hora da compilação ele entender tudo como uma linha só?? simples, basta usar o \ veja este exemplo:

#include <stdio.h>
main()
{
	printf("Se nos digitarmos uma frase grande assim \
	e nao quisermos ultrapassar o limite da barra de rolagem para nao fica \
	ruim para ler depois, fazemos isso.\n");
}

Ai sim ele vai imprimir tudo numa linha, e se não couber ele termina na próxima linha, e se não couber de novo, na próxima, e assim por diante…

5. Determinando o número de caracteres que printf imprimiu
———————————————————-

Este parâmetro é muito útil, ele é usado para dizer quantos caracteres foram usados até determinado ponto que você definiu. O especificador usado para isso eh o %n. Veja o exemplo:

#include <stdio.h>
main()
{
	int contagem;
	printf("quantos caracteres sera q eu digitei ate aqui%? %n \n", &contagem);
	printf("Resposta: %d\n", contagem);
}

Compile e veja o que da. O %n pode ser usado em qualquer parte da linha, mas quando você for atribuir o numero de linhas a ele use o “E comercial ” (&) na frente. Como você viu no exemplo.

6. Exibindo valores do tipo INT usando printf
=============================================

Bem, como você já deve saber, int eh um tipo de variável, mas como imprimir este tipo de variável numa função printf? simples. Basta usar o seguinte especificador: %d. Já usamos ele em alguns exemplos ai acima, vamos agora dar um exemplo pratico:

#include <stdio.h>
main()
{
	int ano = 1984;
	int mes = 9;
	int dia = 19;
	printf("Eu nasci no dia %d do mes %d do ano de $d\n", dia, mes, ano);
}

Entenderam? Fácil né?
Observação: é interessante você que esta lendo o texto, ir compilando cada programa e comparando resultados. É o melhor jeito de aprender.

Olha, muitos compiladores de C tratam o especificador de int no seguinte format também %i. Mas hoje em dia já esta ficando cada vez mais fácil de se encontrar programas usando %d mesmo, é bem capaz dos compiladores começarem a usar somente o %d. Então, é recomendável familiarizar-se com o %d mesmo.

6.1. Imprimindo valores inteiros formatados
===========================================

O que seria formatar um valor? Apagar? não não, estou me referindo a formatação de texto, estilo, como o texto deve ser. Veja como é possível formatar uma saída de inteiros.

6.1.1. Deslocando a impressão para a direita
——————————————–

Para deslocar uma impressão para a direita, deve-se fazer o seguinte. Use o numero de espaços que você quer por antes do especificador e depois do %. Veja o exemplo:

#include <stdio.h>
main()
{
	int valor = 10;
	printf("%1d\n", valor);
	printf("%2d\n", valor);
	printf("%3d\n", valor);
	printf("%4d\n", valor);
	printf("%5d\n", valor);
}

Compile e veja o resultado.

6.1.2. Precedendo de zeros um deslocamento
——————————————

Veja o exemplo e compile, só assim entendera.

#include <stdio.h>
main()
{
	int valor = 10;
	printf("%01d\n", valor);
	printf("%02d\n", valor);
	printf("%03d\n", valor);
	printf("%04d\n", valor);
	printf("%05d\n", valor);
}

6.2. Imprimindo um valor inteiro Octal ou Hexadecimal
—————————————————–

Vocês devem saber o que é um valor Octal(base 8) ou Hexadecimal(base 16), existem especificadores de C que instruem printf a exibir um valor inteiro em Octal ou Hexadecimal. O especificador para octal é o %o. Veja um exemplo:

#include <stdio.h>
main()
{
	int valor = 10;
	printf("%d em decimal eh o mesmo q %o em Octal\n", valor, valor);
}

Compile e veja os resultados. Já tratando-se de hexadecimais inteiros, o especificador eh o %x ou o %X. A única diferença entre os dois é que o %x imprime o valor em minusculo e o %X em maiúsculo. Geralmente é usado o %X, mas fica a critério. Exemplo:

#include <stdio.h>
main()
{
	int valor = 10;
	printf("%d em decimal eh o mesmo q %x ou %X em Hexadecimal\n", valor, valor, valor);
}

6.3. Imprimindo um prefixo antes dos valores Octais ou Hexadecimais
——————————————————————-

Com certeza você já viu em códigos ou textos, que valores em hexadecimal são precedidos por 0x ou 0X e valores octais são precedidos por 0. Agora você ira aprender a imprimir os valores com os precedimentos. Basta você usar o sharp(#) antes do especificador de hexa ou octal e depois do %. Veja o exemplo:

#include <stdio.h>
main()
{
	int valor = 10;
	printf("O octal com precedimento fika assim: %#o\n", valor);
	printf("O hexa com precedimento fika assim: %#x ou %#X\n", valor, valor);
}

Compile e compreenda.

6.4. Imprimindo valores do tipo unsigned int usando printf
———————————————————

Como você deve saber, unsigned é um modificador de inteiros em C que imprime apenas valores positivos (maior que 0). E existe uma maneira de declarar isso direto no printf. Usando o especificador %u. Exemplo:

#include <stdio.h>
main()
{
	unsigned int valor = 1000;
	printf("Imprimindo o valor 1000 como unsigned: %u\n", valor);
	printf("Imprimindo o valor 1000 como int: %d\n", valor);
}

Compile e veja a diferença.

6.5. Imprimindo valores do tipo long int usando printf
——————————————————

Você já reparou q o printf suporta especificadores de modificadores de tipo de uma variável. Existe um especificador que é usado para imprimir valores de long int, ele eh o %ld. Exemplo:

#include <stdio.h>
main()
{
	long int valor = 1000000;
	printf("O valor 1000000 com %%ld eh: %ld", valor);
	printf("O valor 1000000 com %%d eh: %d", valor);
}

Compile e veja a diferença.

7. Imprimindo valores do tipo float usando printf
=================================================

Bem, você sabe o que é uma variável do tipo float né? Vejamos agora o especificador para se imprimir um valor de uma variável desse tipo. Ele é o %f. Veja o exemplo.

#include <stdio.h>
main()
{
	float nota1 = 6.7;
	float nota2 = 8.3;
	float media = (nota1 + nota2) / 2;
	printf("O aluno tirou %f na primeira prova e %f na segunda, sua media eh %f\n", nota1, nota2, media);
}

Compile e veja como funciona.

7.1. Imprimindo valores do tipo float em formato exponencial
———————————————————–

Você já deve estar sabendo o que é um valor exponencial. Existe o especificador para isso. Ele é o %e ou %E, que como no especificador de hexadecimais(%x ou %X), a diferença entre os dois é que o %e imprime o ‘e’ em minuscula, o o %E imprime o ‘e’ em maiúscula. Veja o exemplo:

#include <stdio.h>
main()
{
	float valor1 = 4.525657;
	float valor2 = 3.9890;
	printf("O valor1 multiplicado pelo valor2 com %%e eh: %e\n", valor1 * valor2);
	printf("O valor1 multiplicado pelo valor2 com %%E eh: %E\n", valor1 * valor2);
}

7.2. Imprimindo valores do tipo float de outras maneiras
——————————————————–

Agora que você aprendeu a usar o %f e o %e/%E, vou ensina-los a usar um outro especificador de float. Ele é o %g ou %G. Ele é assim, você define um float e quer imprimi-lo, usando o %g ou %G, o próprio compilador escolhe a melhor maneira de se exibir a saída para o usuário, sendo ela no formato do %f ou no formato do %e/%E (eh por causa do %e/%E q existe o %g minusculo e maiúsculo também(%G)). Veja o exemplo:

#include <stdio.h>
main()
{
	printf("Exibir 0.1234 resulta em %g\n", 0.1234);
	printf("Exibir 0.00001234 resulta em %g\n", 0.00001234);
}

Compilem e vejam, muito interessante…

7.3. Imprimindo valores float formatados
—————————————-

Da mesma maneira do int, formatamos o float usando o numero de espaços que serão preenchidos. Veja o exemplo para compreender melhor:

#include <stdio.h>
main()
{
	float valor = 1.23456;
	printf("%8.1f\n", valor);
	printf("%8.3f\n", valor);
	printf("%8.5f\n", valor);
}

Compile e compreenda a diferença.

8. Imprimindo valores do tipo char usando printf
================================================

Para imprimir um valor de uma variável do tipo char, é usado o seguinte especificador: %c. Porém tem uma coisa interessante em char, você pode definir tanto a letra direto (que deve estar definida entre aspas simples ‘ ‘) ou como o valor da letra na tabela ASCII. Veja o exemplo:

#include <stdio.h>
main()
	printf("A letra A imprimida em char pela letra eh %c\n", 'A');
	printf("A letra A imprimida em char pelo valor ASCII eh %c\n", 65);
}

Porque 65? 65 eh o valor da letra A em maiúsculo na tabela ASCII. Sacou?

9. Imprimindo uma string de caracteres usando printf
====================================================

Também existe um especificador para isso, é o %s. Olhe o exemplo:

#include <stdio.h>
main()
{
	chat teste[] = "Unsekurity Scene Rocks";
	printf("%s\n", teste);
}

9.1. Imprimindo uma string do tipo Near e Far
———————————————

Acho que você já deve saber o que é uma string de tipo near e far. Mas existe a maneira correta de joga-la no printf. Em caso de far, usamos o F que ficara entre o % e o especificador. E o mesmo com o near. Veja no exemplo:

#include <stdio.h>
main()
{
	char *teste_near = "este eh o near";
	char far *teste_far = "este eh o far";
	printf("%Ns\n", teste_near);
	printf("%Fs\n", teste_far);
}

Compile e execute para ver no que da.

10. Imprimindo um endereço de um ponteiro usando printf
======================================================

É, você deve estar imaginando o quão grande diverso é a função printf, pois é, existe especificador pra tudo né, veja agora o especificador de um endereço de um ponteiro. Ele é o %p. Veja o exemplo:

#include <stdio.h>
main()
{
	int valor;
	printf("O endereco de ponteiro da variavel valor eh %p\n", &valor);
}

Com ponteiros usamos o E comercial (&) para atribuirmos uma variável. Compile e veja o resultado.

11. Imprimindo algo precedido de uma sinal de adição ou de subtração
===================================================================

Este é bem simples, para imprimir um valor precedido de um sinal de mais(+) ou de menos(-) não tem muito segredo, basta colocar o sinal de mais apos o % e antes do especificador. Isso se aplica a floats e a inteiros. Veja o exemplo para compreender melhor.

#include <stdio.h>
main()
{
	int teste1 = -10;
	int teste2 = 10;
	float teste3 = -2.5;
	float teste4 = 2.5;
	printf("Os inteiros saun: %+d e %+d\n", teste1, teste2);
	printf("Os inteiros saun: %+f e %+f\n", teste3, teste4);
}

Compile é veja a diferença.

12. ANSI
========

Finalmente chegamos na parte mais legal deste texto, ANSI. Como manipular o controlador de dispositivos ANSI. Que nada mais é do que diversas sequências de escape que podem ser usadas para manipular o cursor, cores e até limpar a tela. Se você estiver programando em um sistema windows, para trabalhar com ANSI será necessário você adicionar a seguinte linha no seu arquivo c:\config.sys (e eh logico, depois reinicializar o micro):

device=C:\WINDOWS\COMMAND\Ansi.sys

Se for qualquer sistema Unix-like, num precisa de nada disso(logico).

12.1. Usando o controlador ANSI para limpar a sua tela(clear)
————————————————————

Que eu saiba, a linguagem C não tem uma função que limpe a tela, geralmente a galera usa o system(“clear”); para fazer isso, mas vamos aprender a fazer isso com ANSI. Como eu disse, manipular ANSI, nada mais é do que manipular sequencias de escape. Por exemplo, na tabela ANSI, a seguinte sequência de escape eh usada para limpar a tela:

Esc[2j

Mas como vamos infiltrar isso em um printf? Trocando o Esc pelo seu valor em ANSI. Q eh \033. Então vamos fazer um teste. Veja o exemplo:

#include <stdio.h>
main()
{
	printf("\033[2J");
	printf("Simples limpador de tela, se executa-lo de novo, ele limpara a tela e imprimira esta \
	mensagem de novo\n");
}

Compile é execute, veja no que da.

12.2. Usando o controlador ANSI para exibir as cores da tela
------------------------------------------------------------

Você já aprendeu q ao manipular ANSI, deve-se usar o seguinte caractere de escape: \033 Agora vamos manipulá-lo para usar cores de fundo e de letra(ou primeiro plano). Veja a tabela abaixo:

====================================
Sequencias  |                      |
de Escape   |         Cor          |
====================================
Esc[30m    | Cor da letra preta    |
Esc[31m    | Cor da letra vermelha |
Esc[32m    | Cor da letra verde    |
Esc[33m    | Cor da letra laranja  |
Esc[34m    | Cor da letra azul     |
Esc[35m    | Cor da letra magenta  |
Esc[36m    | Cor da letra ciano    |
Esc[37m    | Cor da letra branca   |
Esc[40m    | Cor de fundo preta    |
Esc[41m    | Cor de fundo vermelha |
Esc[42m    | Cor de fundo verde    |
Esc[43m    | Cor de fundo laranja  |
Esc[44m    | Cor de fundo azul     |
Esc[45m    | Cor de fundo magenta  |
Esc[46m    | Cor de fundo ciano    |
Esc[47m    | Cor de fundo branca   |
====================================

Ok, você tem uma lista com as cores em sequencia ANSI. Agora vamos testa-las:

#include <stdio.h>
main()
{
	printf("\033[2J");     // limpei a tela
	printf("\033[47m\033[32mTestando...\n");   // aki eu defini a cor de fundo branca e a letra verde
}

Não é tao complicado, é decoreba. Compile e veja.

12.3. Usando o controlador ANSI para posicionar o cursor
--------------------------------------------------------

Sim, existe este tipo de coisa com assim...estilo gotoxy() de pascal. Mas em ANSI. Veja a tabela de sequencias de Escape para isso:

========================================================
Sequencia | 					       |
de Escape |                 Funcao		       |
========================================================
Esc[x;yH  | Posiciona o cursor na linha x, coluna y    |
Esc[xA    | Move o cursor x linhas para cima           |
Esc[xB    | Move o cursor x linhas para baixo          |
Esc[yC    | Move o cursor y colunas para a direita     |
Esc[yD    | Move o cursor y colunas para a esquerda    |
Esc[S     | Armaneza a posicao atual do cursor         |
Esc[U     | Restaura a posicao do cursor               |
Esc[2j    | Este nos ja vimos, eh o limpador, ele move |
| o cursor para o canto superior esquerdo              |
Esc[K     | Limpa ateh o final da linha atual          |
========================================================

Você já deve ter compreendido como funciona agora né? Veja este ultimo exemplo:

#include <stdio.h>
main()
{
	printf("\033[2J");     // limpa a tela
	printf("\033[10;19H");   // Posiciona o cursor para a linha 15 e coluna 12
	printf("\033[43m");  // Pinta o fundo de laranja
	printf("\033[30mTestando minha manipulacao em ANSI");   // Pinta a letra de preto e exibe uma msg
}

Bastante interessante né?

13. Considerações Finais
========================

Galera, eu espero ter ajudado, lembrem-se que todos os controladores e especificadores podem ser usados juntos, combinados... Só um lembrete, recentemente surgiu uma falha chamada de format bug, e até onde sei, esta falha se aplica ao printf. Recomendo também uma leitura do texto do nash sobre isso. Pois é muito interessante. Este texto eu escrevi baseado em alguns tópicos de um ótimo livro de C. O C/C++ a bíblia. Unsekurity Forever! T+, Blood_Sucker! "Odiado por muitos, compreendido por poucos..."

[]'s

The post Conhecendo a função printf appeared first on 0fx66.

A primeira solução que encontrei foi combinar um loop com a função toupper(), que converter letras em maiúscula com um loop, para converter letra por letra, criei um código bastante simples abaixo. Salve e compile.

//EXEMPLO DE CONVERSAO DE STRINGS MINUSCULAS EM MAIUSCULAS EM C.
#include <stdio.h>
#include <ctype.h>// necessaria para toupper().

int main() {
	
	int i;
	char palavra[20];
	//Recebe a string.
	printf("Digite uma palavra: ");
	scanf("%19[^\n]", palavra);

	//loop que efetua a conversao de letra por letra.
	for(i=0;palavra[i]!='\0';i++) {
		palavra[i]=toupper(palavra[i]);
	}

	//Imprimi o resultado.
	printf("%s\n",palavra);

	return 0;
}

Saída:

Agora fica o desafio que tal escrever uma função que realize esta operação? Abaixo tema resposta para o desafio, escondida claro, não quero atrapalha a a diversão de vocês!

void toMaiuscula(char *string) {
	
	while(*string != '\0') {
		*string = toupper((unsigned char)*string);
		 string++;
	}
}

Esta função já apresenta uma pequeno grau de complicação para os iniciantes, pois já começa a trabalhar com ponteiros. Infelizmente em C não temo como trabalhar com passagem de strings sem recorrer ao uso de ponteiros. Entretanto quando estiver estudando ponteiros já vai conhecer uma utilidade no uso deles! Agora segue o código completo.

#include <stdio.h>
#include <ctype.h>// necessaria para toupper().

void toMaiuscula(char *string);

int main() {
	
	//Variaveis
	int i;
	char palavra[20];
	
	//Recebe a string.
	printf("Digite uma palavra: ");
	scanf("%19[^\n]", palavra);

	//loop que efetua a conversao de letra por letra.
	for(i=0;palavra[i]!='\0';i++) {
		palavra[i]=toupper(palavra[i]);
	}

	//Imprimi o resultado.
	printf("%s\n",palavra);
	
	//Utilizando a funcao!
	printf("\n\nAgora utilizando a funcao toMaiscula()\n");
	
	char palavra2[] = "teste";
	printf("Original: %s\n", palavra2);
	
	//Funcao que efetua a conversao.
	toMaiuscula(&palavra2[0]);
	
	printf("Apos a conversao: %s", palavra2);

	return 0;
}

void toMaiuscula(char *string) {
	
	while(*string != '\0') {
		*string = toupper((unsigned char)*string);
		 string++;
	}
}

Vocês viram como é simples lidar com a conversão de strings, que tal um novo desafio? É bem simples, temos uma string em caixa alta, agora o desafio é o oposto, converta de maiúsculo para minusculo.

[]‘s

The post [Linguagem C] Convertendo string minúscula em maiúscula em C appeared first on 0fx66.

Por que não existe patch para a ignorância humana!

Primeiramente oque vem a ser engenharia social? São práticas utilizadas para obter acesso a informações importantes ou sigilosas em organizações ou sistemas por meio da enganação ou exploração da confiança das pessoas. Para isso, o golpista pode se passar por outra pessoa, assumir outra personalidade, fingir que é um profissional de determinada área, etc. É uma forma de entrar em organizações que não necessita da força bruta ou de erros em máquinas. Explora as falhas de segurança das próprias pessoas que, quando não treinados para esses ataques, podem ser facilmente manipuladas. O ataque basicamente explora a o elo mais fraco da corrente da segurança, o ser humano.

Se utilizada para o mal, a engenharia social torna-se crime e pode ser enquadrada nos artigos 171 e 299 do Código Civil Penal. Trata-se de estelionato, com pena de reclusão de um a cinco anos, além de multa, e falsidade ideológica, com pena de reclusão de um a três anos, além de multa.

No texto abaixo extraído da pagina unsekurity (não mais online) o autor Blood_Sucker descreveu diversos métodos de como são aplicados ataque de engenharia social.

Texto: Engenharia Social escrito por Blood_Sucker.

OBS: Este documento foi feito apenas com intuito educacional, não estou incentivando ninguém a fazer isso e muito menos me responsabilizo pelo q possam fazer.

=============
Sumário
=============

1. Introdução
2. O que eh Engenharia Social
3. Engenharia Social via telefone
4. Engenharia Social via e-mail
5. Engenharia Social aliada ao Phreaking
6. Engenharia Social pessoalmente(In Person Social Engineering)
7. Considerações Finais

1. Introdução

Bem, alguns de vocês já devem ter ouvido falar disso, ou não. Este tutorial é simplesmente destinado a explicar o q eh e dar algumas dicas para não ficar com cara de bobo se te pegarem com a mão na lambuja. Como sempre eh dito, eh um tuto destinado a newbies, portanto, se você é elite ou então é do tipo de cara q assistiu o filme do mitnick e ficou dizendo “putz, olha como esse cara é amador” (coisa que já ouvi muito por ai) você não tem motivos para ler isso, já que você é profissional.

2. O que eh engenharia social?

Engenharia social é a arte de se conseguir informações seja la qual for a maneira, muitos dizem ser loucura mas coisas do tipo falsificar uma carteira de identidade, ir numa universidade dizendo ser outra pessoa só para poder ter acesso ao servidor central da mesma eh engenharia social. Engenharia social conta com qualquer tipo de coisa, sejam telefonemas, e-mails, comparecimentos, qualquer coisa… Isso tudo é usado por phreakers, hackers e crackers…Mas quem eh q nunca falsificou uma copia de RG para entrar em um show, ou numa danceteria?? não deixa de ser engenharia social… Portanto não eh “coisa de hacker” como muito babaca diz por ai. Existem grandes loucuras usadas na engenharia social, temos de concordar que não é coisa para qualquer um, exige em muitos casos, mais “esperteza” do q “conhecimento técnico”. E em caso de “esperteza”, brasileiro da show =] Bem, agora que você já sabe o que é engenharia social, darei algumas pequenas dicas caso você esteja planejando algo do tipo.

3. Engenharia Social via telefone

Irei aqui discutir métodos de engenharia social via telefone, com certeza é a maneira mais usada, mas isso não a diminui… Regras básicas neste tipo de engenharia social Pois é…você entrou numa pagina da internet que possuía informações de tal individuo que é dono de um empresa que possui algum dado q você quer, e simplesmente ligara para a empresa dizendo q é ele e que quer a senha do banco de dados deles, certo??? Com certeza isso não dará certo, pelo simples fato da coisa não ser tao simples assim, olha, nunca pense q você é o único espertinho no mundo, nem todo mundo eh idiota. Lembre-se disso. Primeiramente, isso é um exemplo vago, porque com você pretende fazer uma coisa dessas, não seria assim que você conseguiria. Antes de tudo vamos levar em consideração algumas “regras” quando c quer fazer este tipo de coisa. Estas regras não se aplicam somente neste tipo de engenharia social.

- SEMPRE USE APARELHO TELEFÔNICO PUBLICO

- NUNCA, MAS NUNCA MESMO TENTE ALGO SEM TER TODAS AS INFORMAÇÕES NECESSÁRIAS SOBRE O LOCAL,
PESSOA(S), HORÁRIO DE TRABALHO, HORÁRIO DE ALMOÇO, TUDO, ABSOLUTAMENTE TUDO.

- PROCURE SABER O Q CADA PESSOA EH NA EMPRESA

- VOCÊ NÃO PODE SER RECONHECIDO POR NINGUÉM, EU DISSE NINGUÉM.

Estas regras são mais ligadas na engenharia social via telefone…mas também se aplicam a qualquer tipo. Vou explicar agora o motivo de cada regra.
Primeiramente, já inventaram rastreador de chamadas e não foi recentemente, não pensem q é porque a telefônica esta oferecendo este serviço somente agora q ele eh um serviço novo. E meio que uma regra em empresas, conter rastreador de chamadas, e mesmo que você tenha certeza absoluta que a empresa que você esta tramando algo não tem este tipo de coisa, não use seu próprio telefone, NUNCA. Primeiro por que a telefônica tem um registro de C/S(Cliente/Servidor), ou seja, ela tem o registro completo de quem ligou pra quem, eu disse COMPLETO. Mas tem algumas maneiras de burlar isso, uma delas eh usando uma blue box…

Uma dica ai, eh logico q você não vai ligar a cobrar, e muito menos fazer aquele eskeminha de apertar o 9 como já vi muito idiota fazer e dançar. O esquema é, você liga pro lugar com o cartão e quando a pessoa atender você segura o 9 e retira o cartão, ai a ligação passa a ser a cobrar. Mas e se esta telefonista não for tão burra quanto você pensa e ao ouvir o barulho do tom do telefone ela desligar na tua cara??? ou então ela pode ter percebido e esperado você falar q eh tal pessoa para t dizer algo do tipo “O Sr. Marcos esta sentado em minha frente, como pode ser você?? hahahaha”.

Muita gente me chama de doente quando eu levo em conta este tipo de coisa, mas não existe crime perfeito. Nada é perfeito. E isso nos concluímos a cada falha q descobrimos =] Na segunda regra cito q você deve ter todas as informações necessárias e não necessárias. Tipo, cara, e com você liga falando que é o senhor X e que precisa urgentemente de um relatório e q enviara um motoboy pra pega-lo é a telefonista percebe q não é você simplesmente porque o senhor X é gago e porque você esta falando perfeitamente, ou porque o cara tem voz fina e você tem voz grossa?? pois é cara, tem q saber até os mínimos detalhes…e se o tal cara andava comendo a telefonista e você chega todo falando serio, ela vai perceber que não é você porque devido a intimidade que eles tem não era pra ele estar falando dessa maneira. Cara, são inúmeros detalhes que tem de saber, e não somente informações cadastrais. Como citado na regra 3, você tem de saber o que cada pessoa é na empresa.

Não adianta você conseguir o telefone do ramal de vendas e ligar pedindo uma informação sobre o banco de dados, não tem nada haver né cara. A quarta regra é a mais importante, nunca seja reconhecido por NINGUÉM. É claro que por telefone é muito difícil de ser reconhecido, mas não force sua voz para tentar parecer outra pessoa também, Bom cara, são milhares de técnicas usadas para engenharia social por telefone, mas com certeza estas regras aplicam-se em todas. Aqui vai uma dica, se ligam pra você e a voz é de uma mulher bem sensual, você deixaria de dar tal informação para uma donzela indefesa? hehehe, pode parecer machista, mas as pessoas agem com mais seriedade com as mulheres do que com os homens. Pois seria ótimo se você conseguisse que uma mulher ciente de tudo, liga-se por você. Mulher é mais delicada e paciente pra falar (nem sempre huhauha).

Se possível, use artifícios não ligados a empresa, isso é muito mais inteligente do que ligar dizendo ser tal pessoa e por acaso a essa que você diz ser estiver do outro lado da linha. Por exemplo, se a empresa q você esta tramando algo estiver fechando negocio com uma consultoria para configurar o servidor deles. Você pode muito bem ligar para la, dizendo trabalhar na tal consultoria, e que precisa de informações incluindo senhas. Isso funciona, é logico que você não vai pedir somente o dado especifico que você quer, por exemplo “ae, preciso da senha do root”, ninguém seria burro né cara.. Se a pessoa do outro lado da linha não cair na sua armadilha, e começar a dizer merda pra você, NÃO DISCUTA, será pior, simplesmente desligue o telefone. Outro item importante eh demonstrar seriedade, nada de risadinhas. E por ultimo, não ligue de um aparelho publico muito lotado, não deixe que as pessoas ao seu redor ouçam o que você fala. Procure sempre um orelhão vazio.

4. Engenharia Social via e-mail

Pode parecer idiotice mas com a chegada da era da internet, muita coisa passou a ser feita via e-mail, incluindo envio de dados importantíssimos. Aonde entra a engenharia social nisso? Bem, na minha opinião isso já se trata mais de hacking do que engenharia social, mas o que é que no hacking não é uma engenharia social????? busco esta resposta em todos q se consideram elites e vejo eles parados pensando e olhando seriamente para mim. Aqui aplicam-se diversas coisas, envio de e-mail como sendo outra pessoa eh a mais usada, porem e-mail anonimo pode até funcionar. Uma coisa importante eh você escrever o e-mail de uma maneira bastante seria, abusem mesmo, e pecam com urgência, digam q precisam desta informação em menos de 5 horas urgentemente se não podem perder um negocio, sei la, cabe a vocês inventarem suas próprias verdades =] O nash/fallon fez um artigo explicando como enviar um e-mail falso, só pegar la na pagina da unsek. Só para os desavisados, isso tudo aqui eh crime e gente famosa como o Marco Nunez se ferraram fazendo isso. Relembrando. As regras na seção Engenharia Social via Telefone aplicam-se aqui também ta.

5. Engenharia Social aliada ao Phreaking

Engenharia Social e phreaking, duas coisas que quando bem combinadas se saem muito bem. A melhor maneira de usar phreaking na engenharia social é grampeando telefones para conseguir informações, pode parecer um pouco além de nosso alcance, mas não é tao difícil de se fazer uma coisa dessas…Pretendo começar a escrever sobre phreaking junto ao meu amigo j00nix, bom, mas a ideia já foi dada, cabe a você usa-la ou não =]

6. Engenharia Social pessoalmente

Chegamos a maior loucura de todas, engenharia social pessoalmente, também conhecida como “in person social engineering”. Neste caso, não eh brincadeira, se você for pego cara, não a NADA que pode ser feito, a não ser CORRER. É o único jeito, pois se te pegarem, o que você vai dizer para a policia?? q era brincadeira??

Se você chegou a este ponto, com certeza não foi atoa, você já deve ter usado o método via e-mail ou telefone para conseguir tais informações. Neste caso, é muito importante ter uma carteirinha de identificação falsificada, e eh sempre aquela mesma historia, saber com quem esta lidando, e ter o que é mais importante, informações completas.

Neste caso, tente parecer o mais serio possível, mas demonstre um pouco de “estranheza”, não no sentido que vocês estão pensando, mas no sentido de tentar parecer com o tipo de pessoa q meche na área que você esta tentando fingir ser. Compliquei? Vou dar um exemplo. Temos de concordar q a maioria dos programadores ou pessoas q mechem com informática são considerados nerds ou loucos pelas outras pessoas, não digo q isso não seja verdade, mas por exemplo, já vi programador de assembly falar sozinho, ficar olhando para um lugar e começar a viajar, ter aquele olhar de bobo, até mesmo o richard stallman na palestra dele na Linux expô , teve uma hora que parou de falar, e começou a olhar pro chão assim, do nada. Ninguém entendeu. Não estou tentando dizer para parecerem imbecis, só estou tentando faze-los entender q na engenharia social devem fingir ser o q as pessoas acham q o q você esta fingindo ser “SÃO”. (q frase doida)

7. Considerações Finais

Bem, expliquei aqui beeeem resumidamente o que é a tal engenharia social. Uma coisa q esta ficando cada vez mais esquecida pelo simples fato das pessoas começarem a serem mais atentas. Praticar Engenharia Social hoje em dia, principalmente pessoalmente, é muito raro, além de muito perigoso, você tem de ter total certeza do que você ta fazendo, como sempre. Deixo aqui um pedaço do meu esforço escrevendo este texto para fins informativos. Pois somos todos newbies e temos muito a aprender. Valeu galera, Unsekurity forever. T+, Blood_Sucker! “Odiado por muitos e compreendido por poucos…”

O perigo mora ao lado…

Em casos avançados de engenharia social envolvem conhecimento em psicologia, PNL (programação neurolinguística), análise comportamental. Agora analisemos alguns casos de engenharia social:

• O primeiro deles, um teste simples realizado pelos organizadores do congresso europeu InfoSecurity, em 2003. Eles colocaram pesquisadores com crachás no metrô de Londres, que pediam cinco minutos de atenção aos passantes. Para quem se dispusesse a responder um pequeno questionário, entregavam uma caneta simples como presente. Entre as questões pediam o nome da pessoa, a empresa onde trabalhava, o departamento e a senha de entrada no sistema. 95% dos homens e 85% das mulheres responderam de bom grado. Em 2004 a mesma pesquisa foi realizada pelos mesmos organizadores do InfoSecurity, desta vez oferecendo chocolate como prêmio pelas respostas ao questionário, e os resultados foram semelhantes.
• O segundo caso é o do técnico em informática Stanley Rifkin, que em 1978 roubou mais de 10 milhões de dólares do banco Security Pacific sem disparar um tiro ou mesmo sem usar um computador. Ele simplesmente leu o código diário de autorização para transferências internacionais que os funcionários colavam num quadro de avisos para facilitar o acesso, ligou de um orelhão se fazendo passar por um funcionário do setor de contas internacionais, e solicitou a transferência de dez milhões e duzentos mil dólares para uma conta que ele havia aberto na Suíça, fornecendo o código que havia lido. Só foi pego porque usou o dinheiro para comprar diamantes, e não sabia nada sobre como vendê-los sem chamar a atenção.
• E-mails falsos (scam): este é um dos tipos de ataque de engenharia social mais comuns e é usado principalmente para obter informações financeiras da pessoa, como número de conta-corrente e senha. Neste caso, o aspecto explorado é a confiança. Boa parte dos criadores desses e-mails são criminosos que desejam roubar o dinheiro presente em contas bancárias. Porém, os sistemas dos bancos são muito bem protegidos e quase que invioláveis! Como é inviável tentar burlar a seguranças dos sistemas bancários, é mais fácil ao criminoso tentar enganar as pessoas para que elas forneçam suas informações bancárias. A tática usada é a seguinte: o criminoso adquire uma lista de e-mails usados para SPAM que contém milhões de endereços, depois vai a um site de um banco muito conhecido, copia o layout da página e o salva em um site provisório, que tem a URL semelhante ao site do banco. Ataques de e-mails falsos comumente geram os famosos phisings(que ficaram para outro artigo).
• Redes sociais: Boa parte das pessoas possui perfis e contas em redes sociais, o que facilita a engenharia social criminosa. Ao criar perfis em sites de relacionamento é preciso ter cautela com os dados ali fornecidos, pois muitas vezes eles podem ser usados para prejudicar você. Não é aconselhável colocar telefones, endereço, empresa na qual trabalha e qualquer tipo de informação pessoal em seu perfil.
• Boatos = queda: Os boatos que circulam pela Internet podem refletir diretamente na empresa sobre a qual se fala. Um bom exemplo dessa situação é a Apple, que teve queda em suas ações depois que o boato sobre a suposta morte de Steve Jobs circulou por e-mails, blogs e fóruns. Tal método é conhecido no mercado financeiro como “pump-and-dump”.
• Kevin mitnick: Um caso que não poderia ficar sem ser citado, ele utilizou artimanhas da engenharia social pela primeira vez nos anos 70, ao conhecer um estudante que lidava com phreaking(hacking de linhas telefônicas), ele percebeu como os phreakers agiam, fazendo-se passar por funcionários das companhias telefônicas. Começou a tentar com amigos e professores e sentiu-se motivado após notar que tinha facilidade em conseguir informações confidenciais. ele foi evoluindo sua tática até o ponto em que nenhuma empresa estava mais segura contra os seus ataques. Sua lista de ataques inclui desde telefonemas inocentes ao setor de suporte até a incorporação de funcionários importantes para conseguir informações como senhas para obter acesso a grandes sistemas de empresas. Dessa forma ele se tornou uma lenda para a população hacker ao redor do mundo.
• Vladmir Levin: Vladmir Levin, russo, foi preso pela Interpol depois de vários meses de investigação por ter conseguido transferir 10 milhões de dólares de contas bancarias, do CitiBank.

Esses foram só alguns casos a lista de casos famosos e bastante grandes.Em ambos os casos apresentados foi explorada e ingenuidade das pessoas e falta de boas praticas de segurança.

Como se proteger dela?

• Bom senso: A vítima deve ficar sempre bem atenta ao receber qualquer tipo de abordagem, seja por telefone, e-mail, carta ou até mesmo pessoalmente, onde um pessoa (atacante) tenta o induzir a fornecer informações confidenciais pessoais e até mesmo sobre a empresa em que trabalha.
• Informações sensíveis: Deve-se sempre estar antenado quando lhe for solicitado informações sensíveis como, por exemplo, números de cartões de crédito, senhas e etc. por pessoas estranhas. A vítima antes de tudo deve verificar a autenticidade da ligação que esta recebendo, do crachá que o atacante apresentou e etc.
• Solicitações pela internet: Nunca fornecer informações pessoais, de empresas e etc antes de identificar e constatar a autenticidade do pedido. Por várias vezes, vítimas recebem e-mails contendo links falsos, informações não verdadeiras ou até mesmo solicitações de cadastro em empresas fantasmas. Para não cair nestas armadilhas a vítima deve, por exemplo, entrar em contato com a instituição que lhe fez a solicitação de cadastro, como por exemplo bancos, receita federal e etc, para garantir assim uma autenticidade do pedido, nunca clicar sobre links recebidos através de spams e etc.
• Treinamento: E vital empresas fornecerem treinamento para seus funcionários, fim de evitar a vazão de informações sobre a estrutura da empresa.O treinamento, estabelecimento da política de segurança da informação na empresa, baseia-se em educar os funcionários a sempre certificar-se de que a pessoa a quem vai fornecer as informações é realmente quem diz ser, a tomarem cuidado com o lixo pois este é uma grande fonte de informações, desconfiarem de pessoas em chats e etc. Esta política de segurança da informação da empresa deve conter dentre outros tópicos, planos e ações de segurança como, por exemplo, plano de proteção física, continuidade dos negócios, análise de riscos, ações de engenharia, plano de contingência, plano de conscientização de todos os colaboradores, mesmo os terceirizados e etc. Basicamente tudo se resume em reeducar toda a corporação a fim de implantar uma nova cultura cem por cento abrangente, cem por cento, pois qualquer falha põe novamente a corporação em risco iminente.
• Segurança Física: Permitir o acesso a dependências de uma organização apenas às pessoas devidamente autorizadas, bem como dispor de funcionários de segurança a fim de monitorar entrada e saída da organização.
• Certifique-se de que a pessoa e realmente quem diz ser: sempre peça ao menos 1 confirmação verbal e ou escrita(assinada) quando for fazer algum tipo de troca de informações.
• Fique atento para qualquer abordagem: seja via telefone, seja através de um e-mail, onde uma pessoa (em muitos casos falando em nome de uma instituição) solicita informações (principalmente confidenciais) a seu respeito. Procure não fornecer muita informação e não forneça, sob hipótese alguma, informações sensíveis, como senhas ou números de cartões de crédito. Nestes casos e nos casos em que receber mensagens, procurando lhe induzir a executar programas ou clicar em um link contido em um e-mail ou página é extremamente importante que você, antes de realizar qualquer ação, procure identificar e entrar em contato com a Instituição envolvida, para certificar-se sobre o caso.

A melhor arma contra a engenharia social é a informação. De nada adiante as empresas usarem sistemas ultra-protegidos se seus funcionários não tiverem ciência dos golpes que podem sofrer (repare que neste caso, os golpes de engenharia social podem ocorrer não só pela Internet, mas principalmente no próprio ambiente de trabalho). No caso dos usuários domésticos, os pais devem informar a seus filhos sobre os perigos existentes e de igual forma, devem tomar cuidado quando estiverem navegando na Internet.

Fica a nota, engenharia social não só ocorre no mundo virtual, mas também no mundo real, como minha avó diz: pilantras e salafrários tem em tudo que e beco e buraco de rato.

Links e Referências:

http://www.vivaolinux.com.br/artigo/Entendendo-o-que-e-Engenharia-Social/?pagina=1
http://www.espacoacademico.com.br/043/43amsf.htm
http://pt.kioskea.net/contents/attaques/ingenierie-sociale.php3
http://www.baixaki.com.br/info/1078-cuidado-com-a-engenharia-social.htm
http://www.infowester.com/col120904.php
http://www.istf.com.br/vb/etica-e-comportamento/7101-como-se-proteger-de-engenharia-social.html
http://www.forumseguranca.org.br/artigos/engenharia-social-o-ciber-crime-sem-computador

Leitura complementar:

Cartilha da CERT sobre fraudes na internet.
ENGENHARIA SOCIAL Um Perigo Eminente.
Livro A Arte de Enganar, Autor: Kevin D. Nitnick, William L. Simon, Editora: Pearson
Livros de psicologia e PNL.

The post Entendendo a engenharia social appeared first on 0fx66.

O comando dd(diga-se de passagem significa de direct copy) é um clássico dos ambientes Unix-Like, com ele você pode fazer uma copia exata de um arquivo, ou seja uma copia bit a bit. Sintaxe básica:

$dd if=origem of=destino

Por exemplo:

bash-3.1$ ls -la
total 5272
drwxrwxrwx   2 v0rtex users    4096 2010-02-07 18:23 .
drwx--x--x 116 v0rtex users    4096 2010-02-07 18:03 ..
-rwxr-xr-x   1 v0rtex users 5375842 2007-12-25 21:04 05 - Whole Lotta Love.mp3
bash-3.1$ dd if=05\ -\ Whole\ Lotta\ Love.mp3 of=whole_lotta_love.mp3
10499+1 registros de entrada
10499+1 registros de saída
5375842 bytes (5,4 MB) copiados, 0,0682746 s, 78,7 MB/s
bash-3.1$ ls -lh
total 11M
-rwxr-xr-x 1 v0rtex users 5,2M 2007-12-25 21:04 05 - Whole Lotta Love.mp3
-rw-r--r-- 1 v0rtex users 5,2M 2010-02-07 18:23 whole_lotta_love.mp3

Foi feita uma copia do arquivo “05\ -\ Whole\ Lotta\ Love.mp3″ com o nome whole_lotta_love.mp3

Dicas de uso

Copiando um HD para um arquivo.

# dd if=/dev/sda of=~/backup_hd.img

Com isso será feita uma copia exata do hd dentro do diretório do root(#) com o nome “backup_hd.img”. Se quiser restaurar o “backp_hd.img” no /dev/sda2(lembre o sda2 deve ter pelo menos o mesmo tamanho do arquivo “backup.hd” se não os resultados poderão ser desastrosos.

# dd if=backup_hd.img of=/dev/sda2

Copiando HD para HD:

#dd if=/dev/sda1 of=/dev/sda2

Com isso será feita copia do /dev/sda1 para o /dev/sda2. Fazendo uma copia do hd para um arquivo compactado:

dd if=/dev/sda1 | gzip > backup_hd.img.gz

Para descompactar dentro de outro HD use:

# gzip -d -c backup_hd.img.gz | dd of=/dev/sda2

Criar um arquivo .iso:

#dd if=origem of=destino.iso

Para visualizar progresso de cópia de arquivos, vá em outro terminal e execute:

$ watch df -h

Para converter todos as letras maiúsculas de um documento para letras minúsculas:

$dd if=ficheiro1 of=ficheiro2 conv=lcase

Se quisermos converter todas as letras do ficheiro2 para maiúsculas:

$dd if=ficheiro2 of=ficheiro3 conv=ucase

Para zerar(formatar) o seu HD:

# dd if=/dev/zero of=/dev/hda

Gerar senhas de forma (pseudo) aleatória:

$ dd if=/dev/random bs=1 count=8 | base64 -

Referências:

man DD

Como copiar a imagem de um HD para outro usando o Linux:

Comando dd – Truque para visualizar progresso de cópia de arquivos:

Tutorial clonas HD com dd.

Via @Dalton Barreto

[]‘s

The post Usando o DD appeared first on 0fx66.

–=[ Introdução

O Algoritmo de escalonamento é o coração de um Kernel. Existem muitos algoritmos e a eficiência de cada um deles depende do tipo de aplicação que será executada. O Linux, por ser voltado para o computador pessoal, executa em sua maioria, tarefas que interagem com o usuário. Portanto o algoritmo volta-se principalmente para sistemas interativos. Aqui, discutirei em linhas gerais, o funcionamento do algoritmo de escalonamento do kernel 2.4 e suas desvantagens em relação ao do kernel 2.6.

--=[ Kernel 2.4

--=--=[ Breve descrição do funcionamento do algoritmo de escalonamento

O escalonador do Linux divide o tempo de CPU em Eras (epochs). Em cada Era, cada processo tem um time-quantum que especifica o tempo que o processo vai adquirir de CPU durante a Era atual. Quando o time-quantum de um processo acaba, o escalonador é chamado e outro processo começa a rodar.

Uma Era termina quando todos os time-quantum dos processos ativos acabam. Então a lista ligada dos processos é completamente varrida, e para cada processo, é calculado uma nova prioridade e um novo time-quantum. Por este motivo, o algoritmo de escalonamento do kernel 2.4 tem a ordem de O(n) no número de processos ativos. O fator linear do algoritmo vem diretamente do fato de que o acesso à lista ligada é linear, e também da necessidade de se recalcular a prioridade de cada processo entre cada mudança de Era, porém como veremos no kernel 2.6 isto pode ser feito no momento em que se insere o processo na lista.

Os processos ativos dividem-se em duas listas ligadas usadas pelo escalonador. Uma guarda os processos que ainda não extinguiram todo o seu time-quantum designado para a Era atual e estão esperando para serem escalonados, chamada run-queue enquanto a outra guarda os processos que já extinguiram o seu time-quantum e estão esperando para serem escalonados na próxima era, chamada expired-queue.

--=--=[ Tipos de Processos

Existem 2 tipos básicos de processos: Processos de Tempo Real e os processos convencionais. Os processos de Tempo Real são processos que requerem respostas em tempos determinados. Para isso eles precisam de um maior determinismo do sistema e portanto recebem maior prioridade. Estes tipos de processos recebem uma prioridade que é sempre maior que a dos outros processos convencionais e esta prioridade não muda depois que o processo começa a rodar.

Os processos convencionais recebem uma prioridade que muda conforme a necessidade e no caso do kernel 2.4, basicamente a prioridade muda conforme a quantidade de time-quantum não usada pelo processo em seu último escalonamento, o que faz com que processos IO-Boud recebam maior prioridade (pois este tipo de processo deixa sempre sobrando algum time-quantum quando vai dormir esperando um evento de IO).

--=--=[ Quem deve executar primeiro ?

Uma das principais tarefas do escalonador é fazer a escolha dentre os processos na lista run-queue de qual processo executar primeiro. A escolha é feita pegando da lista run-queue o processo com o maior fator Goodness que é calculado da seguinte maneira:

• Goodness = 0 Se o processo acabou o seu time-quantum. A menos que este processo seja o primeiro processo na lista run-queue e todos os outros processos tenham também acabado seu time-quantum , este processo não será selecionado agora.
• 0 < Goodness < 1000 Se o processo eh convencional e ainda não acabou com seu time-quantum, Goodness é a soma da prioridade do processo com o que resta do seu time-quantum somado com 1.
• Goodness >= 1000 Se o processo é de Tempo Real, seu Goodness é a soma de 1000 com sua prioridade.

Perceba que para fazer esta escolha, todos os processos são percorridos e é calculado o fator Goodness de cada um, o que também implica uma ordem de O(n) ao algoritmo de escalonamento.

--=--=[ Sistemas Multiprocessados

Além da escolha de qual processo rodar primeiro, o escalonador deve escolher também (num sistema multiprocessado) em qual CPU o processo vai rodar. Para melhor utilizar a memória Cache, o kernel 2.4 tenta escolher a CPU no qual o processo já estava rodando. Mas isso pode causar um overload de uma CPU enquanto outras estão ociosas. Então essa escolha é feita usando um fator que leva em conta o tamanho da memória cache do processador e sua frequência. Baseado nesse fator o escalonador decide se vale ou não a pena colocar o processo no mesmo processador. Porém ainda assim, no Kernel 2.4, existe uma situação em que um processo pode ficar 'pulando' de uma CPU para outra constantemente, desperdiçando a memória cache. Este já era um bug conhecido a tempos.

--=--=[ Performance do Kernel 2.4: Desvantagens

• O Algoritmo não é escalável: Conforme aumenta o número de processos ativos, aumenta o overhead no escalonamento. O kernel leva mais tempo pra decidir qual processo rodar, diminuindo o desempenho do sistema.
• Estratégia adotada para processos do tipo IO-Bound não é ótima: Dar preferência aos processos do tipo IO-Bound é uma boa estratégia, mas ela não é perfeita. Imagine que você tenha um processo rodando em background como um banco de dados que a todo momento precisa ler dados do HD, porém ele não precisa ter um tempo de resposta rápido. Com este algoritmo, este tipo de processo vai levar vantagem sobre os outros que não são IO-Bound. Outro problema acontece quando um processo que é CPU-Bound precisa também interagir rapidamente com o usuário, este tipo de processo vai ter menos prioridade por ser CPU-Bound.
• Kernel não é preemptivo: No kernel 2.4 e anteriores, para cada operação de escalonamento e context-switch um mutex-lock global precisa ser adquirido antes de entrar na seção crítica do código. Esta seção crítica é na verdade o código completo do escalonador. Assim, num sistema multiprocessado, apenas um processador podia executar o escalonador por vez.

O mutex-lock global impede que dois ou mais processadores executem o escalonador ao mesmo tempo e isso pode representar perda de tempo de processamento, pois os processadores que estão tentando adquirir o mutex vão ter que esperar até o mutex ser liberado. Além disso, durante a execução do escalonador as interrupções são desligadas, e portanto o kernel não é preemptivo. Durante uma chamada de sistema, o código executado no espaço de kernel não pode ser interrompido. Por exemplo, por um processo de alta prioridade (pode ser de Tempo Real) que acabou de acordar e precisa executar na frente de qualquer outro tipo de processamento.

Tudo isso traz péssimas implicações para processos de Tempo Real, pois diminui o determinismo da prioridade de execução de um processo de Tempo Real.

--=[ Kernel 2.6 - Mudanças

--=--=[ Objetivos

Ao se projetar um novo escalonador para o kernel do linux, mantendo as boas características que o kernel 2.4 trazia e adicionando novas e interessantes, os objetivos principais foram os seguintes:

• Boa performance de interatividade, mesmo durante uma sobrecarga de uso de CPU: Se o usuário clica então o sistema deve reagir instantaneamente e executar a tarefa do usuário de forma suave.
• Justiça: Nenhum processo deixa de receber ao menos um pequeno pedaço de tempo da CPU e nenhum processo recebe injustamente um grande pedaço de tempo da CPU. Respeitando as prioridades de cada processo.
• Prioridades: Tarefas menos importantes recebem prioridades menores, tarefas mais importantes recebem prioridades altas.
• Eficiência em ambiente multiprocessado: Nenhuma CPU deve ficar ociosa se existe trabalho a fazer.
• Afinidade de CPU em ambiente multiprocessado: Processos que rodaram numa CPU têm afinidade a ela, e assim que possível, permanecer executando na CPU em que já foi executada. Nenhum processo deve ficar trocando de CPU muito frequentemente.

As novas características que chamam mais atenção são as seguintes:

• Escalonamento completo usando um algoritmo O(1): Sistema muito mais escalável. O número de processos executando não afeta o desempenho do kernel.
• Kernel Preemptivo: Escalabilidade perfeita num ambiente multiprocessado. Não existe mais nenhum mutex-lock global para proteger a área de código do escalonador. Existe agora 1 lista de processos ativos (run-queue) por CPU, permitindo o acesso em paralelo às run-queues sem a necessidade de mutex.
• Escalonamento tipo Batch: Uma grande porção dos processos CPU-Bound se beneficiam da maneira Batch de escalonamento, onde os time-quantum são grandes e os processos são escalonados por round-robin. O novo escalonador designa este tipo de escalonamento (Batch) para os processos com baixa prioridade, e a nova política de prioridade dinâmica designa menores prioridades quanto mais CPU-Bound for o processo.
• Sistema mais confiável para processos Real Time: O fato do kernel ser Preemptivo e o algoritmo de escalonamento ser O(1) melhora o comporta mento do sistema em relação à dar prioridade às tarefas Real Time, pois agora uma chamada de sistema feita por uma tarefa de prioridade menor pode ser interrompida por uma tarefa de maior prioridade para que ela entre em execução imediatamente.

--=--=[ Vetor de Prioridades

Ao invés de usar só uma lista ligada gigante com todos os processos ativos, foi usado uma outra abordagem na qual temos um vetor de tamanho fixo cujo tamanho é o número de níveis de prioridades. Cada elemento do vetor aponta para uma lista ligada de processos que tem a mesma prioridade.

Essa é a estrutura básica do novo escalonador: A lista run-queue, agora é um vetor de prioridades ordenado e cada CPU têm sua própria run-queue. O vetor de run-queue contém todas as tarefas que têm afinidade com a CPU e ainda têm time-quantum para executar, enquanto o vetor de expired-queue contêm as tarefas que tem afinidade com a CPU e que expiraram seu time-quantum, de maneira que este vetor expired-queue (assim como o run-queue) também é mantido ordenado.

A estrutura do array de prioridades é descrita como:

struct prio_array {
    int nr_active;                       /* number of tasks */
    unsigned long  bitmap[BITMAP_SIZE];  /* priority bitmap */
    struct list_head queue[MAX_PRIO];    /* priority queues */
};

MAX_PRIO é número de níveis de prioridades do sistema. Para cada prioridade é mantida uma lista ligada dos processos que estão naquela prioridade. O escalonador escolhe para executar primeiro a lista dos processos no maior nível de prioridade e executa-os em Round-Robin.

Existe um número fixo de níveis de prioridades, e para escolher um novo processo basta pegar o próximo elemento do vetor de prioridades, portanto, o algoritmo neste caso é O(1), pois temos um tempo constante executado em cada escolha de qual processo executar.

--=--=[ Recalculando os time-quantum

No 2.4, cada vez que terminava uma Era, percorria-se todos os processos recalculando os time-quantum de cada um. No kernel 2.6, o calculo do time-quantum ocorre quando o processo termina todo seu time-quantum da Era atual. Assim, antes de ser passado para o vetor de expired-queue, seu time-quantum e também sua prioridade são recalculados. O vetor de expired-queue é mantido ordenado e contém os processo com os time-quantum já calculados da próxima Era. Quando a Era atual termina, basta trocar os ponteiros do vetor de run-queue por expired-queue e o novo vetor de processos ativos está pronto para ser executado.

A abordagem do kernel 2.6 é uma mistura de lista de prioridades com escalonamento por Round-Robin. Os processos de uma mesma prioridade são escalonados por Round-Robin, mas as prioridades maiores são escalonadas primeiro.

--=--=[ Resposta Rápida

Uma das coisas que mais deixam os usuários do sistema irritados, é a demora no tempo de resposta de um comando. No kernel 2.6 este problema é evitado da seguinte maneira: ao invés de aumentar a prioridade de processos IO-Bound, diminui-se a prioridade dos processos que querem consumir muito tempo de CPU quando tempo de CPU está escasso.

--=[ Conclusão

Essas foram as principais mudanças do kernel 2.4 para o 2.6. O Linux sempre foi um sistema operacional voltado para o usuário de Computador Pessoal e por isso conceitos como processamento de tarefas de Tempo Real, escalabilidade no número de CPUs e no número de processos ativos não foram prioridades no desenvolvimento do seu Kernel.

Um usuário de PC rodando o kernel 2.4 não vai notar a menor diferença quando fizer o upgrade para o 2.6, visto que seu PC só tem 1 processador e ele só roda no máximo, digamos, 100 processos em paralelo. Além disso não se usa o Linux como um Sistema Operacional para controlar um sistema de Tempo Real, como um piloto automático de um avião ou um sistema de controle de temperatura de uma usina nuclear. O Linux não foi projetado para esse tipo de coisa, mas com essas mudanças se consegue chegar mais perto do que seria um sistema mais escalável e confiável.

Segundo Theodore Tso (um dos desenvolvedores do kernel), na conversa que teve hoje com os alunos da computação no IC (Instituto de Computação - Unicamp), as futuras versões do kernel caminham em direção a se ter mais robustez para aplicações de Tempo Real, adicionando mais predictabilidade e determinismo à execução de tarefas que exigem alta prioridade.

--=[ Fontes

1) Livro: Understanding the Linux Kernel , By Daniel P. Bovet & Marco Cesati , Editora O'Reilly

2) Livro: Linux Kernel Development , By Robert Love , Editora Sams

3) Email:From: Ingo Molnar
To: linux-kernel-mailing-list
Subject: [announce] ultra-scalable O(1) SMP and UP scheduler
Date: Fri, 4 Jan 2002 03:19:10 +0100 (CET)

Este email pode ser encontrado em:
http://kerneltrap.org/node/341

4) web: http://www.hpl.hp.com/research/linux/kernel/o1.php

5) web: http://www.linuxgazette.com/node/9746

6) web: http://www.faqs.org/docs/kernel_2_4/lki-2.html

_EOF_

The post Algoritmo de escalonamento: Kernel 2.4 Versus 2.6 appeared first on 0fx66.

# mount -o loop arquivo.iso /diretório/de/montagem

Agora vou mostrar como montar arquivos de outro formato como, primeiramente é necessário converter em .iso, por exemplo. Para converter BIN e CUE em ISO, basta usar o bchunk(se tiver ele em sua maquina basta instala, instalação simples com o clássico ./configure&&make&&make install):

$ bchunk arquivo.bin arquivo.cue novoarquivo.iso

Para converter NRG para ISO, instale o nrg2iso (se tiver ele em sua maquina basta instala, instalação simples com o clássico ./configure&&make&&make install):

nrg2iso arquivo.nrg novaimagem.iso

Para converter MDF em ISO, instale o mdf2iso e execute:

mdf2iso arquivo.mdf novaimagem.iso

Para converter IMG para ISO, instale o ccd2iso e execute:

ccd2iso imagem.img imagem.iso

[]‘s

The post Montando arquivos NRG, MDF, IMG, BIN, CUE no Linux appeared first on 0fx66.

Neste texto são apresentadas diversas dicas para o uso do scanner nmap.

Usando nmap para descoberta de host.

# nmap -sL 128.230.18.30-35
Host npropane.syr.edu (128.230.18.30) not scanned
Host helpeiam1.syr.edu (128.230.18.31) not scanned
Host tracker5-18.syr.edu (128.230.18.32) not scanned
Host mirage2.syr.edu (128.230.18.33) not scanned
Host backup01-18.syr.edu (128.230.18.34) not scanned
Host cwis01.syr.edu (128.230.18.35) not scanned
Nmap done: 6 IP addresses (0 hosts up) scanned in 6.628 seconds

Utilizando como banner scan, escaneado uma faixa de ips, procurando pela porta 25 rodando um e-mail.

# nmap -sV 12.150.145.135-139 -p25 | grep IMail -B 3
Interesting ports on 138.145.static.conninc.com (12.150.145.138):
PORT   STATE SERVICE VERSION
25/tcp open  smtp    IMail NT-ESMTP 6.06 28262-4
--
Interesting ports on 139.145.static.conninc.com (12.150.145.139):
PORT   STATE SERVICE VERSION
25/tcp open  smtp    IMail NT-ESMTP 6.06 28263-5

Usando como banner scan, escaneado uma faixa de ips,procurando pela porta 25 rodando um e-mail,e salvando a saída em um arquivo

# nmap -sV 12.150.145.137-139 -p25 | grep IMail -B 3 >> nmap.txt
# cat nmap.txt
Interesting ports on 138.145.static.conninc.com (12.150.145.138):
PORT   STATE SERVICE VERSION
25/tcp open  smtp    IMail NT-ESMTP 6.06 29384-6
Interesting ports on 139.145.static.conninc.com (12.150.145.139):
PORT   STATE SERVICE VERSION
25/tcp open  smtp    IMail NT-ESMTP 6.06 29385-7

Usando a mais intensiva opção de checagem de versão.

# nmap -sV --version-all 128.230.18.35 -p 80
Starting Nmap 4.50 ( http://insecure.org ) at 2008-01-17 22:37 EST
Interesting ports on cwis01.syr.edu (128.230.18.35):
PORT   STATE SERVICE VERSION
80/tcp open  http    Apache httpd

Usando nmap como scanner de banners, escaneando uma faixa aleatória de IPs procurando pela porta 21 aberta, rodando o ProFTP.

# nmap -sV -iR 1500 -p21 | grep ProFTPD -B 3
Starting Nmap 4.50 ( http://insecure.org ) at 2008-01-17 17:41 EST
Interesting ports on www.buford-thompson.net (161.58.19.143):
PORT   STATE SERVICE VERSION
21/tcp open  ftp     ProFTPD

Usando o nmap para descobrir o sistema operacional do host

# nmap -PN -O --osscan-limit 38.117.198.214 | grep Running
Running (JUST GUESSING) : ZyXEL ZyNOS (96%)

Usando nmap como tracerouter verificando a porta aberta é contando os hops

# nmap --traceroute 128.230.18.35
Starting Nmap 4.50 ( http://insecure.org ) at 2008-01-17 22:27 EST
Interesting ports on cwis01.syr.edu (128.230.18.35):
Not shown: 1656 closed ports, 49 filtered ports
PORT      STATE SERVICE
80/tcp    open  http
TRACEROUTE (using port 80/tcp)
HOP RTT   ADDRESS
1   2.89  192.168.1.1
2   12.18 10.114.0.1
3   9.52  172.22.5.13
4   12.33 172.22.5.69
5   10.86 172.22.33.73
6   12.48 172.22.32.106
7   15.21 12.86.87.29
8   41.73 tbr2.attga.ip.att.net (12.122.96.74)
9   41.78 tbr1.dlstx.ip.att.net (12.122.2.89)
10  73.50 ggr3.dlstx.ip.att.net (12.123.16.201)
11  42.87 br2-a3120s2.attga.ip.att.net (192.205.33.206)
12  66.36 66.192.240.226
13  74.74 64-132-176-170.static.twtelecom.net (64.132.176.170)
14  77.85 128.230.61.1
15  74.08 c6509r-srv.syr.edu (128.230.61.58)
16  73.36 cwis01.syr.edu (128.230.18.35)
Nmap done: 1 IP address (1 host up) scanned in 111.295 seconds

Usando nmap para testar o estado de uma porta.

# nmap --reason 128.230.18.35 -p 21
Starting Nmap 4.50 ( http://insecure.org ) at 2008-01-17 22:31 EST
Interesting ports on cwis01.syr.edu (128.230.18.35):
PORT   STATE    SERVICE REASON
21/tcp filtered ftp     no-response

Nmap done: 1 IP address (1 host up) scanned in 1.247 seconds

Usando nmap para MAC address spoofing.

# nmap –spoof-mac 08:00:69:02:01:FC -iR 3
Starting Nmap 4.50 ( http://insecure.org ) at 2008-01-17 22:51 EST
Spoofing MAC address 08:00:69:02:01:FC (Silicon Graphics)
Nmap done: 3 IP addresses (0 hosts up) scanned in 3.387 seconds

Fazendo uma varredura com IPs forjado,com uma escolha aleatória de alvos. Pode ser usado um script para gerar Ips a serem usados em: http://www.darkc0de.com/misc/ipgen1.1.py

# nmap -D 198.162.1.100,198.162.1.101 -iR 3
Starting Nmap 4.50 ( http://insecure.org ) at 2008-01-17 23:22 EST
Nmap done: 3 IP addresses (0 hosts up) scanned in 3.082 seconds

[]’s

The post Um pouco mais sobre nmap appeared first on 0fx66.

Sem duvidas este é um dos temas mais interessantes quando tratamos de processadores. A arquitetura de processador descreve o processador que foi usado em um computador. Grande parte dos computadores vêm com identificação e literatura descrevendo o processador que contém dentro de si, arquitetura CISC e RISC.

• A CISC (em inglês: Complex Instruction Set Computing, Computador com um Conjunto Complexo de Instruções), usada em processadores Intel e AMD; suporta mais instruções no entanto, com isso, mais lenta fica a execução delas.
• A RISC (em inglês: Reduced Instruction Set Computing, Computador com um Conjunto Reduzido de Instruções) usada em processadores PowerPC (da Apple, Motorola e IBM) e SPARC (SUN); suporta menos instruções, e com isso executa com mais rapidez o conjunto de instruções que são combinadas.

Um processador CISC (Complex Instruction Set Computer), é capaz de executar várias centenas de instruções complexas, sendo extremamente versátil. Exemplos de processadores CISC são os 386 e os 486. No começo da década de 80, a tendência era construir chips com conjuntos de instruções cada vez mais complexos, mas alguns fabricantes resolveram seguir o caminho oposto, criando o padrão RISC (Reduced Instruction Set Computer ).

Ao contrário dos complexos CISC, os processadores RISC são capazes de executar apenas algumas poucas instruções simples. Justamente por isso, os chips baseados nesta arquitetura são mais simples e muito mais baratos. Outra vantagem dos processadores RISC, é que por terem um menor número de circuitos internos, podem trabalhar com clocks mais altos. Um processador RISC é capaz de executar instruções muito mais rapidamente.

Assim, em conjunto com um software adequado, estes processadores são capazes de desempenhar todas as funções de um processador CISC, compensando as suas limitações com uma velocidade maior de operação. Atualmente, vemos processadores híbridos, que são essencialmente

Processadores CISC, porém que possuem internamente núcleos RISC. Assim, a parte CISC do processador pode cuidar das instruções mais complexas, enquanto que o núcleo RISC pode cuidar das mais simples, nas quais é mais rápido. Parece que o futuro nos reserva uma fusão destas duas tecnologias. Um bom exemplo de processador híbrido é o Pentium Pro.

Arquitetura CISC

CISC (Complex Instruction Set Computer, ou, em uma tradução literal, “Computador com um Conjunto Complexo de Instruções”): é um processador capaz de executar centenas de instruções complexas diferentes sendo, assim, extremamente versátil. Exemplos de processadores CISC são os 386 e os 486 da Intel.

Intel 80486

Os processadores baseados na computação de conjunto de instruções complexas contêm uma micro programação, ou seja, um conjunto de códigos de instruções que são gravados no processador, permitindo-lhe receber as instruções dos programas e executá-las, utilizando as instruções contidas na sua micro programação. Seria como quebrar estas instruções, já em baixo nível, em diversas instruções mais próximas do hardware (as instruções contidas no microcódigo do processador). Como característica marcante esta arquitetura contém um conjunto grande de instruções, a maioria deles em um elevado grau de complexidade.

Examinando do ponto de vista um pouco mais prático, a vantagem da arquitetura CISC é que já temos muitas das instruções guardadas no próprio processador, o que facilita o trabalho dos programadores de linguagem de máquina; disponibilizando, assim, praticamente todas as instruções que serão usadas em seus programas. Os processadores CISC têm a vantagem de reduzir o tamanho do código executável por já possuírem muito do código comum em vários programas, em forma de uma única instrução.

Esta arquitetura processa e trata grandes e complexas instruções, nomeadamente operações de multiplicação e divisão mas também executa e/ou descodifica grandes quantidades de operações, parecendo possuir outro processador pelo facto da maioria dos algoritmos já se encontrarem no processador sendo o seu tempo de restabelecimento praticamente nulo.

A CISC é implementada e guardada em micro-código no processador, sendo difícil modificar a lógica de tratamento de instruções. Esta arquitetura suporta operações do tipo “a=a+b” descrita por “add a,b”, ou seja podem simplesmente utilizar dois operandos para uma única instrução, sendo um deles fonte e destino (acumulador) e permite um ou mais operadores em memória para a realização das instruções. Com isto se comprova a necessidade de abranger um elevado leque de modelos de endereçamento, com acesso direto à memória e com apontadores para as variáveis em memória, armazenados eles próprios (ponteiros) em células de memória.

A complexidade que envolve estes modelos compromete o produto a nível de comercialização e desenvolvimento, limitando ou diminuindo o aumento a frequência de relógio não só pelo tempo de acesso às memórias como devido ao reduzido número de registos.

Porém, do ponto de vista da performance, os CISC’s têm algumas desvantagens em relação aos RISC’s, entre elas a impossibilidade de se alterar alguma instrução composta para se melhorar a performance. O código equivalente às instruções compostas do CISC pode ser escrito nos RISC’s da forma desejada, usando um conjunto de instruções simples, da maneira que mais se adequar. Sendo assim, existe uma disputa entre tamanho do código X desempenho.

A existência de um grande número de registros nas arquiteturas RISC, aliado à evolução da tecnologia dos compiladores dos últimos anos (em especial, na geração de código), vem permitindo representar a maioria das variáveis escalares diretamente em registro, não havendo necessidade de recorrer com tanta frequência à memória. Esta organização não foi contudo economicamente viável nas gerações anteriores de microprocessadores, com destaque para a família da Motorola (M680x0) e, ainda mais antiga, a família da Intel (ix86). Estes processadores dispunham de um menor nº de registros e, consequentemente, uma diferente organização que suportasse eficientemente diversos mecanismos de acesso à memória.

No caso da família M680x0, o programador tinha disponível dois bancos de 8 registros genéricos de 32 bits: um para dados (D) e outro para apontadores para a memória (A), suportando este último banco um variado leque de modos de endereçamento à memória. Apenas um dos registros (A7) é usado implicitamente em certas operações de manuseamento da stack.

A família Intel é mais complexa por não ter variadamente registros de uso genérico. A arquitetura de base dispõe efetivamente de 4 registros para conter operandos aritméticos (A, B, C e D), mais 4 para trabalhar com apontadores para a memória (BP, SP, DI e SI) e outros 4 para lidar com uma memória segmentada (CS, DS, SS e ES; a única maneira de uma arquitetura de 16 bits poder aceder a mais de 64K células de memória). Cada um destes registros não pode ser considerado de uso genérico, pois quase todos eles são usados implicitamente (isto é, sem o programador explicitar o seu uso) em várias instruções (por exemplo, os registros A e D funcionam de acumuladores em operações de multiplicação e divisão, enquanto o registro C é usado implicitamente como variável de contagem em instruções de controle de ciclos). A situação complica-se ainda mais com a variação da dimensão dos registros na mesma família (de registros de 16 bits no i286 para registros de 32 bits no i386), pois o formato de instrução foi concebido para distinguir apenas operandos de 8 e de 16 bits, e um Bit bastava; para garantir compatibilidade ao longo de toda a arquitetura, os novos processadores têm de distinguir operandos de 8, 16 e 32 bits, usando o mesmo formato de instrução.

Arquitetura RISC

Reduced Instruction Set Computer ou Computador com um Conjunto Reduzido de Instruções (RISC), é uma linha de arquitetura de computadores que favorece um conjunto simples e pequeno de instruções que levam aproximadamente a mesma quantidade de tempo para serem executadas. A maioria dos microprocessadores modernos são RISCs, por exemplo DEC Alpha, SPARC, MIPS, e PowerPC. O tipo de microprocessador mais largamente usado em desktops, o x86, é mais CISC do que RISC, embora chips mais novos traduzam instruções x86 baseadas em arquitetura CISC em formas baseadas em arquitetura RISC mais simples, utilizando prioridade de execução.

SPARC usam arquitetura risc

Os processadores baseados na computação de conjunto de instruções reduzido não tem micro-programação, as instruções são executadas diretamente pelo hardware. Como característica, esta arquitetura, além de não ter microcódigo, tem o conjunto de instruções reduzido, bem como baixo nível de complexidade.

A ideia foi inspirada pela descoberta de que muitas das características incluídas na arquitetura tradicional de processadores para ganho de desempenho foram ignoradas pelos programas que foram executados neles. Mas o desempenho do processador em relação à memória que ele acessava era crescente. Isto resultou num número de técnicas para otimização do processo dentro do processador, enquanto ao mesmo tempo tentando reduzir o número total de acessos à memória.

Esta arquitetura suporta operações do tipo “a=b+c” descrita por “add a,b,c”, ou seja, podem especificar três operandos para uma única instrução, mas exclusivamente se estes forem registos, originando em situação contrária (operadores em memória) um atraso provocado pela introdução de ações extra no processador que se reflete no funcionamento encadeado (piplining).

Para garantir rapidez e eficiência do sistema, pretende-se que os operadores sejam acedidos á velocidade de funcionamento do processador, logo se justifica a utilização dos registos, e para que a representação de todas as variáveis para processamento sejam apresentadas como registos, tem que se garantir um número elevado destes, assegurando-se atualmente a maioria das variáveis escalares pela utilização de 32 registos genéricos que caracterizam a maioria da tecnologia dos compiladores atuais.

Na representação de variáveis estruturadas, a sua atribuição não se apresenta de forma tão linear, a título de exemplo, um inteiro nesta arquitetura ocupa 32 bits, os reais 32 ou 64 bits (consoante a precisão) e cada célula de memória contem apenas 8 bits, logo cada variável ocupa várias células, portanto uma operação básica entre duas variáveis estruturadas implicava várias operações entre registos (efetuadas parcialmente, e implicavam elevado número de operações e registos), para isso utilizam um indicador (.align x) para alinhar a informação apenas em localizações de memória que começam por endereço par para 16 bits (x=1) ou então múltiplos de 4 para 32 bits (x=2).

O comprimento das instruções em arquiteturas RISC tiveram que ser fixados devido a adoção de tecnologias como o pipilining e a maior facilidade e simplicidade e consequente redução do tempo de execução, estando o dimensionamento determinado por 32 bits para permitir especificar os três operandos.

Características comuns à maior parte dos processadores RISC:

• número de instruções limitado;
• codificação de instruções em uma palavra de tamanho fixo;
• execução sem micro-código;
• altas taxas de execução (próximas a 1 instrução/ciclo)
• uso intenso de pipelines;
• poucos modos de endereçamento;
• operações envolvendo a memória principal restritas a transferências (LOAD, STORE);
• operações lógicas e aritméticas entre registradores, tipicamente com instruções de três endereços.

Instruções complexas: apenas incluir quando o benefício no desempenho compensar a degradação de velocidade;

Uso de transistores: área de VLSI pode ser utilizada para novas instruções ou para aumentar número de registradores, incluir memória cache no chip do processador, adicionar unidades de execução;

Uso de microcódigo: deve ser evitado, pois o overhead associado ao tempo de acesso a microinstruções na memória de controle passou a ser considerável a partir do momento em que a tecnologia da memória principal passou de núcleos de ferrite para dispositivos semicondutores;

Papel do compilador: deve substituir eficientemente as operações complexas eliminadas do hardware. Para atingir este objetivo, otimização é fundamental; projeto de compiladores realizado juntamente com o projeto dos processadores.

RISC é também a arquitetura adotada para os processadores dos videogames modernos, que proporcionam um hardware extremamente dedicado somente à execução do jogo, tornando-o muito mais rápido em relação a micro computadores com mais recursos, embora com processador x86.

RISC versus CISC

Todos os processadores dispõem de instruções de salto “de ida e volta”, normalmente designados de instruções de chamada de sub-rotinas: nestas, para além de se alterar o conteúdo do registro PC como qualquer instrução de salto, primeiro guarda-se o endereço de instrução que segue a instrução de salto ( e que se encontra no PC); nas arquiteturas CISC este valor é normalmente guardado na stack; nas arquiteturas RISC esse valor é normalmente guardado num registro.

Conjunto de instruções de um processador RISC: o conjunto de instruções que cada processador suporta é bastante variado. Contudo é possível identificar e caracterizar grupos de instruções que se encontram presentes em qualquer arquitetura.

Para transferência de informação: integram este grupo as instruções que transferem informação entre registros e a memória (load/store), entre registros (simulado no Assembler do MIPS, e implementando com uma soma com o registro 0), diretamente entre posições de memória (suportado por exemplo, no M680x0, mas não disponível em qualquer arquitetura RISC), ou entre registros e a stack, com incremento/decremento automático do sp (disponível em qualquer arquitetura CISC, mas incomum em arquiteturas RISC);

Operações aritméticas, lógicas, …: soma, subtração e multiplicação com inteiros e fp, e operações lógicas AND, OR, NOT, ShiftLeft/Right são as mais comuns; alguns processadores suportam ainda a divisão, quer diretamente por hardware, quer por microprogramação.

Acesso a operandos em memória em CISC e RISC: Uma das consequências do fato das arquiteturas CISC disporem de um menor número de registros é a alocação das variáveis escalares, em regra, a posições de memória, enquanto que nas arquiteturas RISC, a regra era a alocação a registros. Atendendo ao modelo de programação estruturada tão em voga nos anos 70, ao fato da maioria das variáveis escalares serem locais a um dado procedimento, e à necessidade do modelo de programação ter de suportar o aninhamento e recursividade de procedimentos, as arquiteturas CISC necessitavam de um leque rico de modos de endereçamento à memória, para reduzir o gap semântico entre uma HLL e a linguagem máquina.

Resume-se aqui, as principais diferenças entre as arquiteturas CISC e RISC, nas facilidades de acesso a operandos que se encontram em memória:

CISC: grande riqueza na especificação de modos de endereçamento; exemplo do i86: modo absoluto; por registro indireto –(R), – (SP), (SP)+; por registro base –(Rb)+desloc8,16,32, (Rb)+(R), (Rb)+desloc8,16,32; com acessos indiretos à memória, isto é, com apontadores para as variáveis sem memória armazenados em células de memória.

RISC: apenas em operações load/store e apenas 1 ou 2 modos; exemplo do MIPS: apenas (R)+desloc16.

Operações lógicas e aritméticas em CISC e RISC: Duas grandes diferenças se fazem notar entre estes 2 modelos: na localização dos operandos neste tipo de operações, e o nº de operandos que é possível especificar em cada instrução.

CISC: 1 ou mais operandos em memória (máx 1 no i86 e M68K); nem sempre se especificam 3 operandos (máx 2 no i86 eM68K).

RISC: operandos sempre em registros; 3 operandos especificados (1 dest, 2 fontes).

Como pode ser visto no gráfico acima, a quantidade de etapas pela qual a instrução nos processadores de arquitetura CISC e maior que as RISC, causando o efeito de demora para as instruções serem processadas.

Com o aparecimento de linguagens como FORTRAN, Algol, Simula, Pascal e C em 1950-1970 ajudou ao desenvolvimento de metodologias estruturas de programas, a construções lingüísticas de mais alto nível, e a maior quantidade de pessoas a escreverem programas, exigiam suporte eficiente e adequado, para poupar o trabalho de geração de código, pelos compiladores daquelas linguagens. Esta pressão viria a influenciar decisivamente a maioria dos processadores, ao ponto, de exemplo ilustrativo, chegar a haver um CPU que suportava diretamente o tipo de dados ‘lista ligada’, oferecendo instruções máquina para ‘inserir’ e ‘remover’ elementos de uma lista em memória. Instruções de grande complexidade e um grande número de instruções, são os dois principais aspectos que caracterizam um modelo CISC (Complex Instruction Set Computer). Os processadores atuais incorporados no computador pessoal (PC – Personal Computer) seguem esta filosofia.

Arquitetura Híbrida

Apesar de por questões de Marketing, muitos fabricantes ainda venderem seus chips, como sendo “Processadores RISC”, não existe praticamente nenhum processador atualmente que siga estritamente uma das duas filosofias. Tanto processadores da família x86, como o Pentium II, Pentium III e AMD Athlon, quanto processadores supostamente RISC, como o MIPS R10000 e o HP PA-8000, ou mesmo o G4, utilizado nos Macintoshs misturam características das duas arquiteturas, por simples questão de performance. Por que ficar de um lado ou de outro, se é possível juntar o melhor dos dois mundos? A última coisa que os fabricantes de processadores são é teimosos, sempre que aparece uma solução melhor, a antiga e abandonada.

Um hibrido

Examinando de um ponto de vista um pouco mais prático, a vantagem de uma arquitetura CISC é que já temos muitas das instruções guardadas no próprio processador, o que facilita o trabalho dos programadores, que já dispõe de praticamente todas as instruções que serão usadas em seus programas. No caso de um chip estritamente RISC, o programador já teria um pouco mais de trabalho, pois como disporia apenas de instruções simples, teria sempre que combinar várias instruções sempre que precisasse executar alguma tarefa mais complexa. Seria mais ou menos como se você tivesse duas pessoas, uma utilizando uma calculadora comum, e outra utilizando uma calculadora cientifica. Enquanto estivessem sendo resolvidos apenas cálculos simples, de soma, subtração, etc. quem estivesse com a calculadora simples poderia até se sair melhor, mas ao executar cálculos mais complicados, a pessoa com a calculadora científica disporia de mais recursos.

A ideia de construção de um processador híbrido é bastante interessante, pois faz com que finalmente PCs possam ter um desempenho realmente astronômica. A Intel, porém, errou feio em um detalhe importante do projeto do Pentium Pro: o seu decodificador CISC foi desenvolvido basicamente para trabalhar com código de 32 bits – ou seja, com sistemas operacionais como o Windows NT, OS/2 e Netware. (Nota: o Windows 95 é um sistema operacional híbrido; apesar da Microsoft declarar que se trata de um “sistema operacional de 32 bits”, isto não é totalmente verdade. Grande parte do seu código ainda é de 16 bits de modo a tornar-se compatível com aplicativos escritos para o Windows 3.x).

Isto quer dizer que, se tivermos um Pentium-200 e um Pentium Pro-200, um Windows 3.11 será mais rápido no Pentium e não no Pentium Pro, por mais incrível que possa parecer.

Conclusão: Não vale a pena adquirir um micro baseado no Pentium Pro se você for utilizar MS-DOS, Windows 3.x ou Windows 95. Processadores de outros fabricantes – em especial o 6×86 da Cyrix e o 5K86 da AMD – também possuem arquitetura híbrida CISC/RISC, com a vantagem de possuírem um decodificador otimizado para código tanto de 32 bits quanto de 16 bits. Nos chips atuais, que são na verdade misturas das duas arquiteturas, juntamos as duas coisas. Internamente, o processador processa apenas instruções simples. Estas instruções internas, variam de processador para processador, são como uma luva, que se adapta ao projeto do chip.

As instruções internas de um K6 são diferentes das de um Pentium por exemplo. Sobre estas instruções internas, temos um circuito decodificador, que converte as instruções complexas utilizadas pelos programas em várias instruções simples que podem ser entendidas pelo processador. Estas instruções complexas sim, são iguais em todos os processadores usados em micros PC. é isso que permite que um Athlon e um Pentium III sejam compatíveis entre sí.

O conjunto básico de instruções usadas em micros PC é chamado de conjunto x86. Este conjunto é composto por um total de 187 instruções, que são as utilizadas por todos os programas. Além deste conjunto principal, alguns processadores trazem também instruções alternativas, que permitem aos programas executar algumas tarefas mais rapidamente do que seria possível usando as instruções x86 padrão. Alguns exemplos de conjuntos alternativos de instruções são o MMX (usado apartir do Pentium MMX), o 3D-NOW! (usado pelos processadores da AMD, a partir do K6-2), e o SSE (suportado pelo Pentium III).

Referencias:
https://secure.wikimedia.org/wikipedia/pt/wiki/Processadores
http://br.geocities.com/thiago_ferauche/aulas/arquitetura/CISCxRISC.doc
http://alumni.ipt.pt/~brunobt/CISC_versus_RISC.htm#tabela
http://www.clubedohardware.com.br/printpage/857

Leitura complementar:

http://www.4shared.com/file/226765303/e5326018/Cisc_e_Risc.html
http://www.4shared.com/file/226765412/8e61774a/Plataformas_CISC_e_RISC.html
http://www.guiadohardware.net/artigos/risc-cisc/

[]‘s

The post CISC vs RISC appeared first on 0fx66.

Em um sistema Linux temos uma estrutura de diretórios um pouco mais complexa. Os arquivos ali dispostos, a princípio, parecem estar jogados aleatoriamente nos diversos diretórios existentes. Mas, felizmente, há uma certa ordem é uma lógica fazendo com que cada diretório do sistema tenha uma finalidade específica. Antes de irmos entender os diretórios precisamo dar uma pincelada e algumas informações uteis,que serão bem uteis em breve e também ajuda a entender o motivo dos diretórios(caso você esteja querendo ser um desenvolvedor ou e um).

Diretórios

Primeira coisa com que você precisa se habituar é que no Linux os discos e partições não aparecem necessariamente como unidades diferentes, como o C:, D:, E: do Windows. Tudo faz parte de um único diretório, chamado diretório raiz(root) ou simplesmente “/”.
Dentro deste diretório temos não apenas todos arquivos e as partições de disco, mas também o CD-ROM, drive de disquete e outros dispositivos, formando a estrutura que você vê no gerenciador de arquivos.

Estrutura e hierarquia dos diretórios

/bin - é o diretório que contém o mínimo necessário para funcionar e poder ser manuseado pelo administrador. Serão necessárias ferramentas que se encontram em outros diretórios para que a máquina fique operacional. A maioria dos programas possui o seu arquivo executável neste diretório.

/boot – contém informações para o gerenciador de inicialização do sistema. É aqui que normalmente fica o arquivo contendo o kernel da máquina e informações para o carregador do sistema operacional.

/cdrom – Não é propriamente um diretório, mas sim um link para o diretório /media/cdrom (ponto de montagem do dispositivo leitor de CD/DVD da máquina;

/dev – é o local onde ficam armazenadas as referências aos dispositivos presentes na máquina, para o controle destes dispositivos. Esse diretório contém apontadores para, por exemplo, o drive de disquetes, os discos da máquina, terminais virtuais, portas de acesso seriais e paralelas, etc. Os controladores são automaticamente criados durante a instalação do sistema e posteriormente podem ser criados através do comando MAKEDEV.

• devfs – contém todos arquivos-dispositivos, inclusive para dispositivos que não existem no computador e irá ocupar espaço em disco.
• udev – utilizado a partir do kernel 2.6.12, não ocupa espaço em disco e contém somente os arquivos-dispositivos dos devices presentes na máquina.

/etc – é um dos mais importantes diretórios da máquina. Nele ficam a maioria dos arquivos de configuração e manipulação dos serviços essenciais ao sistema, a maioria dos arquivos de configuração de acesso a rede e de comunicação, arquivos de configuração do Sistema de Janelas X, arquivos de configuração do idioma do sistema, de atualizações, enfim, de muitas funcionalidades da máquina.

/home – contém os diretórios pessoais dos usuários e suas configurações(funciona como a pasta Meu Documentos,no windows).

/lib – é o diretório onde ficam as bibliotecas básicas do sistema. Elas são compartilhadas por diversos programas, principalmente os que se encontram no diretório raiz.

/mnt – é o diretório utilizado para o acesso a dispositivos de mídia, como disquetes e CD-ROM. Ele é utilizado como ponto de montagem para a maioria destes dispositivos.

/proc- Não é bem um diretório. Trata-se de um filesystem virtual, cheio de arquivos virtuais, que na verdade são apenas referências dinâmicas dos procedures (procedimentos) do Kernel Linux, que são alteradas constantemente durante a utilização do sistema; fornece informações sobre o kernel e sobre os processos que estão rodando no momento, além de informações sobre a utilização de alguns dispositivos. Alguns parâmetros do kernel podem ser alterados diretamente nesses arquivos, fazendo com que as modificações passem a valer imediatamente. Esse diretório não ocupa espaço nenhum em disco e as informações ali presentes são geradas apenas quando solicitadas.

/root – Esse é o diretório do superusuário do sistema (pode chamar de administrador se quiser, mas não perto de mim, pois me lembra do termo usado por outro sisteminha (semi)operacional proprietário do qual não gosto muito ;-)). O único usuário do sistema com permissão para realizar qualquer modificação no sistema. Aí você me pergunta: “Mas gmazk, se é uma pasta de usuário, porque não está dentro de /home ?”. E eu explico: conforme você vai ver na minha próxima publicação (a respeito de planejamento do particionamento da maquina e instalação do sistema), é conveniente durante a instalação do sistema, determinar que o diretório /home seja montado em uma partição separada da partição principal (onde estão os demais diretórios do sistema). Se o diretório root estivesse nessa partição separada (dentro de /home) e ocorresse com essa partição, o que costumo chamar de um “momento PUTZ… ferrou!”, a pasta /root também estaria inacessível, e como você já sabe, certas coisas só podem ser feitas no sistema pelo usuário root… Então você não poderia, por exemplo, inicializar o sistema para realizar uma recuperação nessa partição;

/opt – Se verificar o conteúdo deste diretório, MUITO provavelmente ele estará vazio. A ideia inicial deste diretório era armazenar programas que não fizessem parte da distribuição GNU/Linux instalada em seu sistema, porém, esse método de separação quase não é utilizado; Ele pode ser útil por questões de espaço.

/sbin contém ferramentas de interesse do superusuário e que geralmente são usadas por serviços básicos da máquina. Ficam nesse diretório programas como os responsáveis pela carga de módulos do kernel, ativação e interrupção das interfaces de rede, manutenção dos sistemas de arquivos e outras atividades.

/srv – É um diretório que sofre do mesmo problema de esquecimento e solidão que o diretório opt, pois não é utilizado nunca… A ideia inicial era usá-lo para armazenar dados que seriam disponibilizados por qualquer programa servidor que você utilizasse no sistema, mas foi outra ideia que “não pegou”;

/sys – O nome vem do sysfs (sys filesystem). É o diretório usado pelo Kernel Linux para manter dados atualizados sobre os dispositivos de hardware da máquina (não confunda, não é a mesma coisa que /dev, já que no /dev estão arquivos que servem de ligação com os dispositivos, e não informações sobre eles);

/tmp serve como repositório para arquivos temporários, sendo utilizado para programas que são executados após a ativação do sistema, ou seja, este diretório serve como espaço extra para vários programas e aplicações.

/var - Contém arquivos que são modificados com o decorrer do uso do sistema (e-mail , temporários, filas de impressão, manuais).

Dentro do /var encontramos:

• /var/lib - Bibliotecas que mudam enquanto o sistema está rodando.
• /var/local – Arquivos variáveis de programas que estão rodando.
• /var/lock – Travas para indicar que um programa está utilizando um determinado dispositivo.
• /var/log – Arquivos de log do sistema (erros, logins, etc..)
• /var/run – Arquivos importantes ao sistema úteis até o próximo boot (atualizações de softwares e kernel).
• /var/spool – Diretório de filas de impressão, e-mail e outros
• /var/tmp – Arquivos temporários dos programas
• /var/catman – Um cache para manuais que são formatados na hora de serem utilizados.

O diretório /usr

Este e um diretório interessante que preciso explicar melhor.O que tem nele?Contém os arquivos das ferramentas e dos aplicativos do usuário.

• /usr bin :Contém ferramentas e aplicativos de cada usuário.Ao criar uma nova conta de usuário,o sistema cria automaticamente uma pasta /usr/bin
• /usr dict :Diretório que são armazenados os dicionários(o nome dict deriva do inglês dictionary) e as listas de termos do usuário.
• /usr/doc :Esse Diretório contem a documentação do sistema em uso.
• /usr/info :Nesse Diretório encontramos os arquivos para o sistema GNU info,baseado em hipertextos
• /usr/lib :Assim como o Diretório /bin da raíz contem as bibliotecas para execução das ferramentas,dessa vez,porem,trata-se dos componentes das ferramentas,dessa vez,porem,trata-se dos componentes das ferramentas que se encontram no Diretório /usr/bin
• /usr/local :Essa pasta contem arquivos locais,ou seja,exclusivos para cada sistema(ou aplicativo),que incluem documentação(/usr/local/doc)e os programas em si(/usr/local/bin).
• /usr/man :diretório que agrupa os manuais que podem ser lidos com o comando man.
• /usr/share :Contém arquivos e componentes compartilhados por vários aplicativos.Nesse Diretório,encontramos diversos subdiretórios com arquivos de ajuda,ícones,etc.
• /usr/src : Esse diretório contem o codigo-fonte(source)dos softwares disponíveis no sistema. Esses sources podem ser visualizados e alterados livremente.
• /usr/tmp :E o diretório em que são colocados os arquivos temporários gerados pelo usuário ativo.

Comandos do Sistema de Arquivos

Aqui estão os comandos para lidar com o sistema de arquivos (HDs, drives e partições de rede).Para mais informações sobre o comando use o

$man


• badblocks – Utilizado para encontrar defeitos físicos no HD.
• cfdisk – Similar ao fdisk só que com uma interface melhorada.
• df – Mostra o espaço livre no disco.
• dosfsck -Verifica e repara sistemas FAT do DOS.
• du – Mostra o espaço que ocupa um diretório e os arquivos internos.
• dump – Usado para fazer o backup de um sistema ext2. O complemento deste comando é o restore.
• dumpe2fs – Faz o backup de blocos do HD e grupos.
• e2fsck – Verifica um volume ext2 em busca de erros.
• e2label – Muda o nome de uma partição ext2.
• fdisk – Usado para criar, editar e apagar partições no HD.
• fdformat – Formata um disquete.
• mount – Usado para “montar” um sistema de arquivos. O complemento deste comando é o umount.
• restore – Usado para restaurar um sistema ext2.
• umount – Desmonta o sistema de arquivos. O complemento é o comando mount.
• cdrecord – Grava CDs.
• cdparanoia – Grava CDs de áudio.

Manipulação de arquivos e diretórios

• cd – Muda para um diretório. Se você não especificar nada ele muda para seu diretório HOME.
• chmod – Muda as permissões para acesso aos arquivos e diretórios (Escrita, Leitura, etc..)
• chown – Muda o proprietário e grupo de um arquivo ou diretório.
• chgrp – Muda o grupo de um arquivo ou diretório.
• cp – Copia os arquivos de um diretório/pasta para outro diretório/pasta.
• dir – Lista o conteúdo de um diretório (preferir o comando “ls”).
• find – Procura arquivos com determinadas características na árvore de diretórios.
• ln – Cria um link simbólico para um arquivo.
• ls – Lista os arquivos de um diretório.
• mc – Midinght Commander. Um gerenciador de arquivos completo para o console.
• mkdir – Cria um diretório.
• mv – Move ou renomeia um arquivo.
• rm – Exclui arquivos.
• rmdir – Exclui um diretório vazio.
• vdir – Lista o conteúdo de um diretório.
• wheris – Localiza o executável, código fonte e manual de um comando.

Neste artigo encontra mais informações sobre os comandos descritos acima.

Referencias:
http://www.guiadohardware.net/dicas/linux-entendendo-arvore-diretorios.html
http://www.danbp.org/linuxcom.html
http://www.conectiva.com/doc/livros/online/10.0/servidor/pt_BR/ch02.html

The post Entendendo a estrutura de diretórios no linux appeared first on 0fx66.

.----------------------------.
| Permissões de Arquivos UNIX `-----------------------------------------------,
| Por MELEU     atualizado em 08/2007 |
`-----------------------------------------------------------------------------'

- = < Í N D I C E > = -

0. Introdução
1. Identificações
2. Permissões de Arquivos
2.1. Permissões Básicas
2.2. Permissões Especiais
3. Sobre Alguns Comandos
3.1. chmod
3.2. ls
3.3. find
3.4. test
3.5. umask
3.6. chattr
3.7. Outros Comandos
4. Usando C
4.1. Informações sobre Arquivos
4.2. Mudando Permissões
5. Esquemas Úteis
6. Referências
7. Considerações Finais
Apêndice. Arquivos de Dispositivo

0. Introdução

Como vocês podem ver isso é assunto bem NewBie mesmo, arrisco dizer que é um assunto de Wannabe Newbie. Só estou escrevendo sobre isto pois quando precisei saber detalhes sobre permissões de arquivos não encontrei nada em português que me ajudasse muito (confesso que não procurei muito :P ). E pode ser que esse texto venha a ajudar alguém numa consulta rápida sobre determinada permissão… Se você já é aquele fuçador tarimbado pode ser que você não encontre nenhuma novidade na parte que descrevo as permissões, porém a parte que envolve C pode ser de alguma utilidade. ;) E se você é elite, com certeza já sabe o conteúdo daqui e não vai querer perder seu precioso tempo…

Agradecimentos: Nash (por tudo), module (ainda vou morar na sua casa), eSc2(vulgo Escape Duplo), xf (se pedir por favor eu até faço :P ), Blind_Bard (e nossa partida de D&D?!), Hekodangews (quer aprender, saia do IRC), klogd (pela companhia nas altas madrugadas :) ), hts (pela dica do pulltheplug),Zarro (simplesmente por ter vontade de aprender e correr atrás), Cs0 (meleca é você seu bundão! :P ) a minha namorada (por não reclamar de eu ficar horas na frente do PC e por não me decepcionar debaixo dos lençóis :-) ), ao pessoal da extinta mail list unsekurity (cuja participação foi fundamental para a realização deste texto, me tiraram algumas dúvidas), a um cara chamado Ademar (por ter dado uma lida no texto e ter me dado uns toques legais), e a todos que ajudam a comunidade fuçadora (e que eu esqueci de mencionar) e não deixam que ela suma!

1. Identificações

Cada usuário cadastrado no sistema possui dois números relacionados ao seu login. Um é o UID (User IDentification) e o outro é o GID (Group IDentification). Isso é porque o UNIX não considera o nome do usuário para determinar suas permissões, ele só trabalha com números, neste caso o UID e o GID ou em outros casos o EUID (Efective User IDentification). Você pode ver os ID’s de um usuário digitando (adivinha!) “id” no prompt.

/* -=-=-= exemplo =-=-=- */
root@meleu:~# id
uid=0(root) gid=0(root) groups=0(root),1(bin),2(daemon),3(sys),4(adm),6(disk),10(wheel),11(floppy)
/* -=-=-= exemplo =-=-=- */

Você deve ter reparado que o UID do root é 0. Qualquer pessoa (não interessa o seu username) que tiver UID 0 terá PERMISSÃO TOTAL no sistema, ou seja, nível de super-usuário. Sempre que eu falar neste texto “nível de super-usuário” eu estou querendo dizer “UID igual a 0″. Cada username cadastrado no sistema precisa de um, e somente um, UID. Dá pra ver também que o root faz parte de vários grupos. Logo concluímos que um usuário pode ter vários GID’s, quer dizer, um usuário pode pertencer a vários grupos. Além destes dois há também o EUID. Este é usado com arquivos que contenham permissões especiais (explicadas no tópico 2.2). Você vai entender sobre EUID quando ler sobre arquivos com SUID, mais adiante.

2. Permissões de Arquivos

Primeiro devemos saber que todas as informações sobre os arquivos vêm de uma estrutura chamada inode. O inode contém informações sobre o UID e GID do arquivo, as permissões do arquivo, o tipo do arquivo e o timestamp do arquivo (informações sobre a última modificação, último acesso, etc).Para ver o número do inode de um arquivo basta um “ls -i”. Também devemos saber que as permissões possuem 3 “níveis”:

+ Proprietário: só pode ser exatamente 1, o dono do arquivo;
+ Grupo: engloba todos os membros de um determinado grupo;
+ Outros: se refere a qualquer pessoa que não seja o proprietário e que não pertença ao grupo.

O proprietário de determinado arquivo/diretório é responsável pelas suas permissões de acesso. Basta um “ls -l” para ver as permissões, o dono do arquivo e o grupo. Vamos a um exemplo:

meleu:~$ ls -l
total 28
drwxr-xr-x   5 meleu    users        4096 Jul 25 10:26 GNUstep/
drwxrwx---   2 meleu    staff        4096 Dec 22 06:58 myprogs/
-rw-r--r--   1 meleu    users        4163 Nov 16 06:43 rfc1244.txt
drwxr-xr-x   2 meleu    staff        4096 Dec 28 16:09 mylibs/
-rw-------   1 meleu    users        1074 Dec 12 04:37 anotações.txt
drwxr-x---   6 meleu    users        4096 Dec 28 16:12 textos/

Note que todos os arquivos pertencem a “meleu” e uns arquivos pertencem ao grupo “users” enquanto outros pertencem ao grupo “staff”. As permissões são mostradas de fato depois do primeiro carácter de cada linha, e sempre na sequência “rwx”. O esquema é o seguinte, os 3 primeiros caracteres após o primeiro descrevem as permissões do proprietário do arquivo; os 3 seguintes dizem respeito ao grupo; e os 3 últimos são referentes aos outros (que não seja o proprietário e nem pertença ao grupo). Note que em determinados itens aparece um ‘d’ antes das permissões, isso significa que isto é um diretório (outros tipos são explicados no tópico 3.2.).

2.1. Permissões Básicas

Vamos falar sobre as permissões básicas. São elas o ‘r’, ‘w’ e ‘x’. Tais permissões possuem significados diferentes quando aplicadas a arquivos e a diretórios.

• r – Read (Leitura):

+ Arquivo: significa que se pode ler o arquivo (através de um “cat” por exemplo.)

+ Diretório: significa que se pode ver o conteúdo do diretório (através de “ls” por exemplo). Porém observe a explicação sobre a permissão de execução mais abaixo.

• w – Write (escrita, gravação)

+ Arquivo: significa que se pode adicionar conteúdo e alterar um arquivo.

+ Diretório: significa que se pode criar e/ou apagar qualquer, repito QUALQUER, arquivo e/ou diretório que esteja dentro deste, mesmo que não se tenha permissão alguma para o arquivo/diretório a ser apagado. Observe a explicação sobre permissão de execução abaixo e “sticky bit” em 2.2.

Dica: NUNCA deixe o seu diretório home com esta permissão para outros (também conhecida como world-writable).

• x – eXecute (execução)

+ Arquivo: pode-se executar o programa ou shell script (se um arquivo texto não for um script e tiver esta permissão e você executar vai dar um monte de “command not found”).

+ Diretório: significa que pode-se “entrar” no diretório. Esta permissão é importante quando atribuída a um diretório. De nada adianta uma permissão ‘w’ se não tiver ‘x’. Já no caso do ‘r’ sem ‘x’ ainda podemos ver o conteúdo do diretório, porém com algumas limitações. Mas na hora de executar um “find” (tópico 3.3.) precisamos ter ‘r’ e ‘x’.Veja o exemplo abaixo, observe as permissões do diretório “pratica” (o comando “id” que aparece no começo é apenas para mostrar “quem sou eu”):

(ATENÇÃO: não confunda *o usuário* “hack” com *o grupo* “hack”, os nomes são iguais mas são coisas diferentes!)

meleu:/home/hack$ id
uid=1000(meleu) gid=100(users) groups=100(users)
meleu:/home/hack$ ls -l
total 20
drwxr-xr-x   5 hack     hack         4096 Jul 25 10:26 GNUstep/
drwxrwx---   2 hack     hack         4096 Dec 22 06:58 ferramentas/
drwxr-xrw-   2 hack     nogroup      4096 Dec 29 00:21 pratica/
drwxr-xr-x   2 hack     users        4096 Dec 28 16:09 progs/
drwxr-x---   6 hack     users        4096 Dec 29 00:51 textos/
meleu:/home/hack$ ls -l pratica/
/bin/ls: pratica/script.sh: Permission denied
/bin/ls: pratica/arquivo: Permission denied
/bin/ls: pratica/dir_teste: Permission denied
/bin/ls: pratica/mais_um_arquivo_teste: Permission denied
/bin/ls: pratica/arquivo_teste: Permission denied
total 0
meleu:/home/hack$ touch pratica/once_more_test
touch: pratica/once_more_test: Permission denied

Observe que eu consegui ler o conteúdo do diretório pratica, mas não consigo ver as permissões destes arquivos. E nas duas ultimas linhas do exemplo note que eu tenho não consigo criar um arquivo dentro de pratica, mesmo tendo permissão de escrita. Vamos usar o “progs” da saída do comando “ls -l” acima para uma ilustração,vamos ver o que significa cada bit:

drwxr-xr-x   2 hack     users        4096 Dec 28 16:09 progs/

1: ‘d’ –> diz que é um diretório;
2: ‘r’ –> mostra que o dono deste diretório pode ver o seu conteúdo;
3: ‘w’ –> mostra que o dono deste diretório pode criar e/ou apagar
arquivos/diretórios que estejam dentro dele;
4: ‘x’ –> mostra que o dono deste diretório pode entrar nele (através do
comando cd)
5: ‘r’ –> mostra que qualquer integrante do grupo “users” pode ver o conteúdo
do diretório;
6: ‘-’ –> mostra que integrantes do grupo “users” não podem criar e/ou apagar
arquivos/diretórios que estejam no diretório “progs”;
7: ‘x’ –> mostra que integrantes do grupo “users” podem “entrar” no diretório;
8: ‘r’ –> qualquer pessoa que não seja o dono do arquivo e nem pertença ao
grupo “users” pode ver o conteúdo do diretório;
9: ‘-’ –> “outros” não podem criar e/ou apagar arquivos/diretórios que
estejam no diretório “progs”;
10: ‘x’ –> “outros” podem “entrar” no diretório.

É importante perceber que “outros” não significa “qualquer pessoa logada no sistema”. Como já foi dito, “outros” se refere a qualquer um que NÃO SEJA o dono do arquivo E NÃO PERTENÇA ao grupo que o arquivo/diretório está atribuído. Estou enfatizando isso porque eu já me confundi uma vez por isso. Vamos a um exemplo:

meleu:/home/hack$ id
uid=1000(meleu) gid=100(users) groups=100(users),102(hack)
meleu:/home/hack$ ls -l
total 20
drwxr-xr-x   5 hack     hack         4096 Jul 25 10:26 GNUstep/
drwxrwx---   2 hack     hack         4096 Dec 22 06:58 ferramentas/
drwxr-xrw-   3 hack     nogroup      4096 Dec 29 01:22 pratica/
drwx---r-x   2 hack     hack         4096 Dec 28 16:09 progs/
drwxr-x---   6 hack     hack         4096 Dec 29 00:51 textos/
meleu:/home/hack$ cd progs/
bash: cd: progs/: Permission denied

Observe pela saída do “id” que eu (o usuário meleu) faço parte do grupo hack, note também que o grupo hack não possui nenhuma permissão no diretório “progs” e o resto do mundo possui permissão ‘r’ e ‘x’. Isso quer dizer que as permissões são verificadas da esquerda pra direita, na sequência proprietário -> grupo -> outros. O algoritmo desta verificação é mais ou menos assim:

Começo
Se usuário é dono do arquivo Então
permissões do dono do arquivo é atribuída ao usuário;
Senão
Se usuário pertence ao grupo do arquivo Então
permissões do grupo do arquivo é atribuída ao usuário;
Senão
permissões de outros é atribuída ao usuário;
Fim.

2.2. Permissões Especiais

Foram estas permissões que motivaram minha pesquisa e a escrita deste simples texto, vamos a elas. Antes é importante que se saiba que para qualquer um destes atributos ter efeito é necessário permissão de execução. Para o Sticky bit é necessário ‘x’ para outros; para o SGID bit é necessário ‘x’ para o grupo; e para SUID é necessário ‘x’ para o proprietário.

* t – Save Text Attribute (vulgo “sticky bit”)

+ Arquivos: A manpage do chmod explica: “Em sistemas Unix antigos, o sticky bit fazia os arquivos executáveis serem acumulados na swap. Esta característica não funciona em sistemas modernos de Memória Virtual, e o kernel do Linux ignora o sticky bit atribuído a arquivos. Outros kernels podem usar o sticky bit em arquivos para propósitos definidos pelo sistema. Em alguns sistemas só o superusuário pode atribuir o sticky bit em arquivos”. Resumindo: na maioria dos sistemas, sticky bit em arquivos serve para NADA.

+ Diretórios: significa que neste diretório o usuário pode apagar apenas arquivos que ele seja o proprietário. Lembra da descrição da permissão “w” em diretórios? Quem tem permissão “w” em diretório pode apagar qualquer arquivo dentro dele. Porém se o sticky bit também tiver sido atribuído ao diretório, o usuário só pode apagar arquivos dele.Geralmente esta permissão é usada em diretórios “world-writable” (por exemplo /tmp) para que não seja permitido que qualquer usuário apague arquivos que não lhe pertençam. Experimente um “ls -ld /tmp” e observe que o último caractere da lista de permissões é um “t”.

* s – Set ID Attribute
Este atributo possui significados diferentes quando está relacionado ao proprietário do arquivo e quando está relacionado ao grupo, assim como também possui significados diferentes para arquivos e diretórios, em relação aos arquivos você deve saber que este atributo NÃO FAZ EFEITO em shell scripts (já ouvi rumores de que antigamente funcionava, mas desde que me tenho como fuçador [1999] nunca vi isto). Em todos os casos ele funciona como um “tempero” para a permissão de execução.

+ SUID Attribute (relacionado ao dono do arquivo)
- Arquivos: SUID significa Set-User-ID, ou seja ele atribui ao EUID (Efective User ID) do usuário o UID do proprietário do arquivo quando o arquivo é executado e somente durante a execução do mesmo (logo, o arquivo precisa ser executável). Isso quer dizer que durante a execução do arquivo você tem acesso a tudo que o dono do arquivo tem.Mas lembre-se SOMENTE DURANTE A EXECUÇÃO DO ARQUIVO. No tópico 5. nós temos vários exemplos de esquemas deste famigerado atributo.
- Diretórios: SEM EFEITO.

+ SGID Attribute (relacionado ao grupo)

- Arquivos: SGID significa Set-Group-ID, ele atribui ao EGID (Efective Group ID) do usuário o ID do grupo do arquivo quando o arquivo é executado e (assim como no SUID) somente durante
execução do mesmo.

- Diretórios: se forem criados arquivos dentro deste diretório o grupo do arquivo será o mesmo grupo do diretório. Não entendeu? Vamos a um exemplo:

meleu:~$ id
uid=1000(meleu) gid=100(users) groups=100(users),102(hack)
meleu:~$ mkdir teste
meleu:~$ ls -l
drwxr-x---   2 meleu    users        4096 Jan  2 09:49 teste/
meleu:~$ chgrp hack teste        #diretório teste eh do grupo hack
meleu:~$ chmod g+s teste/        #atribuindo SGID ao diretório teste
meleu:~$ ls -l
drwxr-s---   2 meleu    hack         4096 Jan  3 12:44 teste
meleu:~$ cd teste/
meleu:~/teste$ touch arquivo.teste
meleu:~/teste$ ls -l
total 0
-rw-r-----   1 meleu    hack            0 Jan  2 09:50 arquivo.teste

Acho que você percebeu que o arquivo.teste pertence ao grupo hack. :) Isso é tudo que eu sei sobre permissões de arquivos. Mas até agora vimos muita teoria. Vamos para um estudo mais pratico.

3. Sobre Alguns Comandos

Aqui coloco algumas informações sobre alguns comandos que estão relacionados a permissões de arquivos.

3.1. chmod

O chmod serve para que você possa mudar as permissões de um arquivo, para fazer isso você deve ser o dono do arquivo (ou o root). Bom… Não vou escrever sobre como usar o comando, isso você deve ver na man page, vou escrever sobre um “método” diferente de como usá-lo. Se ligue na seguinte relação:

x = 1
w = 2
r = 4

Você pode usar esta relação para alterar as permissões de arquivos. Preste atenção na seguinte linha de comando:

 chmod 644 arquivo.txt
|||
dono do arquivo < -'|`-> outros
`-> grupo

Cada dígito diz respeito a um nível. Repare que no comando acima eu usei um 6, isso quer dizer que eu estou dando permissão de gravação (w = 2) e de leitura (r = 4) (4 + 2 = 6). Com o comando acima o “arquivo.txt” terá as seguintes permissões: -rw-r–r– . Veja esta tabela:

,-------,-----------,---------,
| octal | permissão | cálculo |
|-------|-----------|---------|
|   0   |    ---    |    0    |
|   1   |    --x    |    1    |
|   2   |    -w-    |    2    |
|   3   |    -wx    |   2+1   |
|   4   |    r--    |    4    |
|   5   |    r-x    |   4+1   |
|   6   |    rw-    |   4+2   |
|   7   |    rwx    |  4+2+1  |
'-------'-----------'---------'

OBS.: esta tabela só é valida para as permissões “básicas” (rwx).

Lembre-se de que cada dígito diz respeito a um nível! Logo no comando dado como ilustração acima “chmod 644 arquivo.txt” está sendo setado ao dono do arquivo a permissão de leitura e escrita e ao grupo e outros apenas a permissão de leitura. Agora em relação as permissões “especiais”. Observe a relação abaixo:

 Sticky Bit = 1
SGID = 2
SUID = 4

Veja um exemplo de um comando e a explicação de o que estamos fazendo:

 chmod 4755 programa
||||
SUID bit '--s------' < --'||`--> permissão 'r-x' para outros
|`--> permissão 'r-x' para o grupo
permissão 'rwx' para o dono < --'

Após este comando o “programa” terá as seguintes permissões: -rwsr-xr-x. O dígito relacionado às permissões especiais precisa ser o primeiro de quatro. Isso porque o chmod considera dígitos ausentes como 0. Exemplo:

 $ chmod 4 arquivo.txt

é equivalente a

 $ chmod 0004 arquivo.txt

Outra tabelinha de lambuja:

,-------,-----------,---------,
| octal | permissão | cálculo |
|-------|-----------|---------|
|   0   | --------- |    0    |
|   1   | --------t |    1    |
|   2   | -----s--- |    2    |
|   3   | -----s--t |   2+1   |
|   4   | --s------ |    4    |
|   5   | --s-----t |   4+1   |
|   6   | --s--s--- |   4+2   |
|   7   | --s--s--t |  4+2+1  |
'-------'-----------'---------'

Lembre-se: Os valores desta tabela são válidos apenas para o primeiro dígito dos quatro presentes no comando chmod. Relembrando que esta é apenas uma maneira de usar o chmod, uma lida na man page irá revelar outras maneiras, algumas até mais simples.

3.2. ls

Essa parte é só pra você entender o que a saída de um “ls” significa. Vamos repetir aqui o primeiro exemplo dado neste texto:

meleu:~$ ls -l
total 28
drwxr-xr-x   5 meleu    users        4096 Jul 25 10:26 GNUstep/
drwxrwx---   2 meleu    staff        4096 Dec 22 06:58 myprogs/
-rw-r--r--   1 meleu    users        4163 Nov 16 06:43 rfc1244.txt
drwxr-xr-x   2 meleu    staff        4096 Dec 28 16:09 mylibs/
-rw-------   1 meleu    users        1074 Dec 12 04:37 anotações.txt
drwxr-x---   6 meleu    users        4096 Dec 28 16:12 textos/

Como já foi dito, este ‘d’ no primeiro bit de algumas linhas significa diretório. Agora vamos a uma tabela com todas as possibilidades.

,-----------,---------------------------,
| Caractere |       Significado         |
|-----------|---------------------------|
|     -     |     arquivo regular       |
|     b     |   dispositivo de blocos   |
|     c     | dispositivo de caracteres |
|     d     |        diretório          |
|     l     |      link simbólico       |
|     p     |          FIFO             |
|     s     |         socket            |
'-----------'---------------------------'

/* Só umas informações a mais… ;)
Os dispositivos de blocos são periféricos (como um disco rígido, por exemplo) onde os dados são lidos e gravados, no próprio dispositivo como blocos (no disco rígido geralmente o bloco é de 1024 bytes). Nos dispositivos de caracteres os dados são lidos ou gravados em sequência e a I/O pode ser feita como bytes separados (um terminal virtual é um exemplo de dispositivo de caracteres). */

Observe também que no final do nome do diretório existe uma barra “/”. Isto acontece quando é dado o parâmetro -F ao comando “ls”, e geralmente existe um alias que faz isso pra você. Olhe uma tabela com outros caracteres que aparecem no final do nome para
facilitar a identificação:

,---------,----------------,
| Símbolo |  Significado   |
|---------|----------------|
|    *    |   executável   |
|    /    |   diretório    |
|    =    |    socket      |
|    @    | symbolic link  |
|    |    |      FIFO      |
'---------'----------------'

Agora em relação a permissões, permissões especiais pra ser mais específico. Como já foi dito anteriormente, é necessário permissão de execução para que os atributos “especiais” tenham efeito. Portanto quando estes atributos estão sendo usados e não estão fazendo efeito algum eles aparecem em maiúsculo. Veja um exemplo:

meleu:~$ touch arquivo
meleu:~$ chmod 7000 arquivo
meleu:~$ ls -l arquivo
---S--S--T   1 hack     users           0 Jan  4 09:55 arquivo

Se quiser saber mais sobre o “ls” olhe a página man. ;-)

3.3. find

Este comando é uma benção! :) Realmente muito útil e vale a pena você dar uma lida na página man…. Mas vamos aqui a uma pequena introdução só para você sentir um gostinho. Veja aqui uma lista dos argumentos mais usados:

Argumento          Descrição

-user     procura por arquivos cujo dono seja .
-group      procura por arquivos cujo grupo seja .
-uid          procura por arquivos cujo dono tenha UID .
-gid          procura por arquivos cujo grupo tenha GID .
-name
     procura por arquivos de nome que combine com o
.
-type        procura por arquivos do tipo
-perm [-]
   procura por arquivos de permissões
 (veja abaixo).

Nota-1: o parâmetro precisa estar no formato octal, e se você colocar o ‘-’ na frente o find procurará por arquivos que tenham *no mínimo* as permissões (veja exemplos abaixo).Nota-2: os tipos que são usados com o parâmetro -type são aquelas letras da tabela encontrada no tópico 3.2. (sobre ls), com a excessão do arquivo regular onde é usado o caracter ‘f’.

É interessante que você use redirecionamento para poder consultar o resultado da pesquisa. Só pra lembrar: ‘>’ redireciona a saída padrão e ’2>’ redireciona a saída de erro padrão. Assim, uma boa é usar sempre “2> /dev/null”. ;). Vamos a alguns exemplos… para maiores detalhes… nem precisa falar né?!

+ procurar por arquivos suid ou sgid:

 find / -perm -4000 -o -perm -2000

+ procurar por arquivos suid do root executável para todos (ou seja, bons arquivos para se colocar backdoors):

 find / -user root -perm -4001

ou melhor:

 find / -uid 0 -perm -4001

+ procurar por arquivos world-writable que não sejam links simbólicos, nem dispositivos de caracteres, nem sockets, e nem que possuam o sticky bit (OBS-1: 0′s a esquerda das permissões podem ser omitidos; OBS-2: a exclamação ‘!’ serve para negação de tudo que está entre parênteses; OBS-3: o ‘-o’ é o “ou lógico” do find)

 find / -perm -2  ! \( -type l -o -type c -o -type s -o -perm -1000 \)

Eu uso muito o find para encontrar os suid files nos WarGames (ver referências), onde você tem que encontrar o suid file do level superior ao seu. Por exemplo, quando está no level3 e quer procurar o suid file do level4, use:

 find / -user level4 -perm -4000 2> /dev/null

3.4. test

Este comando é muito usado nos shell scripts. E dá pra se fazer muita coisa interessante com ele. Não é o propósito deste texto ensinar Shell Scripting, portanto se não entender procure outras fontes (inclusive em ).Como você deve aber (senão, fica sabendo agora :P ) o “test expressão” é a mesma coisa que usar “[expressão]” e esta última notação que irei usar. Como a página man explica tudo que se deve saber, não vou explicar sobre o test aqui. Mas aí vai um exemplo de script (o script é meio besta… somente para ilustração mesmo). Não esqueça de ler a man page.

< ++> Permissoes/perms.sh
#!/bin/bash

if [ $# -ne 1 ]; then
echo "Uso: `basename $0` filename" 1>&2
exit -1
fi

# -e verifica se o arquivo existe
if ! [ -e $1 ]; then
echo "$1 não existe"

# -k verifica se possui sticky bit
elif [ -k $1 ]; then
echo "$1 possui \"sticky bit\""

# -g verifica se possui SGID
elif [ -g $1 ]; then
echo "$1 possui Set-Group-ID"

# -u verifica se possui SUID
elif [ -u $1 ]; then
echo "$1 possui Set-User-ID"
fi

< -->

Agora basta aprender um pouquinho de shell scripting que dá pra fazer algumas coisas legais! ;)

3.5. umask

O umask é um comando embutido no shell, e está presente nos shells mais comuns (bash, ash, ksh, csh). Dizer que o ele é um comando embutido no shell também quer dizer que não existe uma página man somente para este comando, e sim que a descrição dele está na página man do shell em questão. Tente digitar “man bash” e quando a manpage estiver sendo exibida procure por umask (geralmente isso é feito teclando /umask ). Isso deve levá-lo até a descrição do umask.O umask define as permissões que NÃO serão aplicadas aos novos arquivos a serem criados pelo usuário. Geralmente o umask padrão é atribuido em algum arquivo “profile” (algo como ~/.profile para um usuário individual, ou /etc/profile para todos usuários do sistema, mas isso pode variar muito em cada sistema). Se você achar o seu arquivo profile, tente encontrar o comando umask nele, deve estar em algum lugar. Agora vamos visualizar um exemplo:

meleu:~$ umask
0022
meleu:~$ mkdir bla1    #0022 eh permissao de escrita para grupo e outros
meleu:~$ ls -l         #note que o dir criado NAO tem "w" para grupo e outros
total 4
drwxr-xr-x 2 meleu users 4096 2007-06-03 16:52 bla1/
meleu:~$ umask 0077    #mudei meu umask, 0077 eh rwx para grupo e outros
meleu:~$ mkdir bla2
meleu:~$ ls -l         #note que bla2 NAO tem "rwx" para grupo e outros
total 8
drwxr-xr-x 2 meleu users 4096 2007-06-03 16:52 bla1/
drwx------ 2 meleu users 4096 2007-06-03 16:53 bla2/

Então lembre-se: umask define as permissões que NÃO serão atribuídas aos novos arquivos a serem criados.

3.6. chattr

ATENÇÃO: este comando é específico do Linux e do sistema de arquivos ext2 e ext3! Não existe este comando no FreeBSD ou no minix por exemplo. Mesmo assim achei interessante colocar esta seção pois o uso do Linux está muito difundido por aí. O comando chattr muda atributos de um arquivo em um sistema de arquivos ext2 ou ext3. Os atributos são identificados por um caractere. Para definir um atributo a um arquivo usa-se um sinal de “+” antes do caractere que identifica o atributo, e para retirar o atributo usa-se um “-”. Tais atributos são bem descritos na página man do chattr na seção ATTRIBUTES. Aqui vamos ilustrar o poder do chattr com o atributo “i”, o chamado imutável (immutable flag). Para atribuir o immutable flag a um arquivo o comando é o seguinte “chattr +i arquivo”, mas antes de sair fazendo isso vamos a uma explicação (retirada da página man do chattr):

“Um arquivo com o atributo ‘i’ não pode ser modificado: ele não pode ser apagado nem renomeado, nenhum link pode ser criado para este arquivo e nenhum dado pode ser escrito neste arquivo. Apenas o superusuário ou um processo possuindo a capacidade CAP_LINUX_IMMUTABLE pode ligar ou desligar este atributo.”

Ao ler isso nos vem logo uma pergunta à mente: nem o root pode modificar/ apagar este arquivo? Vamos a um exemplo para responder nossa pergunta. Os comentários após o “#” são para ajudar na explicação e as linhas em branco são somente para tornar a leitura mais agradável. Note que o comando lsattr serve para listar os atributos de um arquivo.

root:~# id                # sou o superusuario
uid=0(root) gid=0(root) groups=0(root),1(bin),2(daemon),3(sys),4(adm),6(disk),10(wheel),11(floppy),17(audio),18(video),19(cdrom)

root:~# touch arquivo     # estou criando um arquivo para nosso teste

root:~# ls -l arquivo     # observe a seguir que tenho permissao de escrita
-rw-r--r-- 1 root root 0 2007-06-04 15:43 arquivo

root:~# lsattr arquivo    # vejamos os atributos deste arquivo
------------- arquivo

root:~# echo "isto eh soh um teste" >> arquivo

root:~# cat arquivo       # adicionei uma linha no arquivo, veja:

isto eh soh um teste

root:~# chattr +i arquivo # atribuindo o immutable flag

root:~# lsattr arquivo    # veja o atributo i setado

----i-------- arquivo

root:~# echo "mais um pequeno teste" >> arquivo

-bash: arquivo: Permission denied

root:~# cat arquivo       # uau! sou o root e nao consegui escrever no arquivo!

isto eh soh um teste

root:~# rm -f arquivo     # serah que consigo apagar este miseravel?

rm: cannot remove `arquivo': Operation not permitted

Viu só? Nem o root pode fazer qualquer modificação em um arquivo com o immutable flag ativado. No entanto somente o root pode ligar ou desligar este atributo de um arquivo. Logo, basta um “chattr -i arquivo” como root e tudo volta ao normal. Agora vamos a uma valiosa dica retirada do Tips-HOWTO seção 3.3. “How to use the immutable flag”:

“Logo após instalar e configurar seu sistema, vá no /bin, /sbin, /usr/bin, /usr/sbin e /usr/lib (e outros diretórios suspeitos) e faça uso liberal de ‘chattr +i comando’. Também faça isso aos arquivos do kernel na raiz. Agora faça ‘mkdir /etc/.dist/’ e copie tudo de /etc/ naquele diretório (eu faço isso em dois passos, usando /tmp/etcdist.tar para evitar recursão). Opcionalmente você pode apenas criar /etc/.dist.tar.gz e marcar como imutável. A razão para tudo isto é limitar o dano que você pode fazer quando estiver usando a conta root. Você não irá sobrescrever arquivos com um operador de redirecionamento perdido, e não fará o sistema inutilizável com um espaço perdido dentro de um comando ‘rm -fr’ (você ainda pode fazer bastante dano em seus dados, mas seus bin’s e libs estarão mais seguros). Isto também impossibilita ou torna mais difícil a ação de uma variedade de exploits de segurança ou denial of service (uma vez que muitos deles consistem em sobrescrever algum arquivo pelas ações de algum programa SUID).A única inconveniência disto é quando se está desenvolvendo e fazendo seu ‘make install’ em vários tipos de binários do sistema. Por outro lado também previne que o ‘make install’ sobrescreva os arquivos. Quando você esquecer de ler o Makefile e fazer ‘chattr -i’ nos arquivos que seriam sobrescritos (e nos diretórios para os quais você quer adicionar arquivos) — o make falha, você só precisa usar o comando ‘chattr -i’ e reexecutar o make.(…)”

Dá pra perceber aí o quanto que vale a pena estudar o chattr, né?

3.7. Outros Comandos

Aqui vai uma relação de alguns comandos que tem relação com permissões de arquivos. Dê uma olhada na página man deles. chown, chgrp, newgrp, su, sudo, suauth. No momento só estou me lembrando destes… Devem haver muitos outros.

4. Usando C

Esta parte tem alguns pontos parecidos com a matéria de lamagra na CoreZine n. 1 (ver 6. Referências). Não me chame de copião! Acho que em português não tem nada sobre isso, por isso resolvi escrever.

4.1. Informações sobre Arquivos

Como já foi dito, todas as informações sobre um arquivo fica numa estrutura chamada inode. Para que possamos consultar estas informações através do C utilizamos as funções stat(), fstat() e lstat(). Aqui estão os protótipos e uma ligeira descrição:

int stat(const char *file_name, struct stat *buf);
int fstat(int filedes, struct stat *buf);
int lstat(const char *file_name, struct stat *buf);

• stat: consulta informações sobre file_name no inode e armazena na estrutura buf.
• fstat: faz o mesmo só que ela acessa o arquivo através do inteiro filedes (file descriptor), como por exemplo o retornado por open()
• lstat: faz a mesmíssima coisa que stat porém quando o file_name é um link a função stat() armazena em buf informações sobre o arquivo apontado pelo link, já lstat() armazena em buf informações sobre o próprio link.

Como podemos ver na página man destas funções a estrutura stat está definida da seguinte forma:

struct stat
{
dev_t         st_dev;      /* device */
ino_t         st_ino;      /* inode */
mode_t        st_mode;     /* protection */
nlink_t       st_nlink;    /* number of hard links */
uid_t         st_uid;      /* user ID of owner */
gid_t         st_gid;      /* group ID of owner */
dev_t         st_rdev;     /* device type (if inode device) */
off_t         st_size;     /* total size, in bytes */
unsigned long st_blksize;  /* blocksize for filesystem I/O */
unsigned long st_blocks;   /* number of blocks allocated */
time_t        st_atime;    /* time of last access */
time_t        st_mtime;    /* time of last modification */
time_t        st_ctime;    /* time of last change */
};

Vamos agora analisar cada elemento desta estrutura.

• st_dev: o dispositivo em qual o arquivo está gravado, para ver o “major and minor numbers” use as macros major() e minor() definidas em sysmacros.h. OBS.: Se você não sabe o que isto significa leia o Apêndice.
• st_ino: o inode que guarda as informações sobre o arquivo (cada arquivo está relacionado a um único inode).
• st_mode: serve para ver o tipo do arquivo (se é diretório, dispositivo de bloco, etc) e também para ver as permissões. Para tais finalidades são necessários alguns artifícios que veremos no código abaixo.
• st_nlink: número de hard links para o arquivo. O mínimo é 1 (pelo menos se o arquivo existir :P ) a cada hard link soma mais 1.
• st_uid, st_gid: ID do dono e ID do grupo, respectivamente (duh!).
• st_rdev: se o arquivo é um dispositivo de bloco ou de caracteres o st_rdev irá armazenar os números maior e menor do dispositivo.

A diferença deste para o st_dev é que, por exemplo, o *arquivo de dispositvo* /dev/hdd está gravado (aqui na minha máquina) em /dev/hda2, então st_dev contém os números “maior” e “menor” do /dev/hda2 ao passo que st_rdev contém os números maior e menor
do próprio /dev/hdd.

• st_size: tamanho do arquivo em bytes (duh!)
• st_blksize: é o tamanho do bloco que o sistema de arquivos usa para E/S, é usado por alguns programas para que haja uma melhor “bufferização”.
• st_blocks: o número de blocos físicos que estão sendo usados por este arquivo no disco.
• st_atime: contém o dia/ano/mês/hora/… do último acesso a este arquivo(leitura e/ou execução).
• st_mtime: contém o dia/ano/mês/hora/… da última modificação feita no arquivo.
• st_ctime: contém /dia/ano/mês/hora/… da última alteração feita *no inode*.

  Note que se você modificar o arquivo você estará alterando o inode também, mas se mudar o inode não quer dizer que esteja alterando o arquivo (ex.: através de chmod, chown, etc…). O que quero dizer é que se alterar st_mtime automaticamente alterará st_ctime, mas o contrário nem sempre acontece.

Bom… Acho que é melhor um código-fonte de exemplo que assim é a melhor maneira de pegar as coisas. ;) Muita atenção nos comentários!

< ++> Permissoes/filestat.c

#include <stdio.h>              /* Essa você deve saber pra que serve. :P */
#include <sys/stat.h>           /* Necessaria para usar lstat() */
#include <sys/sysmacros.h>      /* Para usar major() e minor() */
#include <sys/types.h>          /* Para declarar variável do tipo mode_t */
#include <time.h>               /* Para usar ctime() */
#define TRUE  1
#define FALSE 0
#define PERMS 07777
/* Como foi dito, a variável st_mode armazena num só inteiro o tipo do
arquivo e suas permissões. E é por isso que a gente precisa usar os
bitmasks diferentes para quando queremos ver o tipo do arquivo e para
ver as permissões do arquivo. A macro PERMS declarada acima é para se
"traduzir" as permissões. */
char *FileType (mode_t tipo);
unsigned short int isdev = FALSE; /* Isso é só pra verificar se o
arquivo é um dispositivo. */
int main (int argc, char **argv) {
struct stat arq;
if (argc != 2)
{
printf ("Uso: %s \n", argv[0]);
exit (-1);
}
if (lstat (argv[1], &arq))
{
perror (argv[1]);
exit (1);
}
printf ("Nome do arquivo:\t%s\n", argv[1]);
printf ("Inode:\t\t\t%d\n", arq.st_ino);
printf ("Tipo do Arquivo:\t%s\n", FileType (arq.st_mode));
if (!isdev) { /* Se NÃO for um dispositivo... */
printf ("Tamanho:\t\t%d bytes, %d blocos\n", arq.st_size, arq.st_blocks);
printf ("Bloco de E/S:\t\t%d bytes\n", arq.st_blksize);
printf ("Dispositivo onde está salvo: \tmaior: %d,", major (arq.st_dev));
printf (" menor: %d\n", minor (arq.st_dev));
}
/* Nos dois printf's acima e nos dois abaixo foram usadas as macros
major() e minor(), ambas declaradas em , estas
macros servem para retornar os números maior e menor do dispositivo
(Ver no Apêndice mais sobre estes números). */
else { /* Se for um dispositivo... */
printf ("Dispositivo verdadeiro: \tmaior: %d,", major (arq.st_rdev));
printf (" menor: %d\n", minor (arq.st_rdev));
}
printf ("Permissões:\t\t%04o\n", arq.st_mode & PERMS);
/* Olhe aí a macro PERMS (que eu defini lá no começo) sendo usada. Ela
está sendo usada aqui para ver as permissões no formato octal (ver
tabelinhas do tópico 3.1.) portanto use sempre o formato "%o" para
imprimir com printf() (de preferência "%04o" para mostrar os 0's a
esquerda). Lembre-se que sempre que for fazer esta "tradução" usar
sempre 5 dígitos sendo que o primeiro dígito seja um '0', para que o
compilador entenda que é um octal. */
printf ("Numero de Hard Links:\t%d\n", arq.st_nlink);
printf ("UserID: %d,\tGroupID: %d\n", arq.st_uid, arq.st_gid);
printf ("Último acesso:\t\t\t%s", ctime (&arq.st_atime));
printf ("Última modificação:\t\t%s", ctime (&arq.st_mtime));
printf ("Última alteração no inode:\t%s", ctime (&arq.st_ctime));
/* Nos 3 printf's acima usei ctime() para imprimir o
timestamp bonitinho. */
return 0;
}
char *FileType (mode_t tipo) {
switch (tipo & S_IFMT) { /* Para saber o tipo do arquivo é necessário usar
o S_IFMT. Detalhes sobre esta e outras macros
definidas em  podem ser vistos na
manpage do stat(). */
case S_IFDIR:
return "Diretório";
case S_IFREG:
return "Arquivo Normal";
case S_IFSOCK:
return "Socket";
case S_IFLNK:
return "Link Simbólico";
case S_IFBLK:
isdev = TRUE;
return "Dispositivo de Bloco";
case S_IFCHR:
isdev = TRUE;
return "Dispositivo de Caracter";
case S_IFIFO:
isdev = TRUE;
return "FIFO";
}
return NULL;
}
/* * * EOF * * */

Note que eu usei a função lstat(), pois estou querendo informações sobre o próprio link (se o arquivo for um link!) e não sobre o arquivo apontado por ele. Para se usar a função fstat() você faria algo mais ou menos assim (só um trechinho):

/* -=-=-= usando fstat =-=-=- */
...
int fd;
...
fd = open(argv[1], O_RDONLY); /* isso normalmente fica dentro de um 'if' */
fstat (fd, &arq);             /* e isso também ;) */
...
/* -=-=-= usando fstat =-=-=- */

4.2. Mudando Permissões

Para mudar as permissões de um arquivo você pode usar as seguintes funções:

int chmod(const char *path, mode_t mode);
int fchmod(int fildes, mode_t mode);

• chmod: muda as permissões do arquivo/diretório path setando para mode.
• fchmod: igual chmod porém usando fildes (file descriptor) para mudar as permissões do arquivo.

Em ambas funções você usa o caminho do arquivo que você quer modificar como primeiro parâmetro. E para “mode” (o segundo parâmetro) você deve usar as macros definidas em stat.h ou um número octal de 5 dígitos (sempre de 5 dígitos!). Você pode ver as macros na página man das funções stat.Evidentemente você só pode mudar as permissões de arquivos que lhe pertençam (a não ser que você seja super-usuário).

Para mudar as posses do arquivo (vulgo ownership) você usa as seguintes funções:

int chown(const char *path, uid_t owner, gid_t group);
int fchown(int fd, uid_t owner, gid_t group);
int lchown(const char *path, uid_t owner, gid_t group);

• chown: mudar a proprietário do path para owner e o grupo para group.
• fchown: mesmo esquema só que tem aquele lance do file descriptor.
• lchown: mesmo esquema só que tem aquele lance de alterar o próprio link ao invés de alterar o arquivo apontado pelo link.

Nestas funções o primeiro parâmetro é o caminho do arquivo. O segundo e o terceiro parâmetro é, respectivamente, o UID e GID que você quer atribuir ao arquivo. Quando você não quer mudar o UID ou o GID é só você usar -1.Ainda existem algumas limitações:

• Apenas o super-usuário pode mudar o proprietário do arquivo;
• O proprietário do arquivo pode mudar o grupo do arquivo para qualquer um que ele faça parte;
• O super-usuário pode mudar o grupo do arquivo para qualquer um.

Olhe este pequenino programinha (sem muita utilidade) só pra ver qual é o esquema:

/* -------------------- */
< ++> Permissoes/mudar_permissoes.c
#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#define PERMS 07777
#define GRUPO 666       /* O grupo que eu quero que o arquivo pertença */
#define MODE 04555      /* Permissões que eu quero que o arquivo tenha */
int main (int argc, char **argv) {
struct stat arq;
if (argc != 2) {
printf ("Uso: %s \n", argv[0]);
exit (-1);
}
if (lstat(argv[1], &arq)) {
perror (argv[1]);
exit (1);
}
printf ("ANTES:\n");
printf ("\tOwnership -> UID: %d,\tGID: %d\n", arq.st_uid, arq.st_gid);
printf ("\tPermissões: %04o\n\n", arq.st_mode & PERMS);
if (lchown (argv[1], -1, GRUPO)) perror ("lchown");
if (chmod (argv[1], MODE)) perror ("chmod");
lstat (argv[1], &arq);
printf ("DEPOIS:\n");
printf ("\tOwnership -> UID: %d,\tGID: %d\n", arq.st_uid, arq.st_gid);
printf ("\tPermissões: %04o\n", arq.st_mode & PERMS);
return 0;
}
< -->

O programa mudará o grupo do arquivo para 666, se este GID não existir no sistema o lchown não funcionará como desejado. O programa muda também a permissão do arquivo para “r-sr-xr-x”, ou se preferir: 4555, de acordo com a macro MODE definida lá em cima. Por exemplo: se você quiser tornar um arquivo/diretório com acesso de leitura e execução para todo mundo você faria
o seguinte:

 chmod ("arquivo", 00555);

Nunca se esqueça: são sempre 5 dígitos para ser certinho!

Bom… é isso… teste alguns esquemas ae e divirta-se. Com estas funções dá pra fazer uns lances bem legais pra você verificar arquivos “perigosos” com frequência. Enfim… tenha imaginação!

5. Esquemas Úteis

Vamos ver aqui umas coisinhas interessantes de se fazer usando SUID. Antes vou logo avisando que para que as coisas mostradas neste tópico tenham alguma graça você terá que adquirir nível de outro usuário. Se não sabe como fazer isso… bem amigo… FUCE! Digamos que você conseguiu acessar a conta de outro usuário. Não perca tempo! Copie um shell e atribua SUID a ele. No exemplo abaixo imagine que eu seja “hack” mas consegui acessar a conta do usuário “meleu” (não! isso não é crise de identidade!). Então eu vou e copio um shell e atribuo SUID a ele. Veja:

meleu:~$ id
uid=1000(meleu) gid=100(users) groups=100(users),666(hack)
meleu:~$ cp /bin/ash /tmp/exemplo
meleu:~$ chmod +s /tmp/exemplo
meleu:~$ ls -l /tmp/exemplo
-rwsr-sr-x    1 meleu    users       59628 Dec  9 23:47 /tmp/exemplo*
/* -=-=-= exemplo =-=-=- */

Pronto. Agora eu entro no sistema como o usuário hack e… Veja você mesmo:

hack:/tmp$ id
uid=1005(hack) gid=100(users) groups=100(users),666(hack)
hack:/tmp$ ls -l exemplo
-rwsr-sr-x    1 meleu    users       59628 Dec  9 23:47 exemplo*
hack:/tmp$ ./exemplo
\u:\w$ id
uid=1005(hack) gid=100(users) euid=1000(meleu) groups=100(users),666(hack)

Reparaste que o EUID mudou né? Reparaste também que o PS1 no ash não se comporta como no bash? :P Agora eu (hack) tenho acesso a tudo que meleu também tem. Mas felizmente existem programadores que são pessoas preocupadas com a segurança e alguns programas não funcionam quando você está com EUID de outro usuário. Este é o caso do programa “ps”. Veja o exemplo:

\u:\w$ id
uid=1005(hack) gid=100(users) euid=1000(meleu) groups=100(users),666(hack)
\u:\w$ ps x
This /bin/ps is not secure for setuid operation.

Sacaste?

OBSERVAÇÃO: Em versões anteriores deste texto eu afirmei que este esquema não funcionava no bash. Mas recentemente, fuçando a manpage dele, eu li que se usarmos a opção “-p” o comportamento dele para com o effective user id é diferente do que se não for passado parâmetro algum. Desta forma, é possível sim, fazer uma cópia de /bin/bash e atribuir SUID a esta cópia e depois executá-la com a opção “-p”. Fiz meus testes com a versão 3.1.17. Faça alguns testes no seu sistema aí e observe que interessante. ;-)

Este esquema eu testei no tcsh 6.08, bash 3.1.17, ash (não sei a versão), zsh 3.0.6, e pdksh 5.2.12 (Public Domain Korn Shell). Só funcionou no ash, zsh, pdksh, e no bash utlizando-se a opção “-p” na linha de comando.

Também é possível fazer outras coisas muito interessantes…Uma boa a se fazer é copiar e atribuir SUID a um editor de textos. Só testei este esquema com o “vi” (o editor mais fácil de se achar nos sistemas que existem por aí). Tendo um editor com SUID você pode editar/criar arquivos como se fosse o outro usuário. Consequentemente você pode editar/criar um profile para a “vítima”, e quando falamos nisso logo pensamos em (tchan tchan tchan!) Trojan Horses. E se você tiver um editor SUID para root você pode mecher nos arquivos de configuração do sistema (geralmente localizados em /etc ), visualizar o tão cobiçado /etc/shadow e mais uma infinidade de coisas. Isso foi só um pontapé inicial. Não vou ensinar aqui como editar profiles e nem como fazer Trojans. Mas posso te indicar onde aprender: para aprender a fazer/editar profiles você tem que aprender shell script e para aprender a fazer Trojans você tem que aprender a programar. Existem diversos textos sobre o assunto, inclusive em http://unsekurity.virtualave.net (Veja mais em 6. Referências).

ATENÇÃO: Se o administrador do sistema tiver um mínimo de competência ele rodará um find (ver tópico 3.3.) com frequência para dar uma monitorada nos arquivos SUID. Portanto não fique dando bobeira usando estes esquemas tão “fuleiros”.

6. Referências

Dominando o Linux -> Foi onde li sobre as permissões básicas e sobre arquivos de dispositivo (do Apêndice). Este livro já foi A Bíblia do Linux, hoje em dia não sei. Estou meio desatualizado. Podia ser comprado em http://www.lcm.com.br Hoje em dia não tem mais. Mas para quem lê bem em inglês, vai em irc.nullus.net e entra no canal #bw ;-) Satisfação garantida!

Security-HOWTO -> Li sobre SUID, SGID, e sticky bit. Você pode encontrar em http://www.tldp.org ou /usr/doc/Linux-HOWTOs

Tips-HOWTO -> A dica sobre o immutable flag encontra-se neste documento na seção 3.3. Pode ser consultado em http://www.tldp.org ou
/usr/doc/Linux-HOWTOs

Bash-Prog-Intro-HOWTO ———,-> Textos sobre shell script. Úteis para você Advanced Bash-Scripting Guide -’ aprender a criar/editar profiles. Ambos se encontram em http://www.tldp.org

Cursos de Linguagem C -> Dois ótimos lugares para se aprender a programar em Linguagem C: (português) http://ead1.eee.ufmg.br/cursos/C e (inglês, muito bom! voltado especificamente para ambiente UNIX) http://www.cs.cf.ac.uk/Dave/C/CE.html

Backdoors e Trojans -> Bom texto que explica sobre como fazer backdoors e trojan horses, feito pelo NashLeon, algumas usando e abusando da permissão SUID. Como não existe mais a página da unsekurity scene, aí vai um mirror http://www.ataliba.net/sections/old-hacking/unsekurity Gostaria de externar o meu mais profundo agradecimento ao cara que teve a excelente ideia de fazer um mirror dos arquivos da unsek. Seria uma grande perda…

Barata Eletrica n. 20 -> Tem um texto sobre UNIX e foi lá que eu vi aquelas tabelas do topic 3.2. A URL é http://www.inf.ufsc.br/barata/

CoreZine n. 01 -> Li sobre a parte de C. A CoreZine não existe mais e não achei mirror algum via google. Achei um arquivo onde tem o texto que usei:
http://www.abunasar.net/mirrors/h0h0.com/hwa/hwa-hn52.txt

man pages -> Sobre os comandos do tópico 3 e as system calls.

Linux Allocated Devices -> Maiores detalhes sobre os arquivos de dispositivo. Você pode encontrar em /usr/src/linux/Documentation/devices.txt

www.rootthisbox.org -,-> Dê uma olhada aqui se quiser saber mais www.pulltheplug.com -| sobre wargames (OBS: vale muito a pena!!). www.hackerslab.org –’

extinta mail list da unsekurity -> Se não fosse a mail list esse texto seria um lixo ou até mesmo nem sairia! Infelizmente (ou felizmente, depende do ponto de vista) a lista não existe mais.

7. Considerações Finais

Bem como esse texto é para o pessoal que está bem no começo mesmo, vou dar uma dica em forma de relato “baseado em fatos reais”. :P

O lance é que quando eu comecei a estudar profundamente permissões de arquivos, eu comecei a fuçar nos txts da vida e determinado assunto puxava outro, e para compreender melhor o outro tinha que ler outro mais (arquivos de dispositivo é um exemplo)… e por aí vai… E de tanto ir saltando de txt em txt eu acabava aprendendo um monte de coisa útil.

Onde quero chegar?! Estou querendo dizer que ao invés de ficar procurando ajuda em canais de IRC você tem que correr atrás das infos você mesmo ou pedir indicação de um txt pra alguém… Você acaba aprendendo muitas outras coisas! É lógico que não é todo undo que dispõe de tempo pra ficar fazendo isso. Portanto não pense que estou condenando quem fica pedindo ajuda… As vezes
precisamos de uma solução rápida e talz… Mas conseguir aprender as coisas por conta própria a muito gratificante (pelo menos pra mim).
Eu costumava apurrinhar o pessoal da extinta mail list da unsekurity com dicas de leitura e outras coisas… Se você, fuçador iniciante, também encontrar um meio de trocar informações vai sair lucrando! Dividir experiências com os outros faz a informação fluir mais facilmente e vai que alguém já passou pelo mesmo problema que você e encontrou um txt sarado sobre o assunto! =]

Vou terminando aqui… Um abraço irmãos! E não se esqueçam de ler as man pages sempre que houver alguma dúvida! ;)

Apêndice

Arquivos de Dispositivo

Os arquivos de dispositivo são um artifício para que os programas possam interagir com os dispositivos de hardware através do kernel. Eles não são “arquivos” de verdade (ou são?). Mas os programas os usam como se fossem, e assim o kernel reconhece a solicitação de E/S e envia para o driver correspondente. Como vocês já sabem os arquivos de dispositvos ficam no /dev. Ao listar o conteúdo do /dev com um “ls -l” você ve algo incomum. Veja um exemplo:

/* -=-=-= exemplo =-=-=- */
meleu:~$ ls -l /dev/hda2
brw-r-----   1 root     disk       3,   2 Apr 27  1995 /dev/hda2
/* -=-=-= exemplo =-=-=- */

Você deve ter observado que o primeiro bit das permissões é um ‘b’ o que mostra que é um dispositivo de bloco (ver tópico 3.2.). Mas não é disso que falo quando digo “algo incomum”. Estou falando são destes dois números separados por uma vírgula (3 e 2). O primeiro valor é o número maior (major) do dispositivo e o segundo é o número menor (minor). Isso é para que o kernel saiba que dispositivo está sendo usado. Quando um arquivo de dispositivo é acessado o kernel recebe essa informação em forma de número maior e número menor. O maior número especifica um determinado driver de dispositivo do kernel e o menor número especifica exatamente qual dispositivo será controlado pelo driver.

Olhe outro exemplo:

meleu:~$ ls -l /dev/hda*
brw-r-----   1 root     disk       3,   0 Apr 27  1995 /dev/hda
brw-r-----   1 root     disk       3,   1 Apr 27  1995 /dev/hda1
brw-r-----   1 root     disk       3,  10 Apr 27  1995 /dev/hda10
brw-r-----   1 root     disk       3,  11 Apr 27  1995 /dev/hda11
brw-r-----   1 root     disk       3,  12 Apr 27  1995 /dev/hda12
brw-r-----   1 root     disk       3,  13 Apr 27  1995 /dev/hda13
brw-r-----   1 root     disk       3,  14 Apr 27  1995 /dev/hda14
brw-r-----   1 root     disk       3,  15 Apr 27  1995 /dev/hda15
brw-r-----   1 root     disk       3,  16 Apr 27  1995 /dev/hda16
brw-r-----   1 root     disk       3,   2 Apr 27  1995 /dev/hda2
brw-r-----   1 root     disk       3,   3 Apr 27  1995 /dev/hda3
brw-r-----   1 root     disk       3,   4 Apr 27  1995 /dev/hda4
brw-r-----   1 root     disk       3,   5 Apr 27  1995 /dev/hda5
brw-r-----   1 root     disk       3,   6 Apr 27  1995 /dev/hda6
brw-r-----   1 root     disk       3,   7 Apr 27  1995 /dev/hda7
brw-r-----   1 root     disk       3,   8 Apr 27  1995 /dev/hda8
brw-r-----   1 root     disk       3,   9 Apr 27  1995 /dev/hda9

Repare que o número maior de todos são iguais, isso quer dizer que para todos estes dispositivos é usado o mesmo driver. O número menor indica ao driver qual é o dispositivo que ele tem que executar sua função.

Para maiores informações consulte a página man do comando mknod e o arquivo /usr/src/linux/Documentation/device.txt

Fonte: LinuxSecurity

Quero agradecer MELEU por ter escrito um artigo de tão boa qualidade.

The post Permissões de Arquivos UNIX appeared first on 0fx66.

Como todos já sabem, acredito eu, sou um heavy user do Amarok e de seus recursos em especial os podcast, fique bastante contente pois recentemente saiu a versão 2.5 do Amarok com suporte a contas do gpodder. Para atualizar no Ubuntu é muito fácil basta executar as linhas abaixo:

sudo add-apt-repository ppa:kubuntu-ppa/backports
sudo apt-get update
sudo apt-get upgrade

Pronto está atualizado e instalado, infelizmente seria perfeito se fosse somente isso, utilizo o Amarok desde a versão 1.4, que diga-se de passagem foi uma das melhores versão do Amarok, ele era leve, rápido, cheio de recursos, atendia a todos muito bem a única reclamação que via sobre ele nos fóruns e redes IRC era por ele utilizar QT e não se integrar muito bem a ambientes GTK (como Gnome e XFCE).

Então um belo dia, veio uma tempestade chamada QT4, que mudou tudo, o ambiente KDE que utilizava o QT3.5, migrou para o QT4 as mudanças no ambiente foram muito drásticas, me lembro da quantidade de reclamações quanto as primeiras versões do KDE4, era lento, repleto de bugs, parecia um Windows Vista…

Não foi só o KDE4 que sofreu grandes mudanças, mas sua base de aplicativos também, não fui muito afetado pois a maioria dos programas que utilizo são programas escritos em GTK. Mas dentro do ambiente GTK não existe nenhum player que seja melhor que o Amarok, isso é um fato, o Banshee nem entra para a lista aquela coisa usa Mono.

As mudanças provocadas pelo KDE resultaram no que a principio chamei de aberração o Amarok2, ele era uma bela de uma porcaria, fiquei indignado com o que fizeram com o Amarok1.4 que era uma versão excelente, fico pensando por quiseram mudar tudo, por que só não portaram para QT4? (mais abaixo vou falar do port dele para QT4).

Depois de algumas atualizações os bugs foram sendo corrigidos, novos apareceram, foi ficando mais encorpado ou seja atingindo maior maturidade. Fui utilizando feliz, estava me atendendo muito bem, nem me lembrava mais da época do 1.4.

Até que efetuei este ultimo upgrade para o 2.5 e notei que o uso do processador estava maior do que o de costume, então resolvi fazer alguns downgrades do Amarok. Fiz um para o 2.4 o uso do processador era menor, mas ainda bem alto, fiz outro para o 2.3 é o uso do processador era menor que no 2.4 mas ainda sim muito alto. Então fiquei com a pulga atrás da orelha, no 1.4 o consumo de processamento e memória era muito menor, muito menor mesmo!

Então resolvi instalar o Amarok 1.4 na máquina virtual, para comparar os dois (sim na máquina virtual mesmo!) e o mais incrível que seu desempenho mesmo em uma máquina virtual era superior ao do Amarok2 (2.3, 2.4 e 2.5), o Amarok se tornou um bloatware, desde a versão 2 dele, ele virou um bloatware.

Antigamente browsers era simplesmente ferramentas para visualizamos nossos sites, não programas atolados de funcionalidades hoje um browser e praticamente um sistema operacional sua complexidade e sofisticação atingiu níveis colossais, hoje em dia e impraticável (a menos que tenha muito, mas muito tempo livre) pegar o código fonte do Firefox ou do Amarok até mesmo do Linux estuda-los a fundo.

A alguns anos atrás utilizamos hardware bastante limitados, computadores com processadores de apenas um núcleo, 256MB de RAM, 40GB de HD (estou sendo otimista com essa configuração), hoje em dia e inviável utilizar um hardware como esse que citei, graças aos bloatware.

O que é um bloatware? São softwares inchados, softwares que agregaram tantos recursos que se tornaram muito pesados, os recursos nem sempre bem implementados (para falar a verdade raramente são bem implementados) hoje não temos mais softwares tão bons quanto a alguns anos atrás, fazendo uma analogia hoje temos patos! Eles nadam, voam e andam, mas não fazem nada tão bem.

O Firefox é o melhor exemplo de bloatware que temos hoje em dia, era um bom navegador, não que não seja ainda um bom navegador mas…implementou o suporte a extensões que hoje são vistas como o melhor e o pior, depois recebeu mais implementações como o suporte a skins, depois mudanças internas até chegou no que temos hoje, um navegador pesado, exigente com o uso de processador e um devorador de memória.

Pessoas tentam nos enfiar goela abaixo a ideia de que podemos usar o browser para tudo e de que Smartphones e Tablets podem substituir computadores/notebooks. Tablets e Smartphones entram na mesma analogia dos patos, fazem muita coisa, mas nada direito, não venha me falar que fazem pois todos sabemos não fazem, tenta redigir sua monografia no seu iPhone ou no Galaxy para tu ver, experimente ler livros no seu iPad ou xoom a luz do sol para tu ver ou então leia por horas e mais horas para ver se sua vista não ficara extremamente cansada.

Qual relação dos Tablets, Smartphones, Bloatware e patos? Todos são Bloatwares! Os Smartphones são bloatwares, dos celulares, fazem tudo que um celular faz, mas a maioria de suas funções não fazem direito e ainda tem quem alega que pode ter uma produtividade alta com eles, podem até oferecer alguma produtividade dependendo do uso, mas na maioria sua experiência e limitada. Tablets se encaixam perfeitamente na categoria, pois são bloatwares dos e-readers (que era um gadget com objetivo específico, funcionar como leitor digital) diferente dos Tablets que atiram para tudo que é lado…

Perceberam aonde quero chegar com tudo isso? Chegamos em um ponto que os softwares deixaram de fazer o que se propunham e começaram a tentar executar todo tipo de tarefa! Deixaram de executar suas tarefas direito e passaram a fazer um monte de coisa, mas nada direito, minha teoria pode ser confirmada com o surgimento do Chrome, por que ele se tornou um navegador tão utilizado? Por causa do marketing da Google? Não! Pois era um navegador bom!

Ele se propunha a ser um navegador veloz, leve e que funcionava direito, nada de bloatware e cumpriu sua proposta, muito bem diga-se de passagem, e questão de tempo até ele se tornar o navegador mais utilizado do mundo, hoje o chrome está entrando na era bloatware, se atolando de recursos e questão de tempo até ele se tornar o novo Firefox.

[]‘s

The post O problema do Amarok, Firefox, Smartphones e Tablets appeared first on 0fx66.

Todas as dicas apresentadas, utilizam a edição de chaves na about:config, que pode ser acessada facilmente abrindo uma nova aba no Firefox e digitando about:config.

1. Exibindo imagens em alta qualidade: O Firefox tem a opção de mostrar imagens em alta qualidade, porém essa opção é desativada por padrão por utilizar muito processando acaba causando um efeito negativo na performance do navegador. Se você deseja ter imagens em melhor qualidade apesar do detrimento da performance altere o valor da chave “gfx.color_management.enabled” para “true”.
2. Desativando a checagem do antivírus dos downloads: Uma dica interessante quem usa o Firefox em sistemas windows, o Firefox sempre faz uma checagem nos arquivos baixados logo após o termino do download. Para desativar este recurso altere o valor da chave “browser.download.manager.scanWhenDone” para “false”.
3. Habilitando o corretor ortográfico em todos os campos de texto: E bem chato ter que ficar marcando toda “verificar ortografia” quando quiser quer alguma frase seja corrigida, então vamos fazer com que tudo digitado passe pelo corretor ortográfico, mude o valor da chave “layout.spellcheckDefault” mude para 2.
4. Abrindo resultados da caixa de busca em uma nova aba: Esta é uma das minhas preferidas!Para que ela abra uma nova aba e mostre os resultados, altere o valor “browser.search.openintab” para “true”.
5. Selecione o texto da barra de endereços com apenas 1 clique: Para que o texto da barra de endereços seja todo selecionado com apenas um click (como nos sistemas windows e mac). Altere o valor da chave “browser.urlbar.clickSelectsAll” para “true”
6. Usando a tecla “Backspace” no Firefox: É bastante comum o Firefox vim com a tecla backspace sem a função “voltar página”, para que ela volte as páginas ao ser pressionada, altere o valor “browser.backspace_action” para 0.
7. Melhorando a qualidade das fontes: Altere o valor da chave “browser.display.auto_quality_min_font_size” de 20 para 1. Essa dica ira aumentar a qualidade da renderização das fontes. Ao utilizar este recurso estaremos entrando no mesmo caso da dica 1, podem causar perca de performance.
8. Aumenta a velocidade de navegação com pipelining (cuidado): Está é a dica mais conhecida do about:config e não poderia ficar sem marcar presença. Altera as seguintes chaves:

network.http.pipelining – mude para “true”
network.http.proxy.pipelining - mude para “true”
network.http.pipelining.maxrequests - mude para 6
network.http.max-connections - mude para 96.
network.http.max-connections-per-server - mude para 32.

Atenção com o uso desta dica, o uso de pipeling nas conexões agiliza de fato a navegação, porém elas causam sobrecarga em pequenos servidores, dependendo da circunstancia, muitos administradores configuram seus servidores para evitar essa sobrecarga limitando a quantidade de conexões fornecidas para cada usuário, por este motivo o seu uso, pode não oferecer nenhuma melhoria na velocidade de navegação.

9. Removendo delay da renderização da página: Mais uma dica também muito popular, o Firefox por padrão aguarda, o download completo da página para iniciar sua renderização, mas você pode mudar isso, configurando a editando a chave “nglayout.initialpaint.delay”, se não existir crie ela, será uma inteira), atribua o valor 0.
10. Completar endereços automaticamente: Ao modificar esta chave, o Firefox completa automaticamente o endereço enquanto escrevemos, usando endereços do histórico ou dos favoritos, não sendo necessário clicar numa das sugestões para que esta apareça na barra. Modifiquem a chave “browser.urlbar.autoFill” para “true” para ligar esta opção.
11. Modificar o editor de código-fonte: Muita gente não gosta daquele editor default que o firefox utiliza para exibir o código-fonte das páginas, se você é um desses, e deseja mudar o editor basta alterar estas chaves: “view_source.editor.external” que deve ser modificada para “true” e “view_source.editor.path”, onde deve ser informado o diretório da aplicação de edição de texto.
12. Reduza o uso de RAM quando o Firefox estive minimizado (cuidado): Esta alteração irá “mover” o Firefox para o seu disco quando ele for minimizado, ocupando por isso menos memória. Crie uma nova chave Boolean com o nome “config.trim_on_minimize” e defina o valor como “true”. Terá de fazer um restart ao Firefox para que esta alteração fique ativada. Muito cuidado com o uso desta opção, pois o tiro pode sair pela culatra, pois movimentar o conteúdo da memória para o HD, pode ser demorado, causando um enorme delay ao minimizar e maximizar, pois o HD é tem a velocidade de leitura e escrita muito inferior se compramos com a velocidade da memória RAM. Então o uso desta chave fica a seu critério, recomendo fazer alguns testes com ela, é verificar se compensa gastar menos memória ou ter um delay ao minimizar seu navegador.
13. Desativando o tempo de espera da instalação de extensões: Modifique a chave “security.dialog_enable_delay” para 0, e adeus tempo de espera para instalar addons :)
14. Colando com o mouseQuem usa linux adora esse recurso, para colar textos com um click do scroll do mouse, basta modificar ou criar caso não exista (ela e inteira), a chave “mousewheel.withaltkey.action” para 1.
15. Desativando função “restaurar sessão: Simples e rápido, altere o valor da chave “browser.sessionstore.enabled” para “false”

Referências:

http://www.vivaolinux.com.br/dica/13-dicas-uteis-para-o-aboutconfig-do-Firefox?

http://pplware.sapo.pt/2007/05/24/as-15-dicas-mais-uteis-do-firefox/

http://securityhacker.org/artigos/189-dicas-do-firefox

http://wiki.archlinux-br.org/Firefox_Dicas_e_Truques

The post Compilação de dicas para o Firefox appeared first on 0fx66.