@You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login  no te compliques la existencia y hazme caso échale una ojeada a esto  You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login
es portable y lo puedes ejecutar en donde quieras y como quieras, ¡eso sí! teniendo en cuenta el SO.

You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login
Las plantillas de las que hablas seguramente sean en HTML, es muy habitual encontrar páginas donde recopilan plantillas para editar con Dreamweaver.

Saludos

Hola hermano Stiuvert creo que las plantillas de las que habla son estas You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login que fueron posteadas por un compañero de aquí del Foro.
Con pinegrow se pueden modificar perfectamente saludos

Creo que lo que necesitas es pinegrow, pero es una jodienda si no sabes trabajar con CSS. Con pinegrow podrás modificar a toque de click los contenidos de casi cualquier Web page, dispone de una opción para colocar la url de la web, la clona la almacena en tu disco y a partir de aquí puedes trabajarla modificando los Css, el source ,en fin todo por todo.
Aquí te pongo uno de los diversos videos sobre pinegrow

Excelente aporte @You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login...!!

Es un gran trabajo Devilboy descargué hace tiempo una versión anterior y me quedé maravillado  me encanta la ingenuidad del Startup, me refiero el archivo que se crea en la carpeta inicio linkeando hacia el server, me quedé prendado, desconocía esa forma de hacerlo.
Por cierto.- Aprovecho para preguntarte ya que sólo lo probé con un framework 4  y en un windows 7,¿Qué frameworks son necesarios para que se ejecute el server y con qué SO's es operativo el server? gracias por tu tiempo.
Saludos compañeros.

Son pocos datos los que aportas y reciéntemente hemos estado dando soporte Stiuvert y yo a otro usuario con SO windows, pero básicamente todo es lo mismo.
Todo se conecta desde una ip:puerto a otra ip:puerto las causas de que no conecte son dignas de estudiar ¿Cómo?  utilizando herramientas que todo SO lleva ,como la consolas||terminales  se pueden visualizar programas y puertos LISTEN,TIME WAIT STABLISHED.
En linux como root netstat -antp te listará ips puertos y programas||servicios corriendo
En Windows como administrador netstat -ano iden de lo mismo.
Una vez tengas claro que en una máquina tiene salida por un puerto en concreto y que apunta a donde tiene que apuntar y que en la máquina que espera la conexión tienes esperando la conexión en el puerto adecuado.
Los siquientes pasos siempre son los mismos:Firewalls del SO o del Antivirus.
@Saludos

Bueno yo doy mi opinión y es que un post tan bonito y está destrozado por el color del  You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login me han pelado las pupilas intentando de leerlo por lo demás muy interesante.
Cabe decir que el color que utilizas me encanta pero me es muy difícil la lectura e intentar distinguir el fondo gris-negro con dicho color.
@Saludos y espero no te lo tomes a mal.

Excelente...! gran trabajo  y bonita gui me encantan  los entornos oscuros

Puedes hace pruebas a nivel LAN  ten el builder de Spynet por ejemplo en tu pc de sobremesa y ejecuta en el Laptop el server, para las configuraciones del Spynet coloca la ip local de pc sobremesa   por ejemplo si la ip del pc sobremesa es la 192.168.0.110 crea un server con esa ip

Nota: con esa configuración sería solo para probarlo entre ordenadores conectados a la misma Red >>Por eso le puese LAN(Local Área Network) estimado Stiuvert.

Cuando ejecutes en el Laptop mira por consola netstat -ano y debe apuntar sí o sí a la ip del sobremesa

En el pc sobremesa comprueba con netstat -ano que está a la escucha.

Para las dll que te faltan bindealas con el server del Spynet porque es muy cantoso cuando lo ejecutas las alertas que aparecen en pantalla sobre estas dll

PD: Qué pretendo en este último post, pues pretendo que descartes el uso de no-ip a priori para ejecutar y probar en distintas máquinas de tu misma Red LAN y definitivamente encuentres en dónde se ubica el problema.

Hola Libercode si estabas buscando un sitio donde aprender,compartir y ser parte de una gran familia lo has encontrado

Bienvenido a la familia You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login

Quizás lo que te puse en los post de arriba es el problema, vamos a hacer una cosa y así descartamos:

Cuando crees el server como te ha dicho Stiuvert  lo ejecutas como siempre, abres una consola y tipeas netstat -ano, si en el retorno de la consola ves una conexión TCP apuntando a tu ip pública o en su caso ves tu no-ip  entonces llevo razón en que de tu no-ip a ti mismo no puedes conectarte.

Para comprobar que tienes bien configurado la no-ip también desde consola haciendo un ping a tu no-ip te devolverá la ip pública y sabrás que la no-ip está haciendo su trabajo correctamente.

Con estas dos pruebas quedará zanjado el tema, sólo te quedaŕá una más que será la definitiva ir a algún compañero en otra red y que te deje hacer las pruebas(Se lo mandas por correo en un rar con password y le dices que lo ejecute en su pc) una vez lo ejecute deberá conectar él hacia tí.

Que tal broooo...!!! me encanta todo el esfuerzo que pones en You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login nos mantienes informados con variopintas noticias. Simplemente me encanta todo lo que haces, todo lo que aportas, tu esfuerzo y perseverancia dicen mucho de tu personalidad.

Después de la breve introdución sólo quiero comentar que es pintoresca la vida y lo digo porque una sociedad como es la Japonesa la cual es muy protectora con el medioambiente ,la contaminación y en el tema de salvaguardar especies animales como  el caso expuesto  son reacios.

La cuestión es:¿Qué ocurrirá cuando exterminemos todo lo que nos rodea? ¿Está la especie humana condenada a su desaparición? por no saber administrar!!proteger los recursos de la naturaleza.

Esperemos que la acción de Anonymous genere un punto de reflexión,aunque no lo creo porque es una sociedad cuyas costumbres están bindeadas al mar.

Saludos amigo mío.

Lo que te ha dicho Alanprogrammer es que le des a tu script permisos root así no necesitarás dentro del código dar ningún permiso.
Sitúate por terminal en la carpeta donde tengas es script en python y dale todos los permisos como root : chmod +x 'nombrearchivo.py' con esto debe funcionar tu script sin  problemas.

Qué buen tutorial hacía años que no veía algo así...! enhorabuena..!!

Dos imágenes que vienen de perlas a este post y que muestran la triste realidad, aunque un AV ayuda el 100% lamentablemente no garantiza la protección.

No me hagáis caso porque hace bastante tiempo que no toco el remoting pero creo que no os podéis autoinfectar utilizando vuestra no-ip.
En los últimos momentos en los que practiqué con los Rats comprobé que a través de este servicio(no-ip) no recibía conexión, los medios que utilizaba para ver las conexiones eran a través de consola de windows tipeando netstat -ano o utilizando netsagent, para la desinfección utilizaba process explorer.

Resumiendo: creo que de tu noip a tí mismo no funciona

Jajajaja pues me gusta el marketing que estás haciendo amigo graphixx sin lugar a dudas tiene las 4P:

Las cuatro pe en marketing son:
Price
Place
Product
Promotion

Muy buena Rollth .!!! se podría ejecutar un dir C:\"nombre_archivo" /s y capturar el InputStream y mostrarlo en un Jlabel o un Jtext,esto lo que haría sería buscar el archivo en todo el disco C, aunque como tú bien dices la respuesta podría demorar.

Gracias amigo mío..!!!

Hola compadre @You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login te debía una por el aportazo de los SO de windows y te devuelvo el favor:
Aquí comparto dos generadores  de diccionarios con patrones son dos script un en .sh y otro en perl

You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login

Estos generadores los tenía en el baúl de los recuerdos el exe no lo he llegado a utilizar  este es el reporte de virustotal.

CitarYou are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login

Estos son los códigos de los scripts

[1] Script en .sh

Citar

#!/bin/bash

flag_no_ceros=false
flag_salida=false
caracter_espacio=""

uso()
{
        echo "Uso: $0 [OPCIONES] <diccionario1> <diccionario2>"
        echo "  Lista de opciones:"
        echo "  -e, inserta espacio entre dos palabras"
        echo "  -h, muestra esta ayuda"
        echo "  -z, omite ceros en ambos diccionarios"
        echo "  -o, especifica archivo de salida."
        echo "      Salida estándard si se omite esta opción"
}

if [ $# -eq 0 ]
then
        uso
        exit 1
fi

while getopts "zeho:" Opcion
do
        case $Opcion in
                e)
                        caracter_espacio=" "
                        ;;
                h)
                        uso
                        exit 1
                        ;;
                z)
                        flag_no_ceros=true
                        ;;
                o)
                        salida=$OPTARG
                        flag_salida=true
                        ;;
                ?)
                        echo "opción $OPTARG no reconocida"
                        ;;
               
                        echo "opción $OPTARG requiere un argumento"
                        ;;
        esac
done

shift $(( OPTIND - 1 ))

if [ -z $1 ]||[ -z $2 ]
then
        echo "Faltan argumentos"
        exit 1
fi

if [ ! -e $1 ]
then
        echo "No se pudo encontrar $1"
        exit 1
fi

if [ ! -e $2 ]
then
        echo "No se pudo encontrar $2"
        exit 1
fi

for f1 in $(if [ $flag_no_ceros == true ]
        then
                cat $1|tr -d "0"
        else
                cat $1
        fi)
do
        for f2 in $(if [ $flag_no_ceros == true ]
                then
                        cat $2|tr -d "0"
                else
                        cat $2
                fi)
        do
                if [ $flag_salida == true ]
                then
                        echo $f1$caracter_espacio$f2 >> $salida
                else
                        echo $f1$caracter_espacio$f2
                fi
        done
done

[2] Script en perl

Citar

#!/usr/bin/perl

#######################################################################
# Fichero:                      sgen.pl
# Fecha:			2-03-2010
# Version			1.2
# Autor:                        |FluiD| ([email protected])
# Descripcion:			Generador de diccionarios.
#
# Este programa es software libre; puedes redistribuirlo y/o modificarlo
# bajo los términos de la Licencia Publica General GNU (GPL) publicada
# por la Free Software Foundation; en su versión numero 3, o (bajo tu
# criterio) la ultima versión. Mira http://www.fsf.org/copyleft/gpl.txt
#
# Este programa se distribuye SIN GARANTIA de ningún tipo.
#
##########################################################################

#Variables a mostrar en menu.
$p = "N/A.";
$s = "N/A.";

# Salida estandar de HEX aleatorias
if (($ARGV[0] eq "-h") or ($ARGV[0] eq "-H"))
   {

print <<AQUI;

 StrinGenerator 1.2, by |FluiD| <[email protected]>
 usage: perl sgen.pl [ -hxX  <num> ]

   Sin parametro muestra menu.  

  -h Muestra esta ayuda.
  -x HEX aleatorias minusculas en STDOUT.
  -X HEX aleatorias mayusculas en STDOUT.
  <num> Longitud de HEX (para -x -X). Sin <num>, 26 char.

AQUI
      exit;
   }
elsif ($ARGV[0] eq "-X")
   {
      &hex_may_out;
   }
elsif ($ARGV[0] eq "-x")
   {
      &hex_min_out;
   }

################################################################################################################
####################################### SUBRUTINA menu_principal ###############################################

&menu_principal;

sub menu_principal
{

my ($opmenu);

&limpia;
print <<AQUI;
 ===================================================
          StrinGenenator v1.2 by |FluiD| 
 ===================================================
 1.-  Dic. letras minusculas.
 2.-  Dic. letras MAYUSCULAS.
 3.-  Dic. letras minusculas y numeros.
 4.-  Dic. letras MAYUSCULAS y numeros.
 5.-  Dic. numeros.
 6.-  Dic. numeros desde... hasta...
 7.-  Dic. HEX.
 8.-  Dic. HEX aleatorios.
 9.-  Dic. con string y letras minusculas.
 10.- Dic. con string y letras MAYUSCULAS.
 11.- Dic. con string y numeros.
 12.- Dic. con string, letras minusculas y numeros.
 13.- Dic. con string, letras MAYUSCULAS y numeros.
 14.- Dic. a medida.
 15.- Dic. a medida por volumenes.
 16.- Filtrar palabras en archivo de texto.
 17.- Conversor archivos Mayusculas/Minusculas.
 ---------------------------------------------------
 p.-Prefijo : $p
 s.-Sufijo  : $s
 ---------------------------------------------------
AQUI

print " Opcion: ";

$opmenu = <STDIN>;
chomp $opmenu;

if ($opmenu eq 1)
   {
      &fichero;
      &longitud;
      &let_min;
   }
elsif ($opmenu eq 2)
   {
      &fichero;
      &longitud;
      &let_may;
   }
elsif ($opmenu eq 3)
   {
      &fichero;
      &longitud;
      &let_min_num;
   }
elsif ($opmenu eq 4)
   {
      &fichero;
      &longitud;
      &let_may_num;
   }
elsif ($opmenu eq 5)
   {
      &fichero;
      &longitud;
      &num;
   }
elsif ($opmenu eq 6)
   {
      &fichero;
      &num_def;
   }
elsif ($opmenu eq 7)
   {
      &fichero;
      &longitud;
      &hex;
   }
elsif ($opmenu eq 8)
   {
      &fichero;
      &hex_aleatorio;
   }
elsif ($opmenu eq 9)
   {
      &fichero;
      &longitud;
      &string;
      &string_min;
   }
elsif ($opmenu eq 10)
   {
      &fichero;
      &longitud;
      &string;
      &string_may;
   }
elsif ($opmenu eq 11)
   {
      &fichero;
      &longitud;
      &string;
      &string_num;
   }
elsif ($opmenu eq 12)
   {
      &fichero;
      &longitud;
      &string;
      &string_min_num;
   }
elsif ($opmenu eq 13)
   {
      &fichero;
      &longitud;
      &string;
      &string_may_num;
   }
elsif ($opmenu eq 14)
   {  &fichero;
      &longitud2;
      &medida2;
   }
elsif ($opmenu eq 15)
   {  &menu_volumen;
      &fichero;
      &longitud2;
      &medida;
   }  
elsif ($opmenu eq 16)
   {
      &fichero;
      &cleandic;
   }
elsif ($opmenu eq 17)
   {
      &fichero;
      &conv;
   }
elsif ($opmenu eq "p")
   {
      &prefijo;
   }
elsif ($opmenu eq "s")
   {
      &sufijo;
   }
else
   {
      &menu_principal;
   }

} #SUB


################################################################################################################
####################################### SUBRUTINA hex_may_out ##################################################

######################################################
# Ejecutando el script con perl sgen.pl -X <num>
# genera por la salida estandar Hex aleatorias en
# mayusculas con la longitud <num>.
# Sin <num> genera con longitud 26
######################################################

sub hex_may_out
{
   my($long,@hex,$cont,$num,$hex);

   $long = $ARGV[1];

   if (($long eq "") or ($long !~ /\b\d+\b/)) {$long= 26};


   @hex = (0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F);
   $cont = 0;

while(1)
   {

      $num =  int(rand(16));
      $hex = $hex.$hex[$num];

      $cont++;

         if ($cont == $long)
            {
               $cont=0;
               print "$hex\n";
               $hex = "";
            }
   }
}


################################################################################################################
####################################### SUBRUTINA hex_min_out ##################################################

######################################################
# Ejecutando el script con perl sgen.pl -x <num>
# genera por la salida estandar Hex aleatorias en
# minusculas con la longitud <num>
# Sin <num> genera con longitud 26.
######################################################


sub hex_min_out
{
   my($long,@hex,$cont,$num,$hex);

   $long = $ARGV[1];

  if (($long eq "") or ($long !~ /\b\d+\b/)) {$long= 26};

   @hex = (0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f);
   $cont = 0;

while(1)
   {
      $num =  int(rand(16));
      $hex = $hex.$hex[$num];

      $cont++;

         if ($cont == $long)
            {
               $cont=0;
               print "$hex\n";
               $hex = "";
            }
   }
}

################################################################################################################
####################################### SUBRUTINA prefijo #####################################################

sub prefijo
{
   print "\n Este prefijo se aplicara a TODOS los diccionarios.\n";
   print " A excepcion de las opciones 16 y 17.\n";
   print " Pulsa solo enter para no usar ningun prefijo.\n\n";
   print " Prefijo: ";
   $pref = <STDIN>;
   chomp $pref;

   if ($pref eq "")
      {
         $p = "N/A.";
      }
   else
      {
         $p = $pref;
      }

   &menu_principal;
}


################################################################################################################
####################################### SUBRUTINA sufijo #####################################################

sub sufijo
{
   print "\n Este sufijo se aplicara a TODOS los diccionarios.\n";
   print " A excepcion de las opciones 16 y 17.\n";
   print " Pulsa solo enter para no usar ningun prefijo.\n\n";
   print " Sufijo: ";
   $suf = <STDIN>;
   chomp $suf;

   if ($suf eq "")
      {
         $s = "N/A.";
      }
   else
      {
         $s = $suf;
      }

   &menu_principal;
}


################################################################################################################
####################################### SUBRUTINA cleandic #####################################################

# Extrae palabras de archivos de texto

sub cleandic
{

# Declaramos las variables como local
my ($longitud, $archivo, @matriz1, @matriz2, $opcion);

@matriz1=();
@matriz2=();
$longitud=();
$opcion=();

# El nombre del diccionario a crear se obtiene en una llamada en la subrutina menu_principal

# Obtenemos el nombre del archivo de texto a filtar
print " Nombre del archivo de texto a filtrar: ";
$archivo = <STDIN>;
chomp $archivo;

# Abrimos el archivo a filtrar
if (not open (ARCHIVOAFILTRAR, "$archivo"))
   {
      print " No se ha podido abrir el archivo!";
      $null = (<STDIN>);
      &menu_principal
   }

# Agregamos a la matriz2 cada linea del archivo de texto
while (<ARCHIVOAFILTRAR>)
   {
      @matriz1 = split(/\s+/, $_);
      splice(@matriz2, $#matriz2+1, 0, @matriz1);
   }

ETI3:
print <<AQUI;

 ===================================================

 1.-    Extrae todo, no filtra longitud.

 2.-    Extrae longitud indicada.

 3.-    Todas las longitudes menores o igual que...

 4.-    Todas las longitudes mayores o igual que...

 ===================================================

AQUI

print " Opcion: ";
$opcion = (<STDIN>);
chomp $opcion;
if ($opcion !~ /\b[1-4]\b/) {goto ETI3;}

if ($opcion ne 1)
   {
      ETI4:
      print " Longitud en caracteres de las palabras a extraer: ";
      $longitud = <STDIN>;
      chomp $longitud;
      if ($longitud !~ /\b[1-9]+\b/) {goto ETI4;}
   }

# Opcion menu 1
if ($opcion eq 1)
   {
      foreach (@matriz2)
         {
            print DICC "$_\n";
         }

      close ARCHIVOAFILTRAR;
      &generando;
      &generado;      
   }

# Opcion menu 2
elsif ($opcion eq 2 )
   {
      foreach (@matriz2)
         {
            if (length($_) eq $longitud) 
               {
                  print DICC "$_\n";
               }
         }

      close ARCHIVOAFILTRAR;
      &generando;
      &generado;      

   }

# Opcion menu 3
elsif ($opcion eq 3 )
   {
      foreach (@matriz2)
         {
            if (length($_) <= $longitud) 
               {
                  print DICC "$_\n";
               }
         }

      close ARCHIVOAFILTRAR;
      &generando;
      &generado;      

   }

# Opcion menu 4
elsif ($opcion eq 4 )
   {
      foreach (@matriz2)
         {
            if (length($_) >= $longitud) 
               {
                  print DICC "$_\n";
               }
         }

      close ARCHIVOAFILTRAR;
      &generando;
      &generado;      

   }

print " Opciones no validas!";
$null = <STDIN>;
&menu_principal;

} # Fin sub cleandic

################################################################################################################
####################################### SUBRUTINA menu_volumen #################################################

sub menu_volumen
{

# De aqui obtenemos la variable $tamano

print " Generar el diccionario en varios volumenes? (s/n): ";
$sino = <STDIN>;

if ($sino =~ /\bs\b/i)
   {
   
      $fijaerror = 1;
      ETI1:
      print " Cuantos Mb por volumen: ";
      $tamano = <STDIN>;
      chomp $tamano;

      if (($tamano !~ /\b\d\d*\b/) or ($tamano eq 0)) {goto ETI1;}

# De aqui obtenemos la variable $stop que nos servira en la subrutina comprueba
      
      ETI2:
      print " Esperar y preguntar despues de cada volumen? (s/n): ";
      $stop = <STDIN>;
      chomp $stop;

      if ($stop =~ /\bs\b/i)
         {
            $stop = 1;
         }
   
      elsif ($stop =~ /\bn\b/i)
         {
            $stop = 0;
         }
      else {goto ETI2;}

   }
elsif ($sino =~ /\bn\b/i)
   {
      #Esto es necesario para fijar el error de $tamano cuando no tiene valor, ya que entra en el 
      #condicional if de la subrutina &comprueba y hace "true" la sentencia

      $fijaerror = 0; 
   }
else
   {
      &menu_volumen;
   }

} #SUB


################################################################################################################
####################################### SUBRUTINA comprueba ####################################################

sub comprueba
{
   $size = (-s DICC);
   $size = (($size / 1024) / 1024);
   if (($size >= $tamano) and ($fijaerror eq 1))
   {

      close DICC;
      $sumavol++;
      open (DICC, ">$diccionario$sumavol");

      if ($stop eq 1)
         {
            print "\n";
            print " Volumen $sumavol con $tamano Mb creado\n";
            print " Pulsa ENTER para continuar";
            $null = <STDIN>;
            &generando2
         }
   } 
}



################################################################################################################
####################################### SUBRUTINA limpia #######################################################

sub limpia
{
$platform = `uname -o`;
chomp $platform;

   if ($platform eq "GNU/Linux")
      {
         system clear;
      }
   else
      {
         system cls;
      }
}


################################################################################################################
####################################### SUBRUTINA fichero ######################################################

sub fichero
{

   #Obtenemos el nombre del diccionario y lo abrimos con el gestor
   
   print " Nombre del diccionario a crear: ";
   $diccionario = <STDIN>;
   if ($diccionario eq "\n"){&fichero;}
   chomp $diccionario;
   if ( -e $diccionario)
      {
         print "\n";
         print " ---------------------------------------------\n";
         print " El diccionario a crear ya existe.\n";
         print " Las palabras nuevas seran agregadas al final.\n";
         print " ---------------------------------------------\n";
      }

   open (DICC, ">>$diccionario");

}


################################################################################################################
####################################### SUBRUTINA logitud ######################################################

sub longitud
{
      print " Logitud de la cadena (num. de variables(2-13)): ";
      $longitud = <STDIN>;
      chomp $longitud;
      if (($longitud ne 2) and 
          ($longitud ne 3) and
          ($longitud ne 4) and
          ($longitud ne 5) and
          ($longitud ne 6) and
          ($longitud ne 7) and
          ($longitud ne 8) and
          ($longitud ne 9) and
          ($longitud ne 10) and
          ($longitud ne 11) and
          ($longitud ne 12) and
          ($longitud ne 13))
            {
               &longitud;
            }
}   



################################################################################################################
####################################### SUBRUTINA logitud2 #####################################################

# Esta subrutina es solo para  &medida y $medida2, para poder ampliar la longitud maxima a 15
sub longitud2
{
      print " Logitud de la cadena (num. de variables(2-15)): ";
      $longitud = <STDIN>;
      chomp $longitud;
      if (($longitud ne 2) and 
          ($longitud ne 3) and
          ($longitud ne 4) and
          ($longitud ne 5) and
          ($longitud ne 6) and
          ($longitud ne 7) and
          ($longitud ne 8) and
          ($longitud ne 9) and
          ($longitud ne 10) and
          ($longitud ne 11) and
          ($longitud ne 12) and
          ($longitud ne 13) and
          ($longitud ne 14) and
          ($longitud ne 15))
          
            {
               &longitud2;
            }
}   

################################################################################################################
####################################### SUBRUTINA string #######################################################

sub string
{
   print " Cadena o string a intercalar entre las variables: ";
   $string =<STDIN>;
   chomp $string;
   @string = ();
   unshift (@string,$string);
}

################################################################################################################
####################################### SUBRUTINA generando ####################################################

sub generando
{
print <<AQUI;

 ===================================================
 Generando diccionario...
 Nombre del diccionario : $diccionario
 CONTROL + C cancela diccionario.
 ===================================================
AQUI
}
################################################################################################################
####################################### SUBRUTINA generando2 ###################################################

sub generando2
{
print <<AQUI;

 ===================================================
 Generando diccionario...
 CONTROL + C cancela diccionario.
 ===================================================
AQUI
}

################################################################################################################
###################################### SUBRUTINA generado ######################################################

sub generado
{
close DICC;
print <<AQUI;

 ===================================================
 Diccionario creado con exito.
 Pulsa ENTER para volver a menu.
 ===================================================
AQUI

$null =  <STDIN>;
&menu_principal;
}


################################################################################################################
####################################### SUBRUTINA agrega #######################################################

sub agrega
{
print <<AQUI;

 ===================================================
 Introduce los atajos con los corchetes.
 Para mas ayuda consulta el LEEME.txt
 ---------------------------------------------------

 [a-z] Agrega abecedario completo en min.

 [A-Z] Agrega abecedario completo en MAY.

 [0-9] Agrega todos los numeros.

 [a-f] Agrega todos los caracteres HEX en min.

 [A-F] Agrega todos los caracteres HEX en MAY.

 ===================================================
 Introduce cualquier caracter, palabra o signo de
 puntuacion y pulsa ENTER.
 Se generaran todas las combinaciones de los
 caracteres que introduzcas.
 ---------------------------------------------------
 Para comenzar a generar el diccionario 
 escribe .exit en minusculas (Con el punto).
 ===================================================

AQUI
}

################################################################################################################
####################################### SUBRUTINA let_min ######################################################

sub let_min
{

##############################################
#   Genera combinaciones de la "a" a la "z"  
#   de letras minusculas de longitud de entre
#   2 y 13 caracteres.
##############################################

#DEFINIMOS VARIABLES COMO LOCAL
my ($var1,$var2,$var3,$var4,$var5,$var6,$var7,$var8,$var9,$var10,$var11,$var12,$var13,@matriz);

@matriz=("a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z");

&generando;

#VARIABLE 1
foreach $var1(@matriz)
{

#VARIABLE 2
      foreach $var2(@matriz)
      {
	if ($longitud == 2)
         {
         print DICC $pref,$var1,$var2,$suf;
         print DICC "\n";
         next;
         }

#VARIABLE 3      
      foreach $var3(@matriz)
      {
         if ($longitud == 3)
         {
         print DICC $pref,$var1,$var2,$var3,$suf;
         print DICC "\n";
         next;
         }

#VARIABLE 4      
      foreach $var4(@matriz)
      {
         if ($longitud == 4)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$suf;
         print DICC "\n";
         next;
         }

#VARIABLE 5
      foreach $var5(@matriz)
      {
         if ($longitud == 5)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$suf;
         print DICC "\n";
         next;
         }

#VARIABLE 6      
      foreach $var6(@matriz)
      {
         if ($longitud == 6)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$var6,$suf;
         print DICC "\n";
         next;
         }

#VARIABLE 7      
      foreach $var7(@matriz)
      {
         if ($longitud == 7)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$var6,$var7,$suf;
         print DICC "\n";
         next;
         }

#VARIABLE 8      
      foreach $var8(@matriz)
      {
         if ($longitud == 8)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$var6,$var7,$var8,$suf;
         print DICC "\n";
         next;
         }

#VARIABLE 9      
      foreach $var9(@matriz)
      {
         if ($longitud == 9)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$var6,$var7,$var8,$var9,$suf;
         print DICC "\n";
         next;
         }

#VARIABLE 10      
      foreach $var10(@matriz)
      {
         if ($longitud == 10)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$var6,$var7,$var8,$var9,$var10,$suf;
         print DICC "\n";
         next;
         }
#VARIABLE 11      
      foreach $var11(@matriz)
      {
         if ($longitud == 11)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$var6,$var7,$var8,$var9,$var10,$var11,$suf;
         print DICC "\n";
         next;
         }
#VARIABLE 12      
      foreach $var12(@matriz)
      {
         if ($longitud == 12)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$var6,$var7,$var8,$var9,$var10,$var11,$var12,$suf;
         print DICC "\n";
         next;
         }
#VARIABLE 13      
      foreach $var13(@matriz)
      {
         if ($longitud == 13)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$var6,$var7,$var8,$var9,$var10,$var11,$var12,$var13,$suf;
         print DICC "\n";
         next;
         }

      } #BUCLE 13
      } #BUCLE 12
      } #BUCLE 11
      } #BUCLE 10
      } #BUCLE 9
      } #BUCLE 8
      } #BUCLE 7
      } #BUCLE 6
      } #BUCLE 5
      } #BUCLE 4
      } #BUCLE 3
      } #BUCLE 2

} #BUCLE 1

&generado;

} #SUB

################################################################################################################
####################################### SUBRUTINA let_may ######################################################

sub let_may
{

##############################################
#   Genera combinaciones de la "a" a la "z"  
#   de letras MAYUSCULAS de longitud de entre
#   2 y 13 caracteres.
##############################################

#DEFINIMOS VARIABLES COMO LOCAL
my ($var1,$var2,$var3,$var4,$var5,$var6,$var7,$var8,$var9,$var10,$var11,$var12,$var13,@matriz);

@matriz=("A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z");

&generando;

#VARIABLE 1
foreach $var1(@matriz)
{

#VARIABLE 2
      foreach $var2(@matriz)
      {
	if ($longitud == 2)
         {
         print DICC $pref,$var1,$var2,$suf;
         print DICC "\n";
         next;
         }

#VARIABLE 3      
      foreach $var3(@matriz)
      {
         if ($longitud == 3)
         {
         print DICC $pref,$var1,$var2,$var3,$suf;
         print DICC "\n";
         next;
         }

#VARIABLE 4      
      foreach $var4(@matriz)
      {
         if ($longitud == 4)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$suf;
         print DICC "\n";
         next;
         }

#VARIABLE 5
      foreach $var5(@matriz)
      {
         if ($longitud == 5)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$suf;
         print DICC "\n";
         next;
         }

#VARIABLE 6      
      foreach $var6(@matriz)
      {
         if ($longitud == 6)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$var6,$suf;
         print DICC "\n";
         next;
         }

#VARIABLE 7      
      foreach $var7(@matriz)
      {
         if ($longitud == 7)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$var6,$var7,$suf;
         print DICC "\n";
         next;
         }

#VARIABLE 8      
      foreach $var8(@matriz)
      {
         if ($longitud == 8)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$var6,$var7,$var8,$suf;
         print DICC "\n";
         next;
         }

#VARIABLE 9      
      foreach $var9(@matriz)
      {
         if ($longitud == 9)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$var6,$var7,$var8,$var9,$suf;
         print DICC "\n";
         next;
         }

#VARIABLE 10      
      foreach $var10(@matriz)
      {
         if ($longitud == 10)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$var6,$var7,$var8,$var9,$var10,$suf;
         print DICC "\n";
         next;
         }
#VARIABLE 11      
      foreach $var11(@matriz)
      {
         if ($longitud == 11)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$var6,$var7,$var8,$var9,$var10,$var11,$suf;
         print DICC "\n";
         next;
         }
#VARIABLE 12      
      foreach $var12(@matriz)
      {
         if ($longitud == 12)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$var6,$var7,$var8,$var9,$var10,$var11,$var12,$suf;
         print DICC "\n";
         next;
         }
#VARIABLE 13      
      foreach $var13(@matriz)
      {
         if ($longitud == 13)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$var6,$var7,$var8,$var9,$var10,$var11,$var12,$var13,$suf;
         print DICC "\n";
         next;
         }

      } #BUCLE 13
      } #BUCLE 12
      } #BUCLE 11
      } #BUCLE 10
      } #BUCLE 9
      } #BUCLE 8
      } #BUCLE 7
      } #BUCLE 6
      } #BUCLE 5
      } #BUCLE 4
      } #BUCLE 3
      } #BUCLE 2

} #BUCLE 1

&generado;

} #SUB

####################################################################################################################
####################################### SUBRUTINA let_min_num ######################################################

sub let_min_num
{

##############################################
#   Genera combinaciones de letras minusculas
#   y numeros (en ese orden) de entre 2 y 
#   13 caracteres.
##############################################

#DEFINIMOS VARIABLES COMO LOCAL
my ($var1,$var2,$var3,$var4,$var5,$var6,$var7,$var8,$var9,$var10,$var11,$var12,$var13,@matriz);

@matriz=("a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z","0","1","2","3","4","5","6","7","8","9");

&generando;

#VARIABLE 1
foreach $var1(@matriz)
{

#VARIABLE 2
      foreach $var2(@matriz)
      {
	if ($longitud == 2)
         {
         print DICC $pref,$var1,$var2,$suf;
         print DICC "\n";
         next;
         }

#VARIABLE 3      
      foreach $var3(@matriz)
      {
         if ($longitud == 3)
         {
         print DICC $pref,$var1,$var2,$var3,$suf;
         print DICC "\n";
         next;
         }

#VARIABLE 4      
      foreach $var4(@matriz)
      {
         if ($longitud == 4)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$suf;
         print DICC "\n";
         next;
         }

#VARIABLE 5
      foreach $var5(@matriz)
      {
         if ($longitud == 5)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$suf;
         print DICC "\n";
         next;
         }

#VARIABLE 6      
      foreach $var6(@matriz)
      {
         if ($longitud == 6)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$var6,$suf;
         print DICC "\n";
         next;
         }

#VARIABLE 7      
      foreach $var7(@matriz)
      {
         if ($longitud == 7)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$var6,$var7,$suf;
         print DICC "\n";
         next;
         }

#VARIABLE 8      
      foreach $var8(@matriz)
      {
         if ($longitud == 8)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$var6,$var7,$var8,$suf;
         print DICC "\n";
         next;
         }

#VARIABLE 9      
      foreach $var9(@matriz)
      {
         if ($longitud == 9)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$var6,$var7,$var8,$var9,$suf;
         print DICC "\n";
         next;
         }

#VARIABLE 10      
      foreach $var10(@matriz)
      {
         if ($longitud == 10)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$var6,$var7,$var8,$var9,$var10,$suf;
         print DICC "\n";
         next;
         }
#VARIABLE 11      
      foreach $var11(@matriz)
      {
         if ($longitud == 11)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$var6,$var7,$var8,$var9,$var10,$var11,$suf;
         print DICC "\n";
         next;
         }
#VARIABLE 12      
      foreach $var12(@matriz)
      {
         if ($longitud == 12)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$var6,$var7,$var8,$var9,$var10,$var11,$var12,$suf;
         print DICC "\n";
         next;
         }
#VARIABLE 13      
      foreach $var13(@matriz)
      {
         if ($longitud == 13)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$var6,$var7,$var8,$var9,$var10,$var11,$var12,$var13,$suf;
         print DICC "\n";
         next;
         }

      } #BUCLE 13
      } #BUCLE 12
      } #BUCLE 11
      } #BUCLE 10
      } #BUCLE 9
      } #BUCLE 8
      } #BUCLE 7
      } #BUCLE 6
      } #BUCLE 5
      } #BUCLE 4
      } #BUCLE 3
      } #BUCLE 2

} #BUCLE 1

&generado;

} #SUB

####################################################################################################################
####################################### SUBRUTINA let_may_num ######################################################

sub let_may_num
{
##############################################
#   Genera combinaciones de letras MAYUSCULAS
#   y numeros (en ese orden) de entre 2 y 
#   13 caracteres.
##############################################

#DEFINIMOS VARIABLES COMO LOCAL
my ($var1,$var2,$var3,$var4,$var5,$var6,$var7,$var8,$var9,$var10,$var11,$var12,$var13,@matriz);

@matriz=("A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z","0","1","2","3","4","5","6","7","8","9");

&generando;

#VARIABLE 1
foreach $var1(@matriz)
{

#VARIABLE 2
      foreach $var2(@matriz)
      {
	if ($longitud == 2)
         {
         print DICC $pref,$var1,$var2,$suf;
         print DICC "\n";
         next;
         }

#VARIABLE 3      
      foreach $var3(@matriz)
      {
         if ($longitud == 3)
         {
         print DICC $pref,$var1,$var2,$var3,$suf;
         print DICC "\n";
         next;
         }

#VARIABLE 4      
      foreach $var4(@matriz)
      {
         if ($longitud == 4)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$suf;
         print DICC "\n";
         next;
         }

#VARIABLE 5
      foreach $var5(@matriz)
      {
         if ($longitud == 5)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$suf;
         print DICC "\n";
         next;
         }

#VARIABLE 6      
      foreach $var6(@matriz)
      {
         if ($longitud == 6)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$var6,$suf;
         print DICC "\n";
         next;
         }

#VARIABLE 7      
      foreach $var7(@matriz)
      {
         if ($longitud == 7)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$var6,$var7,$suf;
         print DICC "\n";
         next;
         }

#VARIABLE 8      
      foreach $var8(@matriz)
      {
         if ($longitud == 8)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$var6,$var7,$var8,$suf;
         print DICC "\n";
         next;
         }

#VARIABLE 9      
      foreach $var9(@matriz)
      {
         if ($longitud == 9)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$var6,$var7,$var8,$var9,$suf;
         print DICC "\n";
         next;
         }

#VARIABLE 10
      foreach $var10(@matriz)
      {
         if ($longitud == 10)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$var6,$var7,$var8,$var9,$var10,$suf;
         print DICC "\n";
         next;
         }
#VARIABLE 11
      foreach $var11(@matriz)
      {
         if ($longitud == 11)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$var6,$var7,$var8,$var9,$var10,$var11,$suf;
         print DICC "\n";
         next;
         }
#VARIABLE 12
      foreach $var12(@matriz)
      {
         if ($longitud == 12)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$var6,$var7,$var8,$var9,$var10,$var11,$var12,$suf;
         print DICC "\n";
         next;
         }
#VARIABLE 13
      foreach $var13(@matriz)
      {
         if ($longitud == 13)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$var6,$var7,$var8,$var9,$var10,$var11,$var12,$var13,$suf;
         print DICC "\n";
         next;
         }

      } #BUCLE 13
      } #BUCLE 12
      } #BUCLE 11
      } #BUCLE 10
      } #BUCLE 9
      } #BUCLE 8
      } #BUCLE 7
      } #BUCLE 6
      } #BUCLE 5
      } #BUCLE 4
      } #BUCLE 3
      } #BUCLE 2

} #BUCLE 1

&generado;

} #SUB

################################################################################################################
####################################### SUBRUTINA num ##########################################################

sub num
{

##############################################
#   Genera combinaciones de numeros de entre
#   2 y 13 caracteres.
##############################################

#DEFINIMOS VARIABLES COMO LOCAL
my ($var1,$var2,$var3,$var4,$var5,$var6,$var7,$var8,$var9,$var10,$var11,$var12,$var13,@matriz);

@matriz=("0","1","2","3","4","5","6","7","8","9");

&generando;

#VARIABLE 1
foreach $var1(@matriz)
{

#VARIABLE 2
      foreach $var2(@matriz)
      {
	if ($longitud == 2)
         {
         print DICC $pref,$var1,$var2,$suf;
         print DICC "\n";
         next;
         }

#VARIABLE 3      
      foreach $var3(@matriz)
      {
         if ($longitud == 3)
         {
         print DICC $pref,$var1,$var2,$var3,$suf;
         print DICC "\n";
         next;
         }

#VARIABLE 4      
      foreach $var4(@matriz)
      {
         if ($longitud == 4)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$suf;
         print DICC "\n";
         next;
         }

#VARIABLE 5
      foreach $var5(@matriz)
      {
         if ($longitud == 5)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$suf;
         print DICC "\n";
         next;
         }

#VARIABLE 6      
      foreach $var6(@matriz)
      {
         if ($longitud == 6)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$var6,$suf;
         print DICC "\n";
         next;
         }

#VARIABLE 7      
      foreach $var7(@matriz)
      {
         if ($longitud == 7)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$var6,$var7,$suf;
         print DICC "\n";
         next;
         }

#VARIABLE 8      
      foreach $var8(@matriz)
      {
         if ($longitud == 8)
         {
         print DICC $pref,$var1,$var2,$var3,$var4,$var5,$var6,$var7,$var8,$suf;
         print DICC "\n";
  &