Auditando Senhas com ‘John the Ripper’

Disponibilizo um artigo sobre o JtR que fiz para o curso da 4Linux.

Eh bem intuitivo o artigo, servindo para quem esteje precisando da ferramenta.

Senhas JtR

Abracos.

Desenhos do Tio Bill

Para quem tem o humor negro da Microsoft como eu, vai adorar esses desenhos em homenagem ao nosso velho guerreiro Bill Gates.

Espero que gostem.

A Casa 2001 de Bill Gates

Matrix para Windows

Pornô(TM) para Windows

Livro e Caneta do Bill Gates

Desktops com gOS

A empresa Chip7, comeca a distribuir seus rapidos computadoes com o gOS. Uma alternativa aqueles sistemas que vivem cheio de pragas virtuais .

O preço dos PCs a €199 com o Green Operating System, jah apelidado de GoogleOS.

Veja abaixo um tela desse OS.

Abracos a Todos.

Logo do Blog

Quem quiser colocar o GNU TuX no seu bog linkand pra ka ai esta a logo.

YouTube de Livros??!!

Esse site eh uma novidade, ao menos pra mim, que ajudara e muito os estudos seja qual assunto for.

E otimo para quem vive esquecendo os livros e precisa de determinada materia seja onde for.

Divirtam!!!!heheheheh

CCJ do Senado aprova projeto que multa spam em R$ 1.000

da Folha Online

A CCJ (Comissão de Constituição e Justiça) do Senado aprovou nesta quarta-feira (5) um projeto de lei que prevê multas de até R$ 1.000 para quem enviar mensagens eletrônicas não solicitadas, os conhecidos spams.

O projeto ainda deve passar pela Comissão de Educação antes de ser encaminhado ao Congresso.

Pela proposta, toda mensagem eletrônica enviada para destinatário não consciente e que seja enviada de forma massificada fica caracterizada como spam.

O remetente é obrigado a identificar em cada mensagem que enviar itens como seu endereço físico ou endereço eletrônico, além de um mecanismo eficaz pelo qual o destinatário possa optar por não receber mais as mensagens.

A proposta também restringe a coleta automática de endereços de e-mails e proíbe que proprietários de bancos de dados de endereços eletrônicos divulguem as informações a terceiros sem consentimento.

Batalha

Nos EUA, desde 2004 uma lei federal estabelece regras para o envio de spams. A restrição, no entanto, não impossibilitou que o lucrativo negócio de envio de mensagens não solicitadas pela internet continuasse crescendo.

Um ano após a proibição, o número de spams circulando na internet passou a corresponder a 80% de todas as mensagens enviadas. Antes de a lei vigorar, o número de spams correspondia a 50% do total.

De acordo com dados da empresa especializada em segurança na internet, Barracuda Networks Inc, mais de 95% dos correios eletrônicos enviados em 2007 foram spams.

Maiores informações: http://www1.folha.uol.com.br/folha/informatica/ult124u379068.shtml

IBM oferecerá computador ‘livre de Microsoft’ na Europa.

A empresa de serviços de TI, IBM, se uniu com sócios da Áustria e Polônia para oferecer computadores pessoais sem produtos da Microsoft no mercado da Europa Oriental, segundo anunciou na feira tecnológica CeBIT 2008 de Hannover (Alemanha).

Maiores informacoes: http://www.elmundo.es/navegante/2008/03/05/tecnologia/1204708262.html

Intel Linux-Ready Firmware Developer Kit.

O centro de tecnologia open-source da Intel está envolvido em diversos projetos open-source com Linux tais como Threading Building Blocks, Moblin, PowerTOP, e o driver gráfico para X.Org. A Intel também tem interesse em outros projetos como Xen e KVM. Um dos projetos da Intel menos conhecidos, entretanto, é o Linux-ready Firmware Developer Kit. O kit é um CD bootável que analisa a BIOS ou EFI no sistema de testes para ver quão bem ele trabalha com Linux e quais características são suportadas via firmware. O propósito primário deste kit é para uso por desenvolvedores de firmware, mas também pode ajudar usuários em determinar quais características de suas BIOS funcionará com Linux.

Mapeando Erros Para Exceções

Há casos em que é interessante ter uma hieraraquia de exceções para vários tipos de erros relacionados que podem ocorrer quando lidamos com chamadas do sistema operacional. Podemos mapear esses erros diretamente para exceções específicas usando uma classe especialmente projetada para isso. Aqui temos um exemplo de uma hierarquia de exceções e uma classe que automaticamente mapeia erros de sockets para suas respectivas exceções:

 

Código

   1 class Error(Exception):
   2     """Exceção base da hierarquia"""
   3 
   4 class SocketError(Error):
   5     """Um erro ocorreu com um socket"""
   6 
   7 class ConnectionError(SocketError):
   8     """Um erro ocorreu com a conexão"""
   9 
  10 class ClientClosed(ConnectionError):
  11     """-1"""
  12 
  13 class AddressAlreadyInUse(ConnectionError):
  14     """errno: 98"""
  15 
  16 class AddressNotAvailable(ConnectionError):
  17     """errno: 99"""
  18 
  19 class NetworkIsDown(ConnectionError):
  20     """errno: 100"""
  21 
  22 class NetworkUnreachable(ConnectionError):
  23     """errno: 101"""
  24 
  25 class NetworkReset(ConnectionError):
  26     """errno: 102"""
  27 
  28 class ConnectionAborted(ConnectionError):
  29     """errno: 103"""
  30 
  31 class ConnectionResetByPeer(ConnectionError):
  32     """errno: 104"""
  33 
  34 class NoBufferSpaceAvailable(ConnectionError):
  35     """errno: 105"""
  36 
  37 class SocketIsConnected(ConnectionError):
  38     """errno: 106"""
  39 
  40 class NotConnected(ConnectionError):
  41     """errno: 107"""
  42 
  43 class TCPTimeOut(ConnectionError):
  44     """errno: 110"""
  45 
  46 class ConnectionRefused(ConnectionError):
  47     """errno: 111"""
  48 
  49 class HostIsDown(ConnectionError):
  50     """errno: 112"""
  51 
  52 class HostUnreachable(ConnectionError):
  53     """errno: 113"""
  54 
  55 class ConnectionAlreadyInProgress(ConnectionError):
  56     """errno: 114"""
  57 
  58 # Mapa dos códigos de erro para as exceções:
  59 
  60 _connErrorMap = {-1:ClientClosed,
  61                  98:AddressAlreadyInUse,
  62                  99:AddressNotAvailable,
  63                  100:NetworkIsDown,
  64                  101:NetworkUnreachable,
  65                  102:NetworkReset,
  66                  103:ConnectionAborted,
  67                  104:ConnectionResetByPeer,
  68                  105:NoBufferSpaceAvailable,
  69                  106:SocketIsConnected,
  70                  107:NotConnected,
  71                  110:TCPTimeOut,
  72                  111:ConnectionRefused,
  73                  112:HostIsDown,
  74                  113:HostUnreachable,
  75                  114:ConnectionAlreadyInProgress}
  76 
  77 # Classe especial que mapeia os códigos para as exceções:
  78 
  79 class MapSocketError(ConnectionError):
  80     def __init__(self, reason):
  81         # reason é uma tupla ou lista contendo (código de erro,
  82         # mensagem de erro)
  83         code, msg = reason
  84         # caso o erro não exista, ConnectionError é usada
  85         exc = _connErrorMap.get(code, ConnectionError)
  86         self.__class__ = exc
  87         ConnectionError.__init__(self)
  88 
  89 
  90 #Testando o funcionamento da classe:
  91 
  92 if __name__ == "__main__":
  93 
  94     for code, exc in _connErrorMap.items():
  95         try:
  96             raise MapSocketError((code, ""))
  97         except exc:
  98             print "OK - ", exc
  99         except:
 100             print "FALHOU - ", exc

 

Exemplo de uso

Aqui temos um exemplo de uso num objeto socket usado em um servidor. Não precisamos nos preocupar com qual exceção devemos levantar em cada erro. Basta passar o código de erro e a classe faz o resto.

   1 import socket
   2 from Error import MapSocketError
   3 
   4 class ServerSocket:
   5 
   6     def __init__(self, addr):
   7         self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
   8         self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
   9         self.fileno = self.socket.fileno
  10 
  11     def bind(self, host, port):
  12         try:
  13             self.socket.bind((host, port))
  14             self.addr = (host, port)
  15         except socket.error, reason:
  16             raise MapSocketError(reason.args)
  17 
  18     def listen(self, backlog=1):
  19         try:
  20             self.socket.listen(backlog)
  21         except socket.error, reason:
  22             raise MapSocketError(reason.args)
  23 
  24     def accept(self):
  25         try:
  26             sock, addr = self.socket.accept()
  27             return sock, addr[0], addr[1]
  28         except socket.error, reason:
  29             raise MapSocketError(reason.args)

Depois, na utilização da classe ServerSocket, podemos capturar as exceções individualmente, de acordo com o código de erro, ou podemos usar a classe base da hierarquia, ConnectionError.

YEGO, pen-drive expansivel.

Imagine um pen-drive que se encaixa um ao outro, em forma de Y, tornando-se expansivel….. imagino??? entao esse é o YEGO. Como ele possui a caracteristica de ser montavel, nada melhor do que referecialo aos nossos antigos brinquedinhos LEGO. Sendo em formato de Y, logo foi batizado de YEGO.

Maiores informações : http://www.ritekusa.com/product_buy.asp?division_id=3&products_id=26