The Linux Counter

Te invitamos a formar parte, registrarte y registrar tus computadoras con GNU/Linux

http://counter.li.org/

Bruteforce Script exelente para WPA/WPA2

Buscando por la red encontre este exelente script para crear diccionarios "lista de combinaciones posibles para x numero de caracteres"

codigo:

#!/usr/bin/python
#
# :: Invasion Tux
# :: Script realizado por makiolo (makiolo@gmail.com) (Licencia GPL)
# :: Ultima version : http://blogricardo.wordpress.com/2008/12/28/script-para-generar-diccionarios-de-fuerza-bruta/
# :: Dependencias : python
#

import sys, math
from time import time, localtime, strftime

########################### CONFIGURACION #########################

LONGITUD = 8
ALFABETO = "abcdefghijklmnopqrstuvwxyz0123456789"

####################################################################

########################## FUNCIONES ###############################
def getVariacionesConRepeticion(ALFABETO , LONGITUD):
sumatorio = 0
for i in range(LONGITUD):
producto = 1
for j in range(i+1):
producto = producto * len(ALFABETO)
sumatorio = sumatorio + producto
return sumatorio
####################################################################

##################### VARS AUXILIARES ##############################
DEBUG = True
VERBOSE = True
variacionesConRepeticion = getVariacionesConRepeticion(ALFABETO , LONGITUD)
inicioReloj = time()
cont = 0
progreso = 0
####################################################################

while LONGITUD > 0:
try:
contadores = [] # ponemos los contadores a 0
for i in range(LONGITUD):
contadores.append(0)

fin = False
while not fin:
if DEBUG == True:
for i in range(LONGITUD):
sys.stdout.write(ALFABETO[contadores[i]])
sys.stdout.write("\n")

if VERBOSE == True:
if (cont % 600000 == 0) and (cont != 0):
progreso = cont*100.0/variacionesConRepeticion # porcentaje hasta ahora
progreso = round(progreso , 2)
finReloj = time() - inicioReloj # finReloj es lo que esta tardando el calculo
velocidad = cont / finReloj # palabras procesadas por segundo
velocidad = round(velocidad , 2)
estimado = finReloj * variacionesConRepeticion / cont # es lo que se estima en realizar todo el proceso
restante = estimado - finReloj # es lo que se estima en realizar lo restante
restante = restante / 60 / 60 # lo pasamos a horas
restante = round(restante , 2)
sys.stderr.write(str(progreso)+"% - Quedan "+str(restante)+" horas. La velocidad es de "+str(velocidad)+" palabras/seg\n")

cont = cont + 1
actual = LONGITUD - 1 # Pongo actual a la derecha del todo
contadores[actual] = contadores[actual] + 1 # Sumo 1 a las unidades

while(contadores[actual] == len(ALFABETO)) and not fin: # Propago el carry
if(actual == 0):
fin = True # FIN
else:
contadores[actual] = 0 # reinicia el actual contador
actual = actual - 1 # avanza a la izquierda
contadores[actual] = contadores[actual] + 1 # y le sumo 1

LONGITUD = LONGITUD - 1 # combinaciones para uno menos

except KeyboardInterrupt:
sys.stderr.write("Interrumpido por el usuario\n")
fin = True # Fuerzo las condiciones de salida
LONGITUD = 0

if VERBOSE == True:
sys.stderr.write("Terminado al "+str(progreso)+"% - Realizadas "+str(cont)+" combinaciones de "+str(variacionesConRepeticion)+"\n")


Podemos cambiar los caracteres a usar a nuestro gusto y el largo de la combinacion donde dice "LONGITUD"

Jaunty Jackalope viene con ext4 por defecto

Ya está disponible en las releases diarias de Ubuntu Jaunty Jackalope el sistema de ficheros Ext4 disponible en el Kernel de Linux a partir de la versión 2.6.28 y viene en el CD de la Alpha 3 que salio el dia 15 de Enero por lo que al realizar la partición podrá elegirse el sistema de ficheros Ext4.

Ext4 como antes mencionamos en el pasado post está diseñado para proporcionar un mejor rendimiento y aumentar la fiabilidad. También aumenta el tamaño máximo de archivos a un Exabyte y reduce la cantidad de tiempo que se requiere para llevar a cabo una operación fsck.

En Phoronix han realizado una prueba de rendimiento con una instalación de Ubuntu 9.04 y el sistema de ficheros Ext4 destaca en la IOzone, la prueba que escribe un fichero de gran tamaño.

Además se anuncia que esta Alpha 3 de Ubuntu vendrá con X.org versión 1.6

También han incluido un nuevo sistema de notificaciones similar a iconos emergentes en el escritorio. Puede verse un vídeo de muestra en este enlace

Quien desee realizar pruebas podrá descargarla aqui

http://cdimage.ubuntu.com/releases/jaunty/alpha-3/ (Ubuntu)

fuente: http://jvare.wordpress.com

Kernel 2.6.28 con soporte ext4!!!

La versión 2.6.28 del kernel Linux fue lanzada el 25 de diciembre, justo el día de navidad, con interesantes mejoras como el sistema de archivos ext4 que ha dejado de ser experimental.
Desde el sitio de kernelnewbies nos dejan conocer de manera detallada las nuevas características de esta versión, la cual contiene el soporte en fase estable de ext4, el nuevo sistema de archivos que promete mejor estabilidad, más características y performance. De ext3 a ext4 existe una mejora sustanciosas, contrario a lo que fue ext2 de ext3.
Una de las características de este nuevo sistema de archivos es que se puede pasar de ext3 a ext4 sin mayor dificultad y sin perdida de datos.
Otra de las mejoras en el kernel es el nuevo administrador de memoria GPUs GEM el cual se presume será una revolución al soporte gráfico de Linux.

kernel GNU/Linux con menos errores que su competencia.

De acuerdo a un estudio realizado por la Universidad de Stanford el kernel Linux tiene menos fallos en su código fuente que el software propietario.
Aunque este hecho es uno de los puntos principales que han defendido los usuarios del sistema Linux, el informe da a conocer datos precisos sobre el análisis realizado al kernel y la comparación con software propietario.
Según la publicación Wired se analizo el kernel Linux 2.6 presente en productos de la mano de Red Hat, Novell y otras empresas similares encontrando 985 fallos en 5.7 millones de lineas de código. En contra parte Windows XP, presenta fallos mucho más frecuentes en sus 40 millones de lineas de código.
De acuerdo a la Universidad Carnegie Mellon la mayoría del software propietario contiene de 20 a 30 bugs por cada 1,000 lineas de código lo que vendría a ser un aproximado de 114,000 a 171,000 fallos en 5.7 millones de lineas de código de seguir esta tendencia, mientras que el estudio arroja 0.17 bugs por cada 1,000 lineas de código en el kernel Linux.
De los 985 fallos la mayoría estuvieron en partes críticas del kernel. De estos, 569 pueden hacer que el sistema se crashe, 100 son fallos de seguridad y 33 influyen en el rendimiento del sistema. No obstante, se menciona que la mayor parte de estos fallos ya han sido corregidos actualmente.
El proyecto de análisis de código comenzó en el 2000 en la Universidad de Stanford y actualmente continua adelante con la finalidad de dar a conocer los resultados a la comunidad de desarrollo de Linux para ayudar en su mejora.
Seth Hallem, parte del proyecto de análisis de código, comenta:
“Nuestros hallazgos muestran que Linux contiene una muy baja tasa de defecto y es la prueba de la fuerte seguridad de Linux (…) Muchos agujeros de seguridad en el software son el resultado de errores de software que puede ser eliminados con una buena programación de procesos.”.
El artículo completo en: Linux: Fewer Bugs Than Rivals.