12 Tutoriales rails => http://www.digitalmediaminute.com/article/1816/top-ruby-on-rails-tutorials
Rails Guides => http://guides.rubyonrails.org/  (ESTA ES GENIAL)

http://media.rubyonrails.org/video/rails_blog_2.mov

Language: Ruby
#Name program = Killer-Hash
#Version = beta
#Lenguaje = ruby
#Autor = Guason
 
 
 
require 'digest/md5'
 
hash=ARGV[0]
file=ARGV[1]
 
if !hash || !file
 
print "\n\t\t\tKiller-Hash by Guason\t\t\t\n\n\n"
print "Sinopsis = #{$0} <HASH> <FILE>\n\n"
print "<HASH> Hash a crackear\n"
print "<FILE> Diccionario a usar\n\n"
print "Written by Guason\n\n\n"
exit(1);
 
else
 
 
f=File.open(file)
dic=f.readlines
 
dic.each { |stooge| 
digest = Digest::MD5.hexdigest(stooge)
 
if hash == digest 
print "\n\nEl password es #{stooge}\n\n"
exit(1);
 
else 
 
print  " #{hash}  = #{digest} = !?\n" 
 
end
 
 
 
 
 
}
 
 
 
print "\n\nWritten by Guason || 2009\n\n"
print "Visita guason-cracker.blogspot.com & infierno-hacking.webcindario.com\n\n"
exit(1);
 
 
end
 
 
#Agradecimientos = Gracias A ozx y a todo el foro Under Security por ayudarme en mis dudas raras y #tambien a explorer de perlenespañol  que tmb me ayudo a perfeccionarme en perl 
#Email = chairface_darkhat@hotmail.com
#Web = infierno-hacking.webcindario.com
#Blog = guason-cracker.blogspot.com

Language: Ruby
#Name program = Scanner-Port
#Version = beta
#Autor = Guason
 
 
 
require 'socket'
 
host=ARGV[0]
pi=ARGV[1]
pf = ARGV[2]
 
if !host 
 
print "\nScanner Port by Guason\n\n"
print "Modo de uso = <HOST> <PUERTO INICIAL> <PUERTO FINAL>\n\n\n"
print "<HOST> = Ip o host a scanear\n"
print "<PUERTO INICIAL> = Puerto inicial\n"
print "<PUERTO FINAL> =Puerto final\n\n\n"
print "Written by Guason\n\n\n"
exit(1);
 
 
 
else
 
host=ARGV[0]
 
print "\n\nIniciando scaneo a #{host} con parametros #{pi}-#{pf}\n\n"
 
 
for port in (pi..pf)
 
 
 
begin
sock=TCPSocket.new(host,port) 
 
rescue
 
print ""
 
 
 
 
 
else
 
 
print "Puerto  #{port} ABIERTO \n"
 
 
 
end
end
 
 
print "\n\nScaneo finalizado\n\n"
print "Written by Guason || 2009\n\n"
exit(1);
 
 
end
 
 
 
#Agradecimientos = protos por sus manuales bien explicados y a todo el foro Under Security
#Email Autor = chairface_darkhat@hotmail.com
#wEB = infierno-hacking.webcindario.com
#Blog = guason-cracker.blogspot.com
#Good Bye

var = Win32API.new(api, funcion, param3, param4) 
var.Call(parametros)

Language: Ruby
require 'Win32API' 
 
a = Win32API.new("user32", "SystemParametersInfo", ['L', 'L', 'P', 'L'], 'L') 
a.Call(20, 0, "\miimagen.bmp", 0)

class Class2 <Class1 
def initialize(parametros Class2) 
super 
@parametro=parametro 
... 
end 
end

 
class Login #Creamos una clase que llamaremos login 
def initialize(foro, user, pass) #el initialize obligatorio con los parametros, foro user y pass 
@foro=foro #definimos tres variables de instancia con los valores recibidos de los parametros 
@user=user # 
@pass=pass # 
end # terminamos initialize 
def user # Definimos un metodo llamado user 
@user #el cual nos devuelve el valor del usuario. Como veis, podemos obviar el return 
end # No explico las siguientes linias, hacemos exactamente lo mismo para todos los parametros 
def foro 
@foro 
end 
def pass 
@pass 
end 
end 

log=Login.new('z0l', 'pRotos', 'mipass') #Creamos un objeto 
log.user #Y nos dará el nombre del usuario. 
log.foro # 'z0l' 
log.pass # Nos dará la pass del user.

class Login 
def initialize(foro, user, pass) 
@foro=foro 
@user=user 
@pass=pass 
end # Hasta aquí era lo mismo que antes 
attr_reader :foro, :user, :pass #Creamos 3 atributos de lectura, con los valores de foro, user y pass. Esta linia hace #exactamente lo mismo que el code anterior, nos crea automaticamente los metodos necesarios para acceder a esos #valores 
end #terminamos la clase, no hace falta poner un end para el attr_ 

log=Login.new('z0l', 'pRotos', 'pass') #creamos el objeto, como siempre 
log.user #dará pRotos 
log.foro # z0l 
log.pass # pass

def Login 
def initialize(foro, user, pass) 
@foro=foro 
@user=user 
@pass=pass 
end #Lo mismo de antes. 
attr_reader :user # Creo el atributo de lectura que seria lo mismo que crear un metodo para acceder a @user 
def user=(newuser) # creo un metodo llamado user= y que recibe el parametro newuser 
@user=newuser #cambio el valor de @user por el parametro recibido 
end 
end # Lo he hecho solo para user, porque no es necesario hacerlo para los 3 parametros, asi ya lo vemos 

log=Login.new('z0l', 'pRotos', 'pass') 
log.user #Como hemos creado el attr_reader, esto nos da pRotos 
log.user = "pRot0s" # Llamamos al metodo user= para cambiarle el valor a @user 
log.user # Y nos da pRot0s

def Login 
def initialize(foro, user, pass) 
@foro=foro 
@user=user 
@pass=pass 
end #como siempre...creamos el initialize con las variables de instancia 
attr_reader :foro, :user, :pass #creamos los 3 atributos de lectura 
attr_writer :foro, :user, :pass #Y también de escritura 
end # Terminamos nuestra clase Login 

log=Login.new('z0l', 'pRotos', 'pass') 
log.pass # Nos dará pass 
log.pass="12345" # cambiamos la pass 
log.pass # Nos dará 12345

class Ascii #definimos la clase 
def initialize(cadena) #definimos el initialize como siempre, y recibimos el parametro 
@cadena=cadena #creamos una variable de instancia con el valor del parametro 
end #cerramos initialize 
def to_ascii #definimos el metodo to_ascii 
print "("                                                  
@cadena.each_byte {|x| print x, " ,"} # Cogemos cada byte de la cadena y lo escribimos uno a uno ( nos los devuelve en 
# su numero ascii. 
print ")" # lo de los parentesis es una cuestion puramente estética. 
end #terminamos metodo 
end #terminamos clase

require 'ascii' # requerimos el otro code, fijaos que no hay que poner el .rb. Ahora tenemos la clase lista en este code para 
# ser usada 
#.......Aqui iria el bloque con todas las encriptaciones, mirar el encripter que he codeado que esta en esta misma sección 
#para ver como iria eso. 
a=Ascii.new("cadena a traducir a ascii").to_ascii #Creamos el objeto de nuestra clase y le pasamos directamente el metodo 
#encargado de traducirlo a ascii codeado por nosotros. 
print a #mostramos resultados

def nombrefuncion(parametros) #Definimos una funcion. Puede ser que queramos pedirle parametros al usuario, entonces 
# van entre parentesis, si no queremos parametros, ponemos los parentesis vacios () 
bloque funcion #Aqui iria todo lo que queremos que haga la funcion 
end # cerramos la funcion 
 
nombrefuncion(parametros) #Llamamos y ejecutamos la funcion.

def saludo(nombre) 
print "Buenos dias #{nombre}" 
end 
saludo("pRotos")

class Nombreclase #definimos la clase Nombredeclase. Todas las clases empiezan por mayuscula 
def initialize(parametros) #definimos el metodo initialize, este metodo es obligatorio para todas las clases, es el metodo 
# que se activará automáticamente al crear un objeto de nuestra clase 
bloque initialize # lo que hará el metodo initialize 
end #terminamos el metodo 
def nombremetodo #creamos otro metodo 
bloque nombremetodo #con su respectivo bloque 
end # y lo cerramos 
... #podemos definir tantos metodos como queramos 
end # y terminamos la clase 

var=Nombreclase.new(parametros) #creamos un objeto de nuestra clase asociado a la variable var y con los parametros 
# que queramos 
var.nombremetodo #le pasamos el metodo nombremetodo a nuestro objeto

 
class Cambio #creamos la clase Cambio 
def initialize(texto) # definimos el initialize con el parametro texto 
@texto=texto # creamos una variable de metodo ( las variables que se usan en los metodos tienen que llevar @ delante) 
# con el valor del parametro que nos pasan 
end #terminamos el initialize 
def positivo #definimos el metodo positivo 
a=@texto.gsub("una mierda", "genial") # Si alguien no entiende lo que hace gsub que pregunte 
return a #Lo que devolverá el metodo es el return, en este caso la variable a 
end # terminamos el metodo positivo 
end #y cerramos la clase 

var=Cambio.new("Esta guia es una mierda") #creamos un objeto de la clase Cambio con el parametro "esta guia es una 
# mierda" y asociado a la variable var 
print var.positivo #le pasamos el metodo positivo. Esto daria: "Esta guia es genial"

require 'digest/md5' 
class String 
	def initialize(text) 
		@text=text 
	end 
	def sep 
		a=@text.split("") 
		return a.join(" ") 
	end 
	def cra 
		n=1 
		a=@text.split("").each { |x| 
		if n%2==0 
			print x 
		else 
			print x.upcase 
		end 
		n+=1 
		} 
		return a.delete("Cadena de pruebas") 
	end 
	def cra2 
		n=1 
		a=@text.split("").each {|x| 
		if n%2!=0 
			print x 
		else 
			print x.upcase 
		end 
		n+=1 
		} 
		return a.delete("Cadena de pruebas") 
	end 
	def md5 
		Digest::MD5.hexdigest(@text) 
	end	 
	def to_ascii 
		a=@text.each_byte {|x| print x, " ,"} 
		return a.delete("Cadena de pruebas") 
	end 
end 
prueba=String.new("Cadena de pruebas") 
print prueba.sep, "\n" 
print prueba.cra, "\n" 
print prueba.md5, "\n" 
print prueba.cra2, "\n" 
print prueba.to_ascii, "\n"

require 'ftools' #Requerimos la libreria. Realmente para muchos de los metodos no es necesaria, pero por si acaso 

file=File.new('nombre del archivo', 'modo') #Donde modo puede ser por ejemplo 'r' (lectura) o 'w' (escritura), entre otros.

File.metodo('archivo') #Sin hacer el File.new() tambien podemos pasar metodos. Pero yo prefiero siempre crear el objeto

file.atime #Devuelve la fecha de la última vez que se accedió a ese archivo 
file.ctime # Devuelve la fecha de la última vez que se cambió ese archivo. 
file.mtime #Devuelve la fecha de modificación 
file.chmod(modo, archivo/s) #Cambia el modo del/los archivo/s que pongamos. No hace falta decir que necesitamos root... 
file.chown(owner, grupo) #Cambia el owner y el grupo del file. 
File.compare(archivo1, archivo2) #Devuelve true si los archivos son identicos. Como veis este metodo es uno de los que hay 
#que pasarle directamente a la clase File. Por eso pongo File en mayusculas 
File.copy(archivo1, archivo2) #Copia el archivo1 a archivo2 ( se le puede dar una nueva ruta). Otro a pasarle a File 
file.delete #Eliminamos el archivo. 
file.unlink #Hace lo mismo 
file.dirname #Devuelve el directorio del archivo 
file.executable? #Devuelve true si el archivo es un ejecutable válido. el ? en los metodos tiene esa función: devuelve true 
#o false en relación a lo que sea. Por ejemplo : .directory? deuvelve true si es un directorio, etc... 
File.exist?('nombrearchivo') #Devuelve true si el archivo existe. Como veis aqui utilizo File con mayuscula porque llamo a la 
#clase File. Si hubiese puesto file, al hacer referencia al objeto que habiamos creado, siempre existiria... 
file.extname #Devuelve el nombre de la extensión. 
File.makedirs(directorio) #Crea en directorio con sus subdirectorios si hay. 
File.move(desde, hacia) # Este creo que tambien se lo podriamos pasar a file. es cuestion de probar. 
File.rename('antiguo nombre', 'nuevo nombre') #Renombra un archivo, este tambien funciona con file, creo. 
file.size # Adivinad que hace xD, devuelve el tamaño del archivo 
file.readable? #Devuelve true si se puede leer 
file.writable? #Devuelve true si se puede escribir.

 
require 'tk' #Requerimos la libreria tk. 

root=TkRoot.new() { title "Prueba de App Gráfica"} # Creamos el objeto principal, seria como crear la pantalla. Con título

bot=TkButton.new(root) { 
text "Texto dentro del botón" 
pack("side=>'top') 
}

	TkButton.new(root) { 
	text " Clear" 
	command proc { 
	label.clear 
	} 
	pack("side"=>"bottom") 
	}

entrada=TkEntry.new(root) { 
pack( padx 20 ; pady 20; side 'top' ) 
} 
#Creamos una entrada de texto.Lo empaquetamos con algunas medidas: 20px para el eje de las x y otros 20 verticales. 
entrada.insert(0, "texto en la entrada") #Y luego le escribimos algo

 
label=TkLabel.new(root) { 
text "texto de la etiqueta" 
} 
label.pack(lo mismo de antes...) #Como veis en este caso el pack lo he puesto como un metodo para variar

 
caja = TkText.new(root) { width 25; height 2 }.pack("side"=>"bottom")

caja.insert('end', "Texto a insertar") #Así de sencillo

TkMessage.new(root) { text "texto que quieras" }.pack("side"=>"bottom")

image = TkPhotoImage.new('file'=>"foto.gif", 'height'=>25) 
label_foto = TkLabel.new(root) { image image }.pack("anchor"=>"e")

menu = TkMenu.new() #creamos el objeto menu 
pri = TkMenu.new(menu) #Creamos un par de huecos para  menus 
sec = TkMenu.new(menu) 
menu.add('cascade', 'menu'=>pri, 'label'=>"Archivo") #Le ponemos un menu en cascada al primer hueco, de nombre Archivo 
pri.add('command', 'label'=>"Quit", 'command'=>proc { root.destroy })# Añadimos una opción a la cascada del hueco pri 
#La opción se llama 'Quit', y lo que hará es lo que hay en la opción 'command'. En este caso destruir root, cerrando la #pantalla. 
menu.add('cascade', 'menu'=>sec, 'label'=>'Editar') #Creamos otro menu en cascada para el segundo hueco, nombre Editar 
sec.add('command', 'label'=>"1", 'command'=>proc { ... }) #Añadimos la opcion 1 a la cascada sec ( si, es tarde, me #queda poca imaginación, no he puesto el proc, y el nombre de la label es deprimente, y que xD 
sec.add('command', 'label'=>"2", 'command'=>proc {...} #Podriamos seguir añadiendo hasta que queramos. 

root.menu(menu)#Añadimos los menús al root 
Tk.mainloop(root)#Imprescindible, ahora explico porqué

Tk.mainloop(root)

var1=TkVariable.new() #Creamos la variable Tk 

TkEntry.new(root) { #Creamos una entrada de datos 
textvariable(var1) #Lo que introduzca el user se almacenará en la variable var1 
pack() #empaquetamos y cerramos bloque de widget 
} 

print var1.value #Fijaos, hay que poner el .value siempre para acceder a la variable...

 
widget.bind("FocusIn") { #cuando el ratón entre en el widget 
bloque, proceso que queramos, imaginación! #Hacemos lo que hayamos puesto en el bloque 
}

Quote

Any Shift Control Alt Meta, M
Mod1, M1 Mod2, M2 Mod3, M3 Mod4, M4 Mod5, M5
Button1, B1 Button2, B2 Button3, B3 Button4, B4 Button5, B5 Double Triple

Quote

Activate Enter KeyPress, Key ButtonPress, Button FocusIn Map
Deactivate Leave KeyRelease ButtonRelease FocusOut Unmap
Circulate Colormap Configure Destroy Expose
Gravity Motion Property Reparent Visibility

text=TkText.new().pack() #Creamos un textbox, me da vagueza ahora hacerlo mejor, asi ya basta 
text.font("aahs") #Le ponemos la font "aahs" al texto de text.

TkFont.families()

Quote

irb(main):004:0> TkFont.families()
=> ["mgopenmoderna", "aahs", "clearlyu devangari extra", "fs", "freemono", "tlwgtypist", "clearlyu arabic", "anjalioldlipi", "purisa", "garuda", "mgopenmodata", "lohit gujarati", "clearlyu arabic extra", "fixed", "lucidatypewriter", "courier 10 pitch", "mukti", "open look glyph", "lohit hindi", "bitstream charter", "clearlyu pua", "utkal", "shmookh", "mgopencanonica", "malotf", "clean", "terminal", "gothic", "new century schoolbook", "bitstream vera sans mono", "clearlyu alternate glyphs", "kasr", "loma", "lucidabright", "bitstream vera serif", "muktinarrow", "freeserif", "song ti", "dejavu sans", "open look cursor", "helvetica", "mincho", "tlwgmono", "gentium", "clearlyu", "courier", "lucida", "clearlyu devanagari", "nil", "mcs", "mgopencosmetica", "fangsong ti", "lohit punjabi", "charter", "aga", "vemana2000", "gentiumalt", "times", "norasi", "newspaper", "dejavu sans mono", "rachana", "clearlyu ligature", "lohit tamil", "freesans", "dejavu serif", "dotum", "batang", "tlwgtypewriter", "symbol", "bitstream vera sans", "malige"]

font = TkFont.new('courier') #Cogemos la font courier de base 
font.configure('size'=>36)  # le augmentamos el tamaño a 36 
text.font(font) #Le pasamos nuestra font modificada a nuestro textbox.

Quote

-Joooo las aplicaciones que 'programan' en VB molan mucho, tienen botoncitos y eso, y en cambio lo nuestro solo vale por pantalla...

-VB mola un monton, puedes hacer unos programas muy bonitos y buenos con él...

require 'socket' 
begin 
sock=TCPSocket.new('156.67.43.33', 67) 
rescue 
print "Se ha producido un error\n" 
else 
print "Conexión establecida 
end

require 'socket' 
begin 
sock=TCPSocket.new('156.67.43.33', 67) 
rescue Errno::ECONNREFUSED 
print "El socket no se pudo conectar, host invalido o puerto cerrado\n" 
else 
print "Conexión establecida 
end

require 'socket' 
begin 
sock=TCPSocket.new('156.67.43.33', 67) 
rescue Errno::ECONNREFUSED 
print "El socket no se pudo conectar, host invalido o puerto cerrado\n" 
rescue nombreerror2 
print "No se pudo conectar por culpa de..." 
rescue nombreerror5 
print "No se pudo conectar por la causa tal..." 
rescue nombreerror4 
print "No se pudo conectar porque..." 
else 
print "Conexión establecida 
end

require 'socket' 
begin 
sock=TCPSocket.new('156.67.43.33', 67) 
rescue Errno::ECONNREFUSED 
print "El socket no se pudo conectar, host invalido o puerto cerrado\n" 
rescue nombreerror2 
print "No se pudo conectar por culpa de..." 
rescue nombreerror5 
print "No se pudo conectar por la causa tal..." 
rescue nombreerror4 
print "No se pudo conectar porque..." 
else 
print "Conexión establecida 
ensure 
sock.close() 
end

require 'net/http' #Lo primero de todo es requerir la libreria 
http= HTTP.start(host) #Creamos un objeto http al host que queramos

http.send_request(metodo, path) #Envia la peticion metodo ( GET, POST, HEAD etc) en el path que queramos. 
http.get(path) #Enviamos la peticion get al path seleccionado. Para ver el contenido de la petición tendriamos que acceder 
                       #al body (ej: get=http.get('/index.html') print get.body 
http.get_print(host, path) #Lo mismo que antes pero en una sola linia. Recibe el body de la respuesta 
http.get_response(host, path) #Recibe el response de la respuesta GET. 
Net::HTTP.new(host, puerto) #Hace lo mismo que el start, pero sin abrir la conexion tcp. Podemos pasar a traves de proxy: 
Net::HTTP.new(host, puerto, direccionproxy, puertoproxy, proxyuser, proxypass) #El unico obligatorio a poner es el host. 
http.copy(path) #Envia una peticion COPY al path seleccionado 
http.delete(path) #Lo mismo pero DELETE 
http.head(path) #Petición HEAD 
http.trace(path) #Metodo TRACE 
http.options(path) #Mas de lo mismo, metodo OPTIONS 
http.request(metodo) { |respuesta| } #Envia la peticion (request) que queramos (metodo que le damos) y almacena los #resultados en un bloque

proxy=Net::HTTP::Proxy(direcciondelproxy, puertodelproxy) #Creamos un objeto HTTP pasando detras de un proxy 
proxy.start(host) #Hacemos un start con el host que queramos ya detrás de nuestro proxy ^^

require 'net/ftp' #Cargamos la libreria... 
ses=Net::FTP.new(host) #Establecemos un objeto de la clase FTP con la conexión al host.

ses=Net::FTP.new(host, user, pass) #La mayoria de host ftp piden user y pass. Hacemos directamente el login. 
ses.Net::FTP.open(host, user, pass) {|ftp|} #Lo mismo que antes pero además nos devuelve un bloque. (Solo el host es 
#Imprescindible)

 
ses.chdir(directorio) #Cambiamos de directorio 
ses.connect(host, puerto) #Conectamos con el host, si no ponemos el puerto, será el default FTP. 
ses.delete(file) #Borra el archivo que queramos ( teniendo permisos, claro está) 
ses.get(file) #Pedimos el archivo remoto especificado. 
ses.dir #Es como el comando list 
ses.getdir #Es como el comando pwd 
ses.login(user, pass) #A veces es necesatio loggearse, con esto establecemos el login. 
ses.system() #Devuelve información del sistema 
ses.voidcmd(comando) #Envia un el comando especificado 
ses.sendcmd(comando) #Envia el comando y además devuelve la respuesta. 
ses.rmdir(directorio) #Elimina el directorio especificado 
ses.rename(antiguonombre, nuevonombre) # Renombra un fichero remoto 
ses.putfile(file) #Sube nuestro file local que queramos 
ses.mkdir(directorio) #Crea un directorio remoto 
ses.close() #Se terminó la conexión.

 
require 'net/ssh' #Seguro que adivinais que hace 
sesion=Net::SSH.start(host, user, pass) # Lo mismo de siempre, crear el objeto principal con la conexion.

sesion=Net::SSH.start(host, user, pass) {|ssh| 
shell=ssh.shell.sync # Sincronizamos la shell ^^( el ssh es la variable que nos devuelve el bloque con la conexion) 
shell.send_comand(comando) # Enviamos el comando que queramos. 
shell.exit #Terminamos la shell 
}

 
require 'rubygems' #Para utilizar hpricot necesitamos incluir tambien rubygems 
require 'open-uri' #Necesitamos tambien esta libreria... 
require 'hpricot' #Ahora si 

web=Hpricot(open('www.ejemplo.com')) #Creamos el objeto con la web parseada

 
web.search('loquesea') #Buscará en el resultado del objeto ( get de la pagina ) todo lo que tenga coincidencia con loquesea 
web.at('loquesea') #Buscará la primera coincidencia con loquesea.

print web.at('title')

web.at('title').inner_html # Buscamos el titulo de la pagina y le quitamos las etiquetas de titulo para leer solo el contenido 
web.at('loquesea').to_html #Justo lo contrario, buscamos lo que sea con su respectiva etiqueta html en la web.

require 'rubygems' # Para esta liberia necesitamos rubygems tambien 
require 'mechanize' # Incluimos la liberia que nos interesa. 
 
agent = WWW::Mechanize.new #Como siempre, creamos el objeto al que le pasaremos los metodos.

agent.get('www.ejemplo.com') #Mandamos un GET a donde queramos... 
agent=agent.set_proxy('direccionproxy', puertodelprocy) # Establecemos la conexión mediante proxy nos vendrá bien...

 
formulario=agent.form('nombre del formulario html') # Primero buscamos el nombre del formulario con el que queramos #interactuar 
formulario=agent.forms.first #Si sabemos que el formulario es el primero del code html pues podemos ponerlo asi 
formulario.User='user' #Rellenamos el campo user con lo que queramos 
formulario.Pass='pass' #Rellenamos el campo pass con lo que queramos 
#En cada web, los fomurlarios de login, tienen campos de user y pass, el caso seria mirar en el codigo fuente como se #Llama el formulario, como se llaman los campos que nos interesan y... 
acc= agent.submit formulario #'pulsamos el botón submit', es decir, enviamos los datos del formulario a la web.

agent = WWW::Mechanize.new 
agent.user_agent_alias = 'navegador' #Cambiamos el header user-agent, que es el de nuestro navegador. Alguien ha dicho 
#inyección por headers HTTP??? xDD 
search_form = page.forms.with.name("f") #Buscamos los formularios los nombres de los cuales sean f 
search_form = page.forms.with.name("f").first #Buscamos solo el primer formulario que se llame f 
search_results = agent.submit(search_form) #Otra manera de hacer lo que haciamos antes: Ya hemos escrito en nuestro 
#formulario y con esta linia lo enviamos 
puts search_results.body #Recibimos la respuesta de la pagina a nuestro submit 
link = page.links.text(/Log In/) #Buscamos los links de la pagina que contengan la cadena 'Log in' 
page = agent.click(link) #Los clickamos. Alguien ha dicho bot??? xD 
agent.back() #Equivale a darle al botón atrás en el navegador 
agent.cookies() #Devuelve las cookies almacenadas 
agent.get_file(urldelafile) #Devuelve el contenido del archivo especificado 
get(url, referer='loquesea') #Puedes establecer el referer

cookies=WWW::Mechanize::CookieJar.new() #Creamos un objeto que nos servirá para trabajar con cookies 
cookies.add(uri, cookie) #Añadimos una cookie. 
cookies.clear!() #Borramos todas las cookies 
cookies.cookies(url) #Muestra las cookies que tenemos de esa web 
cookies.load(archivo, format=) #Guardamos las cookies en el archivo que queramos con el formato adecuado

 
require 'resolv' 
ip =Resolv.getaddress(host) #En este caso host seria un nombre de dominio y nos devolveri su IP 
host = Resolv.getname(ip) #En este caso le damos la IP y nos devuelve el nombre de dominio..

 
require 'socket' #Lo primero es llamar a la liberia encargada 
sock=TCPSocket.new('www.ejemplo.com', 80) #Creamos un objeto (sock) con la conexion al host ejemplo.com por el puerto 80

 
sock.print "Datos a enviar" #Le envia lo que sea al socket 
sock.recv(999) #Recibe datos del socket. El numero es la cantidad de datos 
sock.listen(1) #Acepta tantas conexiones como el numero entero entre (), en este caso solo acepta la primera conexion 
sock.close #Cierra la conexi?n.
sock.read #Lee toda la respuesta del socket

 
sock=TCPSocket.new('www.google.com', 80) #Establecemos conexi?n. 
sock.print "GET HTTP/1.1\nHost: www.google.com\n" #Hacemos una petici?n GET al host 
rec=sock.recv(999) #Recibimos datos 
print rec #Imprimimos datos 
sock.close #Cerramos conexi?n

 
Socket.getaddrinfo(host, puerto) # Nos devolver? informaci?n sobre la conexi?n de ese host en ese puerto.

irb(main):001:0> require 'socket' 
=> true 
irb(main):002:0> Socket.getaddrinfo('www.google.com', 80) 
=> [["AF_INET", 80, "lm-in-f147.google.com", "66.102.9.147", 2, 1, 6], ["AF_INET", 80, "lm-in-f147.google.com", "66.102.9.147", 2, 2, 17], ["AF_INET", 80, "lm-in-f147.google.com", "66.102.9.147", 2, 3, 0], ["AF_INET", 80, "66.102.9.99", "66.102.9.99", 2, 1, 6], ["AF_INET", 80, "66.102.9.99", "66.102.9.99", 2, 2, 17], ["AF_INET", 80, "66.102.9.99", "66.102.9.99", 2, 3, 0], ["AF_INET", 80, "lm-in-f104.google.com", "66.102.9.104", 2, 1, 6], ["AF_INET", 80, "lm-in-f104.google.com", "66.102.9.104", 2, 2, 17], ["AF_INET", 80, "lm-in-f104.google.com", "66.102.9.104", 2, 3, 0]]

irb(main):003:0> Socket.getaddrinfo('www.google.com', 'ftp') 
=> [["AF_INET", 21, "66.102.9.99", "66.102.9.99", 2, 1, 6], ["AF_INET", 21, "lm-in-f147.google.com", "66.102.9.147", 2, 1, 6], ["AF_INET", 21, "lm-in-f104.google.com", "66.102.9.104", 2, 1, 6]]

 
sock=TCPSocket.new(host, puerto) 
select [sock], nil, nil, timeout

 
server=TCPServer.new(666) #Dejamos a la escucha el puerto 666 
server.listen(1) #Aceptamos s?lo la primera conexi?n

  CRLF = "\r\n" 
  req = "GET #{path} HTTP/1.1#{CRLF}Host: #{host}#{CRLF*2}"

require 'socket' 
host = ARGV[0] 
port = ARGV[1] 
if !host || !port 
	puts " Uso: scanp.rb <host> <puerto>" 
else 
	sock = TCPSocket.new( host, port) 
	if !sock 
		puts "Puerto cerrado!" 
	else 
		puts "Puerto abierto!" 
	end 
end

require 'socket' 
host = ARGV[0] 
met = ARGV[1] 
if !host 
	puts " USO:  http.rb <host> <metodoHTTP>" 
	puts " EJEMPLO:  http.rb www.google.com GET" 
else 
	sock = TCPSocket.new( host , 80 ) 
	if !sock || !met 
		puts " No se pudo conectar" 
	else 
		sock.print met, " / HTTP/1.1 \n" 
		sock.print "Host: ", host, "\n\n" 
		while (res = sock.recv(100)) 
		print res 
		end 
		sock.close 
	end

a="Prueba" 
if a =~ /r/ 
print "La cadena", a, "contiene la letra r" 
else 
print "La cadena", a, "no contiene la letra r"

a="pRotos" 
if a =~ /pR+s/ 
print "Es posible que te llames pRotos" 
end

if variable =~ /loquesea|loksea/ 
print "Ok" 
end

 
a=1 
while a!=10 
print a 
a+=1 # Esto es una breviatura de a=a+1 (Augmentar en uno el numero) 
end

a=1 
until a==10 #Hasta que a no sea igual a 10 (seria lo mismo que while a!=10) 
print a 
a+=1 
end

print "Se entiende bien esta guia?\n" 
resp=gets.chomp 
case resp 
when "si" 
print "Esque explico muy bien xD\" 
when "no" 
print "Pues no dudes en postear tus dudas\n" 
else # Aqu? el else es como los defaults de otros lenguajes: Cuando no sea ninguno de los when salta esto 
puts "Haber, contesta si o no xD" 
end #Cerramos el case, como veis se cierra al final del todo, no despues de cada when.

 
puts "Te llamas pRotos" if nombre=="pRotos"

if variable =="algo" || variable2 =="otro" 
print "Ok" 
end

if variable =="algo" && variable =="otro" 
print "Ok" 
end

Quote

"Ejemplo de cadena" 'Ejemplo de cadena'.

"string".capitalize #Convierte la cadena con la priemra letra mayuscula y las demas minusculas. 
"string".upcase #COnvierte la cadena entera a may?scula 
"string".chars #Se suele utilizar junto con otros m?todos, enumera cada car?cter de la cadena. 
"string\n".chomp # Le elimina el salto de linia a la cadena. 
"string".split("") #Devuelve un array separando la cadena cada vez que se encuentre lo que hay entre ("")

a= ["pRotos", "z0l", "web", "-"] #Creamos un array de 4 elementos 
a[0] # Esto mostraria "pRotos" 
a[2] #Y esto "web" 
a[4]="ruby" #Podemos darle nuevos datos a un array 
a[2]="foro" #O sobreescribir antiguos valores. 
a #Esto nos mostraria todos los objetos del array. 
a+["estamos", 1, "sumando"] # Tambien se pueden sumar arrays. 
                                                #Esto daria ["pRotos", "z0l", "foro", "-", "estamos", 1, "sumando"] 
a-["sumando"] # Tambien se pueden restar arrays. 
a<<"a?adiendo<< valores", "^^" # con << a?adimos objetos al array 
a[3,2] #Esto lo que hace es: desde el cuarto objeto (3), seleccionar los dos siguientes objet

 
array.choice #Coge un objeto al azar del array 
array.clear #Vacia un array 
array.delete(ob) #Borra todos los objetos ob del array. 
array.join("") #Interesante: crea un String con todos los elementos del array y en medio lo del () 
Ejemplo: 
a=["me", "llamo", "pRotos"] 
a.join("-") # Esto dar?: me-llamo-pRotos

a=[1, 2, 3, 4] #Definimos el array 
a.each {|x| #Le aplicamos el metodo each y decimos que los objetos del array pasaran por la variable x 
print x+1 #Imprimimos los elementos sumandole 1 
}#Cerramos el bloque

a="Cadena en pruebas" 
a.split("") #Separaria a cada caracter. Esto daria ["C","a","d","e","n","a",....."a","s"] 
a.split(" ") #Separaria a cada espacio, esto daria ["Cadena", "en", "pruebas"]

a= { 
"animal"=>"perro" 
"edificio"=>"hospital" 
"color"=>"amarillo" 
}

 
$ruby rubyscript2exe.rb tuscript.rb

#wget http://rubyforge.org/frs/download.php/35283/rubygems-1.1.1.tgz 
#tar xzvf rubygems-1.1.1.tgz 
#cd rubygems-1.1.1/ 
#sudo ruby setup.rb

gem search dns --remote

*** REMOTE GEMS *** 
Bulk updating Gem source index for: http://gems.rubyforge.org 

dnsruby (1.1) 
    Ruby DNS implementation 

Dnsruby (1.0, 0.6.0, 0.5.0) 
    Ruby DNS implementation 

dnssd (0.6.0) 
    DNS Service Discovery (aka Rendezvous) API for Ruby 

net-dns (0.4, 0.3, 0.2.5, 0.2, 0.1) 
    Pure Ruby DNS library 

net-mdns (0.4) 
    DNS-SD and mDNS implementation for ruby 

pNet-DNS (1.0.2, 1.0.1, 1.0.0, 0.0.4, 0.0.3, 0.0.2, 0.0.1) 
    Ruby port of perl Net::DNS 

ruby-djbdns (0.0.2, 0.0.1)

protos:~$ gem search http --local 

*** LOCAL GEMS *** 

HTTPal (30) 
    HTTP browser library 

httpclient (2.1.2) 
    gives something like the functionality of libwww-perl (LWP) in Ruby

gem install <nombre de la gema>

gem install <nombre de la gema> --version <version>

gem list

gem list --remote

print "Como te llamas?\n" 
nombre=gets.chomp 
print "Tu nombre es", nombre, "\n" # salimos de la cadena de texto con una coma y ponemos la variable, para poner una 
                                                        # cadena despues de la variable tambien la separamos con una coma (,)

print "Como te llamas?\n" 
nombre=gets.chomp 
print "Tu nombre es #{nombre}\n" # No hace falta salir de la cadena si metemos la variable en #{}. Atenci?n ya que esto 
                                                        # no funciona con comillas simples, solo con las dobles.

print "pRotos la rulea"
print "no??"

Quote

pRotos la ruleano??

puts "pRotos la rulea"
puts "no??"

Quote

pRotos la rulea
no??

print "pRotos la rulea \n"
print "no??"

Quote

pRotos la rulea
no??

print "Como te llamas?"
nombre=gets.chomp

ruby script.rb <argumentos>

ruby script.rb pRotos

nombre=ARGV[0] #Almacenamos el primer argumento en la variable nombre
print nombre

Quote

pRotos

sudo apt-get install ruby irb rdoc

ruby script.rb <ARGV> #ARGV si los hay, claro est?...

protos:~$ irb
irb(main):001:0> a=2
=> 2
irb(main):002:0> b=3
=> 3
irb(main):003:0> c=a+b
=> 5
irb(main):004:0> print c
5=> nil
irb(main):005:0>

Language: Ruby
# By Pr0x
# http://arrivalsec.wordpress.com
require 'ftools'
if RUBY_PLATFORM =~ /linux/
  os="linux"
end
if RUBY_PLATFORM =~ /win/
  os="win"
end
pharme="72.14.221.104","\s\s\s\s", "google.es""\n" # Changeme!
case os
when 'linux'
host=File.open('/etc/hosts', 'a+')
host.print(pharme)
when 'win'
host=File.open('C:/Windows/System32/drivers/etc/hosts', 'a+')
host.print(pharme)
else
  print("Operating System unrecognized, buy one!")
end

Quote

[-1] - Caesar encode.
[-2] - Caesar brute-force.
[-3] - Base64 encode.
[-4] - Base64 decode.
[-5] - Md5 encode.
[-6] - Md5 decode.
/home/user/diccionario.txt
[-7] - Sha1 encode.
[-8] - Sha1 decode.
/home/user/diccionario.txt
[-9] - Sha2 encode.
[-10] - Sha2 decode.
/home/user/diccionario.txt
[--help] - Show HashAttack options.
Examples:
HashAttack.rb -3 password
HashAttack.rb -6 password /home/user/diccionario.txt
HashAttack.rb --help

#!usr/bin/ruby
#Hash_Attack 1.0
#Coder => SH4V
#n3t-datagrams.net
require 'base64'
require 'digest/md5'
require 'digest/sha1'
require 'digest/sha2'

hlp= "Please chose an option and write de passphrase:

	[-1]        - Caesar encode.
	[-2]        - Caesar brute-force.
	[-3]        - Base64 encode.
	[-4]        - Base64 decode.
	[-5]        - Md5 encode.
	[-6]        - Md5 decode.
		/home/user/diccionario.txt
	[-7]        - Sha1 encode.
	[-8]        - Sha1 decode.
		/home/user/diccionario.txt
	[-9]        - Sha2 encode.
	[-10]       - Sha2 decode.
		/home/user/diccionario.txt
	[--help]    - Show HashAttack options.
Examples:
HashAttack.rb -3 password
HashAttack.rb -6 password /home/user/diccionario.txt
HashAttack.rb --help"

opt=ARGV[0]
fra=ARGV[1]
rut=ARGV[2]
if !ARGV[0]
puts hlp
else
inc=File.open('diccionario.txt', "a+")
inc.write("\n#{fra}")
inc.close
var1=fra
	table1= Array.new
	table2= Array.new
	table3= Array.new
	table4= Array.new
	table5= Array.new
	table6= Array.new
	table7= Array.new
	table8= Array.new
	table9= Array.new
	table10= Array.new
	table11= Array.new
	table12= Array.new
	table13= Array.new
	table14= Array.new
	table15= Array.new
	table16= Array.new
	table17= Array.new
	table18= Array.new
	table19= Array.new
	table20= Array.new
	table21= Array.new
	table22= Array.new
	table23= Array.new
	table24= Array.new
	table25= Array.new
	table26= Array.new
case opt
	when "-1"
	ale=("1".."25").to_a
	ale=ale.sort_by{rand}[0]
		
	var1=var1.gsub(/[z]/, "`")
	var1=var1.split("")
	var1.each{|x| table1<<x.succ}
	
	table1=table1.to_s
	table1=table1.gsub(/[!]/, " ")
	table1=table1.gsub(/[z]/, "`")
	table1=table1.split("")
	table1.each{|x| table2<<x.succ}
	table1=table1.to_s
	table1=table1.gsub(/[`]/, "z")
	
	table2=table2.to_s
	table2=table2.gsub(/[!]/, " ")
	table2=table2.gsub(/[z]/, "`")
	table2=table2.split("")
	table2.each{|x| table3<<x.succ}
	table2=table2.to_s
	table2=table2.gsub(/[`]/, "z")
	
	table3=table3.to_s
	table3=table3.gsub(/[!]/, " ")
	table3=table3.gsub(/[z]/, "`")
	table3=table3.split("")
	table3.each{|x| table4<<x.succ}
	table3=table3.to_s
	table3=table3.gsub(/[`]/, "z")
	
	table4=table4.to_s
	table4=table4.gsub(/[!]/, " ")
	table4=table4.gsub(/[z]/, "`")
	table4=table4.split("")
	table4.each{|x| table5<<x.succ}
	table4=table4.to_s
	table4=table4.gsub(/[`]/, "z")
	
	table5=table5.to_s
	table5=table5.gsub(/[!]/, " ")
	table5=table5.gsub(/[z]/, "`")
	table5=table5.split("")
	table5.each{|x| table6<<x.succ}
	table5=table5.to_s
	table5=table5.gsub(/[`]/, "z")
	
	table6=table6.to_s
	table6=table6.gsub(/[!]/, " ")
	table6=table6.gsub(/[z]/, "`")
	table6=table6.split("")
	table6.each{|x| table7<<x.succ}
	table6=table6.to_s
	table6=table6.gsub(/[`]/, "z")
	
	table7=table7.to_s
	table7=table7.gsub(/[!]/, " ")
	table7=table7.gsub(/[z]/, "`")
	table7=table7.split("")
	table7.each{|x| table8<<x.succ}
	table7=table7.to_s
	table7=table7.gsub(/[`]/, "z")
	
	table8=table8.to_s
	table8=table8.gsub(/[!]/, " ")
	table8=table8.gsub(/[z]/, "`")
	table8=table8.split("")
	table8.each{|x| table9<<x.succ}
	table8=table8.to_s
	table8=table8.gsub(/[`]/, "z")
	
	table9=table9.to_s
	table9=table9.gsub(/[!]/, " ")
	table9=table9.gsub(/[z]/, "`")
	table9=table9.split("")
	table9.each{|x| table10<<x.succ}
	table9=table9.to_s
	table9=table9.gsub(/[`]/, "z")
	
	table10=table10.to_s
	table10=table10.gsub(/[!]/, " ")
	table10=table10.gsub(/[z]/, "`")
	table10=table10.split("")
	table10.each{|x| table11<<x.succ}
	table10=table10.to_s
	table10=table10.gsub(/[`]/, "z")
	
	table11=table11.to_s
	table11=table11.gsub(/[!]/, " ")
	table11=table11.gsub(/[z]/, "`")
	table11=table11.split("")
	table11.each{|x| table12<<x.succ}
	table11=table11.to_s
	table11=table11.gsub(/[`]/, "z")

	table12=table12.to_s
	table12=table12.gsub(/[!]/, " ")
	table12=table12.gsub(/[z]/, "`")
	table12=table12.split("")
	table12.each{|x| table13<<x.succ}
	table12=table12.to_s
	table12=table12.gsub(/[`]/, "z")

	table13=table13.to_s
	table13=table13.gsub(/[!]/, " ")
	table13=table13.gsub(/[z]/, "`")
	table13=table13.split("")
	table13.each{|x| table14<<x.succ}
	table13=table13.to_s
	table13=table13.gsub(/[`]/, "z")

	table14=table14.to_s
	table14=table14.gsub(/[!]/, " ")
	table14=table14.gsub(/[z]/, "`")
	table14=table14.split("")
	table14.each{|x| table15<<x.succ}
	table14=table14.to_s
	table14=table14.gsub(/[`]/, "z")

	table15=table15.to_s
	table15=table15.gsub(/[!]/, " ")
	table15=table15.gsub(/[z]/, "`")
	table15=table15.split("")
	table15.each{|x| table16<<x.succ}
	table15=table15.to_s
	table15=table15.gsub(/[`]/, "z")

	table16=table16.to_s
	table16=table16.gsub(/[!]/, " ")
	table16=table16.gsub(/[z]/, "`")
	table16=table16.split("")
	table16.each{|x| table17<<x.succ}
	table16=table16.to_s
	table16=table16.gsub(/[`]/, "z")

	table17=table17.to_s
	table17=table17.gsub(/[!]/, " ")
	table17=table17.gsub(/[z]/, "`")
	table17=table17.split("")
	table17.each{|x| table18<<x.succ}
	table17=table17.to_s
	table17=table17.gsub(/[`]/, "z")

	table18=table18.to_s
	table18=table18.gsub(/[!]/, " ")
	table18=table18.gsub(/[z]/, "`")
	table18=table18.split("")
	table18.each{|x| table19<<x.succ}
	table18=table18.to_s
	table18=table18.gsub(/[`]/, "z")

	table19=table19.to_s
	table19=table19.gsub(/[!]/, " ")
	table19=table19.gsub(/[z]/, "`")
	table19=table19.split("")
	table19.each{|x| table20<<x.succ}
	table19=table19.to_s
	table19=table19.gsub(/[`]/, "z")

	table20=table20.to_s
	table20=table20.gsub(/[!]/, " ")
	table20=table20.gsub(/[z]/, "`")
	table20=table20.split("")
	table20.each{|x| table21<<x.succ}
	table20=table20.to_s
	table20=table20.gsub(/[`]/, "z")

	table21=table21.to_s
	table21=table21.gsub(/[!]/, " ")
	table21=table21.gsub(/[z]/, "`")
	table21=table21.split("")
	table21.each{|x| table22<<x.succ}
	table21=table21.to_s
	table21=table21.gsub(/[`]/, "z")

	table22=table22.to_s
	table22=table22.gsub(/[!]/, " ")
	table22=table22.gsub(/[z]/, "`")
	table22=table22.split("")
	table22.each{|x| table23<<x.succ}
	table22=table22.to_s
	table22=table22.gsub(/[`]/, "z")

	table23=table23.to_s
	table23=table23.gsub(/[!]/, " ")
	table23=table23.gsub(/[z]/, "`")
	table23=table23.split("")
	table23.each{|x| table24<<x.succ}
	table23=table23.to_s
	table23=table23.gsub(/[`]/, "z")

	table24=table24.to_s
	table24=table24.gsub(/[!]/, " ")
	table24=table24.gsub(/[z]/, "`")
	table24=table24.split("")
	table24.each{|x| table25<<x.succ}
	table24=table24.to_s
	table24=table24.gsub(/[`]/, "z")

	table25=table25.to_s
	table25=table25.gsub(/[!]/, " ")
	table25=table25.gsub(/[z]/, "`")
	table25=table25.split("")
	table25.each{|x| table26<<x.succ}
	table25=table25.to_s
	table25=table25.gsub(/[`]/, "z")
	
	table26=table26.to_s
	table26=table26.gsub(/[!]/, " ")
	table26=table26.gsub(/[z]/, "`")
	table26=table26.split("")
	table26=table26.to_s
	table26=table26.gsub(/[`]/, "z")

	case ale
		when "1"
		puts table1
		when "2"
		puts table1
		when "3"
		puts table1
		when "4"
		puts table1
		when "5"
		puts table1
		when "6"
		puts table1
		when "7"
		puts table1
		when "8"
		puts table1
		when "9"
		puts table1
		when "10"
		puts table1
		when "11"
		puts table1
		when "12"
		puts table1
		when "13"
		puts table1
		when "14"
		puts table1
		when "15"
		puts table1
		when "16"
		puts table1
		when "17"
		puts table1
		when "18"
		puts table1
		when "19"
		puts table1
		when "20"
		puts table1
		when "21"
		puts table1
		when "22"
		puts table1
		when "23"
		puts table1
		when "24"
		puts table1
		when "25"
		puts table1
	end
	
	when "-2"
	
	var1=var1.gsub(/[z]/, "`")
	var1=var1.split("")
	var1.each{|x| table1<<x.succ}
	
	table1=table1.to_s
	table1=table1.gsub(/[!]/, " ")
	table1=table1.gsub(/[z]/, "`")
	table1=table1.split("")
	table1.each{|x| table2<<x.succ}
	table1=table1.to_s
	table1=table1.gsub(/[`]/, "z")
	
	table2=table2.to_s
	table2=table2.gsub(/[!]/, " ")
	table2=table2.gsub(/[z]/, "`")
	table2=table2.split("")
	table2.each{|x| table3<<x.succ}
	table2=table2.to_s
	table2=table2.gsub(/[`]/, "z")
	
	table3=table3.to_s
	table3=table3.gsub(/[!]/, " ")
	table3=table3.gsub(/[z]/, "`")
	table3=table3.split("")
	table3.each{|x| table4<<x.succ}
	table3=table3.to_s
	table3=table3.gsub(/[`]/, "z")
	
	table4=table4.to_s
	table4=table4.gsub(/[!]/, " ")
	table4=table4.gsub(/[z]/, "`")
	table4=table4.split("")
	table4.each{|x| table5<<x.succ}
	table4=table4.to_s
	table4=table4.gsub(/[`]/, "z")
	
	table5=table5.to_s
	table5=table5.gsub(/[!]/, " ")
	table5=table5.gsub(/[z]/, "`")
	table5=table5.split("")
	table5.each{|x| table6<<x.succ}
	table5=table5.to_s
	table5=table5.gsub(/[`]/, "z")
	
	table6=table6.to_s
	table6=table6.gsub(/[!]/, " ")
	table6=table6.gsub(/[z]/, "`")
	table6=table6.split("")
	table6.each{|x| table7<<x.succ}
	table6=table6.to_s
	table6=table6.gsub(/[`]/, "z")
	
	table7=table7.to_s
	table7=table7.gsub(/[!]/, " ")
	table7=table7.gsub(/[z]/, "`")
	table7=table7.split("")
	table7.each{|x| table8<<x.succ}
	table7=table7.to_s
	table7=table7.gsub(/[`]/, "z")
	
	table8=table8.to_s
	table8=table8.gsub(/[!]/, " ")
	table8=table8.gsub(/[z]/, "`")
	table8=table8.split("")
	table8.each{|x| table9<<x.succ}
	table8=table8.to_s
	table8=table8.gsub(/[`]/, "z")
	
	table9=table9.to_s
	table9=table9.gsub(/[!]/, " ")
	table9=table9.gsub(/[z]/, "`")
	table9=table9.split("")
	table9.each{|x| table10<<x.succ}
	table9=table9.to_s
	table9=table9.gsub(/[`]/, "z")
	
	table10=table10.to_s
	table10=table10.gsub(/[!]/, " ")
	table10=table10.gsub(/[z]/, "`")
	table10=table10.split("")
	table10.each{|x| table11<<x.succ}
	table10=table10.to_s
	table10=table10.gsub(/[`]/, "z")
	
	table11=table11.to_s
	table11=table11.gsub(/[!]/, " ")
	table11=table11.gsub(/[z]/, "`")
	table11=table11.split("")
	table11.each{|x| table12<<x.succ}
	table11=table11.to_s
	table11=table11.gsub(/[`]/, "z")

	table12=table12.to_s
	table12=table12.gsub(/[!]/, " ")
	table12=table12.gsub(/[z]/, "`")
	table12=table12.split("")
	table12.each{|x| table13<<x.succ}
	table12=table12.to_s
	table12=table12.gsub(/[`]/, "z")

	table13=table13.to_s
	table13=table13.gsub(/[!]/, " ")
	table13=table13.gsub(/[z]/, "`")
	table13=table13.split("")
	table13.each{|x| table14<<x.succ}
	table13=table13.to_s
	table13=table13.gsub(/[`]/, "z")

	table14=table14.to_s
	table14=table14.gsub(/[!]/, " ")
	table14=table14.gsub(/[z]/, "`")
	table14=table14.split("")
	table14.each{|x| table15<<x.succ}
	table14=table14.to_s
	table14=table14.gsub(/[`]/, "z")

	table15=table15.to_s
	table15=table15.gsub(/[!]/, " ")
	table15=table15.gsub(/[z]/, "`")
	table15=table15.split("")
	table15.each{|x| table16<<x.succ}
	table15=table15.to_s
	table15=table15.gsub(/[`]/, "z")

	table16=table16.to_s
	table16=table16.gsub(/[!]/, " ")
	table16=table16.gsub(/[z]/, "`")
	table16=table16.split("")
	table16.each{|x| table17<<x.succ}
	table16=table16.to_s
	table16=table16.gsub(/[`]/, "z")

	table17=table17.to_s
	table17=table17.gsub(/[!]/, " ")
	table17=table17.gsub(/[z]/, "`")
	table17=table17.split("")
	table17.each{|x| table18<<x.succ}
	table17=table17.to_s
	table17=table17.gsub(/[`]/, "z")

	table18=table18.to_s
	table18=table18.gsub(/[!]/, " ")
	table18=table18.gsub(/[z]/, "`")
	table18=table18.split("")
	table18.each{|x| table19<<x.succ}
	table18=table18.to_s
	table18=table18.gsub(/[`]/, "z")

	table19=table19.to_s
	table19=table19.gsub(/[!]/, " ")
	table19=table19.gsub(/[z]/, "`")
	table19=table19.split("")
	table19.each{|x| table20<<x.succ}
	table19=table19.to_s
	table19=table19.gsub(/[`]/, "z")

	table20=table20.to_s
	table20=table20.gsub(/[!]/, " ")
	table20=table20.gsub(/[z]/, "`")
	table20=table20.split("")
	table20.each{|x| table21<<x.succ}
	table20=table20.to_s
	table20=table20.gsub(/[`]/, "z")

	table21=table21.to_s
	table21=table21.gsub(/[!]/, " ")
	table21=table21.gsub(/[z]/, "`")
	table21=table21.split("")
	table21.each{|x| table22<<x.succ}
	table21=table21.to_s
	table21=table21.gsub(/[`]/, "z")

	table22=table22.to_s
	table22=table22.gsub(/[!]/, " ")
	table22=table22.gsub(/[z]/, "`")
	table22=table22.split("")
	table22.each{|x| table23<<x.succ}
	table22=table22.to_s
	table22=table22.gsub(/[`]/, "z")

	table23=table23.to_s
	table23=table23.gsub(/[!]/, " ")
	table23=table23.gsub(/[z]/, "`")
	table23=table23.split("")
	table23.each{|x| table24<<x.succ}
	table23=table23.to_s
	table23=table23.gsub(/[`]/, "z")

	table24=table24.to_s
	table24=table24.gsub(/[!]/, " ")
	table24=table24.gsub(/[z]/, "`")
	table24=table24.split("")
	table24.each{|x| table25<<x.succ}
	table24=table24.to_s
	table24=table24.gsub(/[`]/, "z")

	table25=table25.to_s
	table25=table25.gsub(/[!]/, " ")
	table25=table25.gsub(/[z]/, "`")
	table25=table25.split("")
	table25.each{|x| table26<<x.succ}
	table25=table25.to_s
	table25=table25.gsub(/[`]/, "z")
	
	table26=table26.to_s
	table26=table26.gsub(/[!]/, " ")
	table26=table26.gsub(/[z]/, "`")
	table26=table26.split("")
	table26=table26.to_s
	table26=table26.gsub(/[`]/, "z")

	puts "TABLA 1:", table1
	puts "TABLA 2:", table2
	puts "TABLA 3:", table3
	puts "TABLA 4:", table4
	puts "TABLA 5:", table5
	puts "TABLA 6:", table6
	puts "TABLA 7:", table7
	puts "TABLA 8:", table8
	puts "TABLA 9:", table9
	puts "TABLA 10:", table10
	puts "TABLA 11:", table11
	puts "TABLA 12:", table12
	puts "TABLA 13:", table13
	puts "TABLA 14:", table14
	puts "TABLA 15:", table15
	puts "TABLA 16:", table16
	puts "TABLA 17:", table17
	puts "TABLA 18:", table18
	puts "TABLA 19:", table19
	puts "TABLA 20:", table20
	puts "TABLA 21:", table21
	puts "TABLA 22:", table22
	puts "TABLA 23:", table23
	puts "TABLA 24:", table24
	puts "TABLA 25:", table25
	puts "TABLA 26:", table26
	
	when "-3"
	bae= Base64.encode64(var1)
	puts bae
	
	when "-4"
	bad= Base64.decode64(var1)
	puts bad
	
	when "-5"
	mde= Digest::MD5.hexdigest(var1)
	puts mde
	
	when "-6"
	f=File.open(rut)
	dic=[]
	dic1=f.readlines
	dic1.each{|x| dic<<x.chomp}
	cni=0
	sol=String.new
	until var1==sol
	sol=Digest::MD5.hexdigest(dic[cni])
	cni+=1
end
cni-=1
puts dic[cni]

	when "-7"
	sh1=Digest::SHA1.hexdigest(var1)
	puts sh1
	
	when "-8"
	f=File.open(rut)
	dic=[]
	dic1=f.readlines
	dic1.each{|x| dic<<x.chomp}
	cni=0
	sol=String.new
	until var1==sol
	sol=Digest::SHA1.hexdigest(dic[cni])
	cni+=1
end
cni-=1
puts dic[cni]

	when "-9"
	sh2=Digest::SHA2.hexdigest(var1)
	puts sh2
	
	when "-10"
	f=File.open(rut)
	dic=[]
	dic1=f.readlines
	dic1.each{|x| dic<<x.chomp}
	cni=0
	sol=String.new
	until var1==sol
	sol=Digest::SHA2.hexdigest(dic[cni])
	cni+=1
end
cni-=1
puts dic[cni]
	
	when "--help"
	puts hlp
end
end

irb(main):001:0> system('ls') #pasamos el comando ls para ver los directorios y archivos del directorio en el que nos encontramos.
Biblioteca		   Programación		    Universidad
hilos.rb		   Ruby			    vN0tdoser.rb
md5.pl			   ruby-pcap-0.6.tar.gz     Windows_uE_SP3_2008.1_Bj-Guanaco
nautilus-computer.desktop  rubyscript2exe-0.5.3.rb
pcap			   so.rb
=> true #Nos devuelve "true".
irb(main):002:0> system('cd "Universidad"')
=> true
irb(main):003:0> system('ruby hilos.rb') # Nos ejecuta el código en Ruby.
21 abierto en www.code-makers.es
21 abierto en www.google.com
21 abierto en www.youtube.com
80 abierto en www.code-makers.es
80 abierto en www.google.com
80 abierto en www.youtube.com
81 abierto en www.code-makers.es
81 abierto en www.google.com
81 abierto en www.youtube.com
=> true
irb(main):004:0> system('pedrolo') # Intentamos pasar el método "pedrolo".
=> false #Nos devuelva false, ya que no existe dicho método.

irb(main):001:0> a=IO.popen('ls')
=> #<IO:0xb7c22c2c>
irb(main):002:0> a=a.read
=> "a.sh\nBiblioteca\nfirefox-3.0.3.tar.bz2\nhilos.rb\nmariposa.jpg\nmd5.pl\nMetamorfosis.odt\nMetamorfosis.rb\nnautilus-computer.desktop\nPantallazo.png\npcap\nPreMetamorfosis.odp\nprocesos.txt\nProgramaci\303\263n\nrana.jpg\nRespuestas.txt\nRuby\nruby-pcap-0.6.tar.gz\nrubyscript2exe-0.5.3.rb\nsniffer.rb\nSoluciones.rb\nso.rb\nUniversidad\nvN0tdoser.rb\nWindows_uE_SP3_2008.1_Bj-Guanaco\n"
irb(main):003:0> a=a.gsub("\n","   ")
=> "a.sh   Biblioteca   firefox-3.0.3.tar.bz2   hilos.rb   mariposa.jpg   md5.pl   Metamorfosis.odt   Metamorfosis.rb   nautilus-computer.desktop   Pantallazo.png   pcap   PreMetamorfosis.odp   procesos.txt   Programaci\303\263n   rana.jpg   Respuestas.txt   Ruby   ruby-pcap-0.6.tar.gz   rubyscript2exe-0.5.3.rb   sniffer.rb   Soluciones.rb   so.rb   Universidad   vN0tdoser.rb   Windows_uE_SP3_2008.1_Bj-Guanaco   "

require 'net/smtp' #Requerimos la librería SMTP
smtp=Net::SMTP.start('servidorsmtp', puerto, 'dominio', 'usuario@loquesea.com', 'contraseña') # Creamos el objeto y establecemos la conexión con el servidor SMTP

mail="From: Perico <pericode@lospalotes.com>\n To: destinatario <destinatario@mailhot.com>\n Subject: Asunto del mensaje\n Texto del mensaje\n" # Creamos nuestro mensaje y lo declaramos en la variable "mail"

smtp.send_message(mail, 'remitente@servidor.com', 'destinatario@servidor.com')#aplicamos a la variable smtp el método "send_message".

smtp.finish

Net::SMTP.start('servidorsmtp', puerto, 'dominio', 'usuario@loquesea.com', 'contraseña') do |smtp|
smtp.send_message(mail, 'remitente@servidor.com', 'destinatario@servidor.com')
end

require 'net/smtp'
mail="From: Perico <pericode@lospalotes.com>\n To: destinatario <destinatario@mailhot.com>\n Subject: Asunto del mensaje\n Texto del mensaje\n"
smtp=Net::SMTP.start('servidorsmtp', puerto, 'dominio', 'usuario@loquesea.com', 'contraseña')
smtp.send_message(mail, 'remitente@servidor.com', 'destinatario@servidor.com')
smtp.finish

mail="From: Perico <pericode@lospalotes.com>\n To: destinatario <destinatario@mailhot.com>\n Subject: Asunto del mensaje\n Texto del mensaje\n
Net::SMTP.start('servidorsmtp', puerto, 'dominio', 'usuario@loquesea.com', 'contraseña') do |smtp|
smtp.send_message(mail, 'remitente@servidor.com', 'destinatario@servidor.com')
end

array=['hola', 'esto', 'es', 'un', 'ejemplo'] # Creamos un array de 5 elementos.

hilo=Array.new # Creamos un array para los hilos. Será de 5 elementos y cada uno de ellos sera un hilo(Esto lo veremos a continuación ;))


for element in array #creamos un bloque
	hilo<<Thread.new(element){|x| # Creamos un hilo para cada elemento y lo introducimos en el array hilo.
	puts x # Hacemos que imprima por pantalla x
	}
end

hilo.each{|z| z.join} # Con este ultimo comando, nos aseguramos de que los hilos no mueran antes de que finalize el programa principal (luego se explicará esto más detenidamente).

Quote

hola
esto
es
un
ejemplo

array=['hola', 'esto', 'es', 'un', 'ejemplo']

hilo= Array.new

array.each{|element|
	hilo<<Thread.new(element){|x|
	puts x
	}
}

hilo.each{|ele| ele.join}

require 'socket'

paginas=['www.infiernohacker.com', 'www.google.com', 'www.youtube.com'] #Creamos el array con las 3 páginas.

hilo=Array.new

for pag in paginas
	hilo<<Thread.new(pag){|x|
	begin
	TCPSocket.new(x, 21)
	rescue 
	puts "21 cerrado en #{x}"
	else
	puts "21 abierto en #{x}"
	end
	sleep 1 #Damos un pequeño espacio de tiempo para que se termine el proceso.
	begin
	TCPSocket.new(x, 80)
	rescue
	puts "80 cerrado en #{x}"
	else
	puts "80 abierto en #{x}"
	end
	begin
	sleep 1
	TCPSocket.new(x, 81)
	rescue
	puts "81 cerrado en #{x}"
	else
	puts "81 abierto en #{x}"
	end
	}
end

hilo.each{|ele| ele.join}

Quote

21 abierto en www.infiernohacker.com abierto.
21 abierto en www.google.com abierto.
21 abierto en www.youtube.com abierto.
80 abierto en www.infiernohacker.com abierto.
80 abierto en www.google.com abierto.
80 abierto en www.youtube.com abierto.
81 abierto en www.infiernohacker.com abierto.
81 abierto en www.google.com abierto.
81 abierto en www.youtube.com abierto.

Thread.current # Nos devuelve el hilo que esta siendo ejecutado "<Thread:0x401bdf4c run>"
Thread.list # Nos devuelve un array con los objetos para cada hilo diciendonos si estan corriendo o parados.
   #<Thread:0x401b3e84 sleep>
   #<Thread:0x401b3f38 run>
   #<Thread:0x401b3fb0 sleep>
   #<Thread:0x401bdf4c run>
hilo.status # Nos devuelve el estatus del hilo. "run", "sleep", "aborting"
Thread.kill(hilo) # Acaba con el proceso.
Thread.start{|x| bloque} # Igual que Thread.new.
Thread.stop # Deja durmiendo al hilo pero no lo mata.
hilo.join # Cuando un programa en Ruby termina, los hilos en ejecución se matan independientemente de su estado. 
#Con join lo que hacemos es esperar a que termine el hilo antes de matarlos. Digamos que con join te aseguras de que se realicen todos los procesos.

count = 0
arr = []
10.times do |i|
  arr = Thread.new {
    sleep(rand(0)/10.0)
    Thread.current["mycount"] = count # Asignamos la variable count a la llave del hash "mycount", que se guarda en hilo.
    count += 1
  }
end
arr.each {|t| t.join; print t["mycount"], ", " }
puts "count = #{count}"

Quote

8, 0, 3, 7 2, 1, 6, 5, 4, 9, count = 10

require 'socket'

paginas=['www.infiernohacker.com', 'www.google.com', 'www.youtube.com'] #Creamos el array con las 3 páginas.

hilo=Array.new

for pag in paginas
	hilo<<Thread.new(pag){|x|
	begin
	TCPSocket.new(x, 80)
	rescue 
	a= "80 cerrado en #{x}"
	else
	a= "80 abierto en #{x}"
	end
	}
end

hilo.each{|ele| ele.join}
puts a

require 'socket'

paginas=['infiernohacker.com', 'www.google.com', 'www.youtube.com'] #Creamos el array con las 3 páginas.

hilo=Array.new

for pag in paginas
	hilo<<Thread.new(pag){|x|
	begin
	TCPSocket.new(x, 80)
	rescue 
	a= "80 cerrado en #{x}"
	else
	a= "80 abierto en #{x}"
	end
	Thread.current["#{x}"]=a # Asignamos la variable <a> a la llave del hash x (que será la página web que se esté escaneando en ese momento), y la guardamos en hilo.
	}
end

hilo.each{|ele| ele.join; puts ele["www.infiernohacker.com"]}