Validación “edit unique” en CodeIgniter

No Comments

Extracto

Es cierto, CodeIniger, tiene muy buen sistema de validaciones, aunque le falten algunas tan tontas como un validador de fechas, y uno que antes de realizar un update en la base de datos compruebe que los campos que hemos declarado como claves UNIQUE sigan siéndolo con los nuevos datos que estamos modificando.

@pedroruizhidalg―La situación es la siguiente: tengo una tabla a la que llamo kanban, cuyo campo kanban_name he descrito como único. Así: Read More…

Trabajar con MY_Controller de CodeIgniter

No Comments

Extracto

Reemplazar las librerías nativas de CI con nuestras propias versiones. Asignando un nombre a los archivos de clase idéntico a una librería nativa causaremos que CI los utilice en lugar de las clases nativas. Esta característica se invoca de la forma más elemental: llamar a la librería igual que su nombre nativo de CI. Por ejemplo para reemplazar con nuestro propio código a la librería nativa de Email tan solo tenemos que crear el archivo application/libraries/Email.php y declarar su clase como:

class CI_Email{
// aquí tu código ///
}

@pedroruizhidalg―Hay que tener en cuenta que la mayoría de las clases empiezan con el prefijo CI, aunque no todas. Has de tener cuidado con esto. No obstante si lo que necesitamos es añadir una (o varias) funcionalidades extra a nuestras clases nativas, es más recomendable usar la extensión de las librerías nativas que andar reconstruyendo todo desde cero: reinventando la rueda.

Read More…

Gestor de copias de seguridad incrementales en Linux

No Comments

Extracto

@pedroruizhidalg― Ya escribimos sobre las copias de seguridad en Linux, otra estupenda opción es rsync. Este comando (https://rsync.samba.org/) de los creadores de samba, tiene, en principio, está pensado para la sincronía remota de directorios. No obstante, su funcionalidad es muy amplia y puede ser dedicado a otros usos.

Read More…

Los permisos de archivos en Linux

No Comments

Extracto

@pedroruizhidalg― Cada archivo y directorio en Linux tiene asociado un conjunto de permisos de determina quiénes pueden acceder y en qué forma. Estos permisos se pueden establecer para restringir el acceso a tres entidades y de tres formas: a usted, al grupo al que perteneces y a otros ―es decir, todo el mundo―.

Read More…

Categories: Computación, linux, Tecnología, Tecnologías Tags: Etiquetas: , , ,

Google Inbox para gestionar mucho correo

No Comments

Extracto

@pedroruizhidalg― Gestionar mucho correo se ha convertido en una tarea tan necesaria como desagradable. Seguramente os ocurrirá como a mí y recibís cientos de correos a la semana. La mayor parte de ellos totalmente inútiles, algunos de ellos interesante y pocos a los que prestar atención. Google tiene una buena solución para esto. Google Inbox.

inbox

Abreviaturas usadas

Descripción

La perfecta integración de Google Inbox con el móvil ―al menos con Android― es perfecta. Permite gestionar varias cuentas de correo, obviamente todas Gmail, con una interfaz ligera con la que puedes cambiar de usuario con un solo gesto, tanto en el navegador del equipo como en el móvil.

Ejecución

Lo primero que tienes que hacer cuando entras en Inbox es entrar al menú,, a la izquierda de Recibidos.inbox1

Tras esto entras en configuración→otros.

inbox2

Y puedes redireccionar todo el tráfico de Gmail a Inbox marcándolo como indico. Si luego no te agrada o quieres dejar de probarlo, tan solo desactiva la redirección eliminando la marca.

Inbox, viene preparado para filtrar, filtrar mucho. Por defecto todos vienen creados unos contenedores para viajes, compras, finanzas, social, notificaciones, foros, promociones y la posibilidad de crear nuevos según tu conveniencia. No obstante yo los tengo desactivado, pues prefiero que me llegue todo al área de Recibidos. Verás por qué. El tratamiento correos de inbox es tan sumamente útil que de una vez por todas vas a tener la bandeja de entrada (Recibidos) vacía.

inbox3

Cuando pases el ratón por encima de cada email aparecen los manejadores que puedes ver a la derecha. El primero es para fijar el email a Recibidos mientras no elimines la chincheta. El segundo es para posponer. Una pasada. Puedes posponerlo para una hora, para otro día, incluso para otro lugar; yo lo he probado incluso con distintas provincias, funciona de maravilla. El tercero envía el email a la bandeja de completados, sin tener que leerlo si no te apetece. El cuarto es para clasificarlo si te apetece o moverlo a otro lugar.

Siempre podrás consultar los archivos pospuestos en su bandeja correspondiente. Igualmente con completados. Que lo elimines de la bandeja de Recibidos no significa que lo hayas eliminado. En absoluto. No obstante, esto también es configurable.

Verás que bajo la bandeja de Enviados, aparece un icono de Recordatorios.

inbox4

Otra maravilla. Olvídate de enviarte correos a ti mismo para acordarte de las cosas. Esto se integrará perfectamente con tu Google Calendar. Todos los recordatorios que tú actives estarán por defecto con la chincheta en la bandeja de recibidos y perfectamente clasificados en tu calendar, tanto en el ordenador como en tu móvil.

Tienes que saber que la «gestualidad» en el móvil es distinta a la del entorno en un navegador. En el móvil cuando recibes un correo lo mandas a completado desplazándolo a la derecha. Mientras que si lo desplazas a la izquierda estarás mandándolo a Pospuestos, listo para ser programado.

Mi táctica personal es como antes dije mantener la bandeja de entrada vacía. Nunca antes lo había conseguido con tanta comodidad.

Epílogo

Espero y deseo que este artículo haya sido de utilidad. Es muy importante para la continuación de trabajos de calidad recibir algún tipo de feedback por parte de los lectores: es decir, responde con comentarios, evalúa la calidad del trabajo con el sistema de estrellas, comparte con tus redes sociales, da me gusta, marca el blog como favorito. Son pequeños gestos que ayudan a mantener el trabajo de creación.

Clave pública @pedroruizhidalg.pub.key

exlibri, sapere aude

exlibri, sapere aude

#aboutpedroruizhidalgo
[polldaddy poll=9120832]
♻ miotroblogsite ahorra papel

Leer argumentos en scripts en bash

No Comments
keep calm and #!/bin/bash

Extracto

@pedroruizhidalg― Como venimos escribiendo acerca del entorno de terminal bash sobre sus variables, las posibilidades del entorno y preparar nuestro sistema para ejecutar scripts incluso con algún ejemplo sobre criptografía en este artículo vamos a ver la forma de recibir argumentos desde la linea de comandos para ser leídos en un script bash.

Abreviaturas usadas

Descripción

Como describimos en el artículo sobre bash  los comandos en Linux por regla general se ajustan al siguiente esquema.

$ Orden Opciones Argumentos

También por regla general los argumentos en Linux suelen ser nombres de archivos. Pero nosotros podemos crear scripts conforme a nuestros gustos, apetencias, forma de trabajar…

Ejecución

Una vez creado ambiente para ejecutar scripts, a modo de ejemplo vamos a crear un script para copiar archivos a un directorio que vamos a crear para tener un repositorio de los archivos que nos interese.

$ cd ~/
$ mkdir sandbox
  1. Nos situamos en nuestra directorio home.
  2. Creamos el directorio sandbox en nuestro home.

Ahora nos dirigimos al directorio que hemos preparado para ejecutar scripts ―en mi caso ~/.bin―. Allí vamos a crear un script que copie automáticamente a sandbox.

$ cd ~/.bin
$ touch tosandbox
$ chmod u+x tosandbox
$ gedit tosandbox &
  1. Cambiamos el directorio a .bin.
  2. Creamos el archivo “tosandbox” vacío.
  3. Le damos permisos de ejecución para el usuario (o sea, nosotros)
  4. Editamos con gedit el archivo en background. Por supuesto puedes usar el editor que más te guste. Guardamos el archivo.
#!/bin/bash
cp $1 ~/sandbox/
  1. En la primera linea informamos al sistema que este script debe ser ejecutado en bash.
  2. En la segunda $1 corresponde al argumento ―es decir, en este caso al nombre del fichero que queremos copiar― en la carpeta sandbox. Es decir, los argumentos, por orden de aparición, adquieren dentro del script como nombre para referirnos a ellos $1, $2, $3
Probamos que funciona
$ cd ~/
$ touch archivodeprueba
$ tosandbox archivodepueba
$ ls -l sandbox
$ ls -l
total 0
-rw-rw-r-- 1 pedro pedro 0 oct 24 16:25 archivodeprueba

Como podemos comprobar, y era previsible, tosandbox a enviado nuestro archivo de prueba a la carpeta deseada.

Usar un número desconocidos de argumentos

Sí. Se puede hacer así. Modificamos nuestro ~/.bin/sandbox

#!/bin/bash
cp $* ~/sandbox/

En la segunda línea hemos sustituido 1 por *. Esto significa que “todos los argumentos que enviemos serán copiados a la carpeta sandbox. Lo probamos.

$ cd ~/
$ touch unfichero otrofichero
$ tosandbox unfichero otrofichero
$ ls -l sandbox
total 0
-rw-rw-r-- 1 pedro pedro 0 oct 24 16:25 archivodeprueba
-rw-rw-r-- 1 pedro pedro 0 oct 24 16:35 unarchivo
-rw-rw-r-- 1 pedro pedro 0 oct 24 16:35 otroarchivo

Epílogo

Con esta entrada del blog podéis empezar a crear vuestros propios scripts aportándoles argumentos desde la linea de comandos.

Espero y deseo que este artículo haya sido de utilidad. Es muy importante para la continuación de trabajos de calidad recibir algún tipo de feedback por parte de los lectores: es decir, responde con comentarios, evalúa la calidad del trabajo con el sistema de estrellas, comparte con tus redes sociales, da me gusta, marca el blog como favorito. Son pequeños gestos que ayudan a mantener el trabajo de creación.

Clave pública @pedroruizhidalg.pub.key

#aboutpedroruizhidalgo
[polldaddy poll=9120832]
♻ miotroblogsite ahorra papel
Categories: Computación, linux, Tecnología, Tecnologías Tags: Etiquetas:

variables en shell bash de Linux

No Comments
keep calm and #!/bin/bash

Extracto

@pedroruizhidalg―Dentro del shell se definen variables. Éstas son conocidas como variables de shell ―no hicieron aquí un alarde de imaginación―, cada usuario puede elegir su propio shell y en cada shell las asignaciones y el tratamiento de variables puede diferir en cuanto a su sintaxis. Nosotros vamos a ver las variables para el shell bash.

Abreviaturas usadas

Descripción

Cuando empezamos a usar nuestro shell bash frecuentemente necesitamos automatizar algunas tareas o bien, simplemente, facilitarnos la vida en un trabajo que creamos que va a ser muy repetitivo. Existen varios tipos de variables shell, numéricas, alfanuméricas y array.

Definición de variables en shell  bash

Definir una variable en bash es tan simple como asignarle un valor con el signo igual y sin espacios desde el prompt de nuestro sistema.

$ variable=77
$ echo $variable
77
$

Ejecución

Como vemos en el ejemplo anterior para la llamada a la variable tenemos que precederla del signo dolar. En otras palabras, para definirla simplemente la nombramos, sin espacios escribimos el signo igual y sin espacios asignamos el valor.

Lo que asignemos a la variable no puede contener espacios que no estén delimitados por comillas simples, dobles o comillas invertidas.

Eliminación de variables
$ unset variable
$ echo $variable
bash: variable: variable sin asignar
$

Mediante la orden unset y el nombre de la variable, esta es eliminada del sistema. Asignar un valor vacío a la variable no la destruye, simplemente la iguala a valor vacio. Como podemos ver en el siguiente ejercicio tan solo unset destruye la variable.

$ciudad=Granada
$ echo $ciudad
Granada
$ ciudad=''
$ echo $ciudad

$ unset ciudad
$ echo $ciudad
bash: ciudad: variable sin asignar
$
Delimitación de cadenas: apóstrofos, comillas y barras invertidas

La cadena literal: entendemos como cadena literal cualquier contenido alfanumérico que no va a ser alterado nunca. Su evaluación será por tanto, una constante. En el siguiente ejemplo usamos Ciudad Real porque consta de dos palabras. Esto siempre será evaluado como ‘Ciudad Real’ mientras no alteremos su contenido.

$ ciudad='Ciudad Real'
$ echo $ciudad
Ciudad Real
$

La cadena evaluada: Para producir cadenas literales con una parte variable usamos las dobles comillas. Este tipo de cadenas al ser evaluadas contiene tanto la parte literal como la parte variable:

$ ciudad='Ciudad Real'
$ visitado="he visitado $ciudad"
$ echo $visitado
he visitado Ciudad Real
$ ciudad=Madrid
$ echo $visitado
he visitado Ciudad Real
$ visitado="he visitado $ciudad"
$ echo $visitado
he visitado Madrid
pedro@Makina:~$
  • En la primera orden asignamos a ciudad el valor de ‘Ciudad Real’.
  • En la segunda orden asignamos con comillas dobles el valor a visitado que contiene una parte literal y otra parte que corresponde al valor de la variable ciudad en el momento de la asignación.
  • En la tercera podemos comprobar cómo visitado muestra tanto su parte literal como su parte variable.
  • En la cuarta orden cambiamos el contenido de la variable ciudad.
  • En la quinta volvemos a mostrar visitado, pero no es alterado su contenido ya que no hemos hecho de nuevo la asignación.
  • En la sexta volvemos a efectuar la asignación a la variable visitado.
  • Comprobamos que la nueva evaluación de la cadena visitado ha surtido efecto con su nuevo valor.

Para alterar el valor de una cadena evaluada hemos de volver a realizar la asignación.

Una demostración de CÓMO NO FUNCIONA una cadena evaluada.

$ ciudad=Madrid
$ visitado='he visitado $ciudad'
$ echo $visitado
he visitado $ciudad
$

Vemos que el mismo procedimiento pero con los apóstrofes produce un resultado literal. La cadena no es evaluada.

Órdenes en variables

Con las comillas invertidas asignamos una orden a una variable. Mediante el comando pwd se averigua el directorio de trabajo en el que estamos actualmente trabajando. Asignemos esto a una variable en el siguiente ejercicio.

$ orden=`pwd`
$ echo $orden
/home/pedro/sandbox
$
Trabajar con arrays

Si sabes programar no te hace falta leer el siguiente párrafo.

Un array es formalmente un vector de memoria. Es decir, es una variable donde vamos a almacenar datos independientes. Estas variables siempre hay que expresarlas con un índice ―el índice del array― que determina su posición dentro del vector. En muchas ocasiones un programador necesita que una sola variable contenga distintos valores por ejemplo una lista de ciuades como en el ejemplo.

Los arrays se definen en bash con una asignación entre paréntesis y los elementos separados por espacio.

$ ciudad=(París 'Nueva York' 'Roma' Santiago)
$ echo ${ciudad[*]}
París Nueva York Roma Santiago
$ echo ${ciudad[0]}
París
$ echo ${ciudad[1]}
Nueva York
$ echo ${ciudad[2]}
Roma
$ echo ${ciudad[3]}
Santiago
$ echo ${ciudad[4]}

$
  1. Hemos asignado a la variable ciudad los elementos París, ‘Nueva York’ ―entre comillas pues son dos palabras―, Roma y Santiago.
  2. Vemos cómo listar todos los elementos del array ciudad. Observamos que para trabajar con arrays la sintaxis además del signo dolar tenemos que encerrar el nombre de la variable entre llaves {} y el número de elemento ―que siempre empieza por el elemento cero― entre corchetes [].
  3. Obtenemos el elemento 0.
  4. Vemos el contenido del elemento 1.
  5. Mostramos el elemento 2.
  6. Vemos el elemento 3.
  7. No existe nada en el elemento 4.

Lo vemos con otro ejemplo. Ahora vamos a introducir en una cadena evaluada un elemento del array.

$ ciudad=(París 'Nueva York' 'Roma' Santiago)
$ visitado="he visitado ${ciudad[$b]}"
$ b=1
$ echo $visitado
he visitado Nueva York
$ b=2
$ visitado="he visitado ${ciudad[$b]}"
$ echo $visitado
he visitado Roma
$

Podemos comprobar cómo con una sola variable almacenamos distintos valores.

Epílogo

Espero y deseo que este artículo haya sido de utilidad. Es muy importante para la continuación de trabajos de calidad recibir algún tipo de feedback por parte de los lectores: es decir, responde con comentarios, evalúa la calidad del trabajo con el sistema de estrellas, comparte con tus redes sociales, da me gusta, marca el blog como favorito. Son pequeños gestos que ayudan a mantener el trabajo de creación.

Clave pública @pedroruizhidalg.pub.key

#aboutpedroruizhidalgo
[polldaddy poll=9120832]
♻ miotroblogsite ahorra papel
Categories: linux, Tecnología, Tecnologías Tags: Etiquetas: , ,

Linux shell bash básico para principiantes

No Comments
logo bash Bourne again shell

Extracto

@pedroruizhidalg― El shell es un intérprete de órdenes que proporciona una interfaz interactiva orientada a línea entre el usuario y el sistema operativo. Si bien existen varios shells, quizás es más común es Bash. Conocer desde un principio la estructura y posibilidades de este shell hará que adquieras unas habilidades en Linux que te mostrará su auténtica potencia.

Abreviaturas usadas

Bash: Bourne again shell.
EOF: End of file. Fin de fichero.

Descripción

Cuando en Linux abrimos un terminal desde nuestro entorno gráfico, o bien fuera de éste, queda a nuestra disposición una interfaz de linea de órdenes ―comandos― esta consola de linea de texto queda dispuesta para órdenes con sus opciones y argumentos. El el inductor shell es representado por el símbolo dolar como muestro a continuación:

$

Linux instala por defecto el shell bash, cuyo inductor es el símbolo dólar, no obstante cada shell en Linux puede tener su propio inductor. En este manual nos centraremos en Bash.

El shell bash es case sensitive, es decir distingue entre mayúsculas y minúsculas.

Ejecución

Empecemos poco a poco. La primera orden que vamos a introducir es «date», que obtiene la fecha y hora del sistema.

$ date
mié oct 21 14:16:37 CEST 2015
$

Esto muestra la hora y fecha en la que ha sido ejecutada esta orden. Dejando tras su ejecución de nuevo el inductor a la espera del siguiente comando.

Como forma general los comandos Linux tendrán la siguiente estructura:

$ Orden Opciones Argumentos
Opciones y argumentos

Una opción es un código seguido de una letra, o dos guiones seguidos de una palabra o palabras separadas por guiones. El comando ls, sin opciones, visualiza todos los archivos del directorio actual.

$ ls
carta1  carta2  micarta  todaslascartas
$

Con “-l” el comando ls modifica su salida y muestra una linea de información acerca de cada archivo.

$ ls -l
total 0
-rw-rw-r-- 1 pedro pedro 0 oct 21 14:30 carta1
-rw-rw-r-- 1 pedro pedro 0 oct 21 14:30 carta2
-rw-rw-r-- 1 pedro pedro 0 oct 21 14:30 micarta
-rw-rw-r-- 1 pedro pedro 0 oct 21 14:30 todaslascartas
$

Con la opción “a” muestra una lista de todos los archivos que haya en el directorio, incluso aquellos archivos que sean archivos ocultos. Los archivos ocultos llevan un punto al principio de su nombre.

Podemos unir las opciones “l” y “a” así “-l -a” o así “-la”.

$   ls -la
total 8
drwxrwxr-x  2 pedro pedro 4096 oct 21 15:23 .
drwxr-xr-x 94 pedro pedro 4096 oct 21 12:59 ..
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 carta1
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 carta2
-rw-rw-r--  1 pedro pedro    0 oct 21 15:23 carta3
-rw-rw-r--  1 pedro pedro    0 oct 21 15:23 carta4
-rw-rw-r--  1 pedro pedro    0 oct 21 14:34 .cartaoculta
-rw-rw-r--  1 pedro pedro    0 oct 21 15:10 documento.asc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:10 documento.doc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:12 factura.doc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:20 factura.moc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:22 factura.xls
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 micarta
-rw-rw-r--  1 pedro pedro    0 oct 21 15:04 texto2
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 todaslascartas

La mayoría de las órdenes han sido diseñadas para llevar argumentos. Como vimos arriba un argumento es una palabra que se teclea en la linea de órdenes tras las opciones. Veamos cómo se comporta el comando “ls” con las opciones “-la” y el argumento carta1.

$ ls -la carta1
-rw-rw-r-- 1 pedro pedro 0 oct 21 14:30 carta1

En este caso hemos pedido al sistema la restricción de su salida haciendo que únicamente nos muestre el contenido del directorio que coincide con carta1. En este caso carta1 no es un archivo oculto. Hubiera producido el mismo resultado que la orden “ls -l carta1”.

Caracteres comodín y argumentos que son nombres de archivo

Los nombres de archivo son los argumentos más comunes en las órdenes. Es frecuente que sólo sepa ―recuerde― una parte del nombre, o tal vez le interese listar aquellos archivos que coinciden con un patrón determinado. Los caracteres comodín sirven para informar al sistema que la orden que estamos solicitando debe cumplir algunas coincidencias.

Carácter comodín *

Se usa para expresar como variable una parte de la cadena que estamos expresando.

$ ls -la carta*
-rw-rw-r-- 1 pedro pedro 0 oct 21 14:30 carta1
-rw-rw-r-- 1 pedro pedro 0 oct 21 14:30 carta2

En otras palabras lista los archivos contenidos en el directorio cuyo nombre comience por “carta”.

¡Cuidado! determinadas órdenes y los comodines pueden producir una mezcla explosiva. Por ejemplo el comando “rm” sirve para eliminar archivos del directorio en que se está trabajando.

$ rm carta*

Borraría, en este caso, carta1 y carta2.

Seleccionar por extensiones

En Linux las extensiones de los archivos no son necesarias. No lo son para Linux, pero qué duda cabe que para los humanos sí, pues nos permite aislar fácilmente ese tipo de fichero del resto. Podemos usar el carácter comodín asterisco como discriminador por extensión.

$ ls -l *.doc
-rw-rw-r-- 1 pedro pedro 0 oct 21 15:10 documento.doc
-rw-rw-r-- 1 pedro pedro 0 oct 21 15:12 factura.doc

Nos muestra todos los archivos cuya extensión es “doc”.

El carácter comodín ?

Este comodín sirve para hacer coincidir una sola posición variable por cada aparición del carácter “?”. Veamos detenidamente el siguiente ejemplo:

$ ls -l *.?oc
-rw-rw-r-- 1 pedro pedro 0 oct 21 15:10 documento.doc
-rw-rw-r-- 1 pedro pedro 0 oct 21 15:12 factura.doc
-rw-rw-r-- 1 pedro pedro 0 oct 21 15:20 factura.moc
$ ls -l factura.?oc
-rw-rw-r-- 1 pedro pedro 0 oct 21 15:12 factura.doc
-rw-rw-r-- 1 pedro pedro 0 oct 21 15:20 factura.moc
$ ls -l factura.*
-rw-rw-r-- 1 pedro pedro 0 oct 21 15:12 factura.doc
-rw-rw-r-- 1 pedro pedro 0 oct 21 15:20 factura.moc
-rw-rw-r-- 1 pedro pedro 0 oct 21 15:22 factura.xls

En la primera orden solicitamos el listado de todos los archivos, sin importar su nombre, cuya extensión termine en “oc”: coinciden tres, documento.doc, factura.doc, factura.moc.

En la segunda orden pedimos todos los archivos cuyo nombre sea factura y su extensión termine en “oc”, coinciden factura.doc y factura.moc.

En la tercera queremos conocer todos los archivos cuyo nombre sea factura sin importar su extensión.

Caracteres comodín [ ]

Estos caracteres comodín se usan para indicar series. Por ejemplo:

$ ls -l carta[2-4]
-rw-rw-r-- 1 pedro pedro 0 oct 21 14:30 carta2
-rw-rw-r-- 1 pedro pedro 0 oct 21 15:23 carta3
-rw-rw-r-- 1 pedro pedro 0 oct 21 15:23 carta4

Hemos seleccionado los documentos carta que terminan con los caracteres del 2 al 4, ecluyendo el 1. Otro ejemplo: pedimos listar los archivos carta2 y carta3 excluyendo los archivos carta1 y carta4.

 $ ls -l carta[2-3]
-rw-rw-r-- 1 pedro pedro 0 oct 21 14:30 carta2
-rw-rw-r-- 1 pedro pedro 0 oct 21 15:23 carta3
La entrada/salida estándar y redirección

Cuando fue diseñado Unix, se tomó la decisión de considerar la implementación física y la organización lógica de un archivo como cosas independientes. Físicamente se accede a los archivos de Unix como bloques que están dispuestos de forma aleatoria, si bien, lógicamente los archivos están dispuestos son un flujo continuo de bytes. Linux como versión de Unix mantiene la misma organización.

Por tanto cualquier archivo, a excepción de  algunas llamadas especiales al sistema, podrá ser copiado a otro archivo fácilmente. Para Linux no hay ninguna diferencia entre un archivo de caracteres y otro de registros, ni entre un archivo de texto y otro binario.

Esta organización lógica de archivos se extiende a las operaciones de entrada y salida. Los datos son organizados como en un archivo. De tal forma que la entrada para por teclado para Linux es un flujo continuo de datos. Igualmente, la salida estándar ―que es la pantalla― es otro receptor de flujos continuos de datos provenientes del sistema.

Esta característica hace de Linux un sistema en que es muy fácil crear salidas y entradas diferentes.

Redirección de la salida estándar: > y >>

Supongamos que en vez de ver el resultado de un comando por pantalla queremos, para observarlo más tranquilamente,  alterar la salida y crear un fichero con el resultado de un comando.

$ls -la > fichero.dir

$ cat fichero.dir 
total 8
drwxrwxr-x  2 pedro pedro 4096 oct 21 16:41 .
drwxr-xr-x 94 pedro pedro 4096 oct 21 12:59 ..
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 carta1
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 carta2
-rw-rw-r--  1 pedro pedro    0 oct 21 15:23 carta3
-rw-rw-r--  1 pedro pedro    0 oct 21 15:23 carta4
-rw-rw-r--  1 pedro pedro    0 oct 21 14:34 .cartaoculta
-rw-rw-r--  1 pedro pedro    0 oct 21 15:10 documento.asc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:10 documento.doc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:12 factura.doc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:20 factura.moc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:22 factura.xls
-rw-rw-r--  1 pedro pedro    0 oct 21 16:41 fichero.dir
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 micarta
-rw-rw-r--  1 pedro pedro    0 oct 21 15:04 texto2
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 todaslascartas

Con la primera orden efectuamos la redirección de la salida por pantalla hacia un archivo llamado “fichero.dir”. Con la segunda orden “cat” examinamos el contenido de dicho archivo. Como se puede observar se ha creado el archivo que consta con 864 bytes.

$ ls -l fichero.dir 
-rw-rw-r-- 1 pedro pedro 864 oct 21 16:41 fichero.dir

Esto ha sido posible por el operador “>” puesto tras la orden “ls -l”. De igual forma podemos redireccionar la salida por pantalla de un archivo hacia otro archivo. Aunque hay un método más sencillo con el comando “cp” para copiar archivos, vamos a efectuar la una copia del archivo fichero.dir hacia otro archivo llamado copia.dir. Luego consultaremos cuántos archivos tienen la extensión .dir.

$ cat fichero.dir > copia.dir

$ ls -l *.dir
-rw-rw-r-- 1 pedro pedro 864 oct 21 16:52 copia.dir
-rw-rw-r-- 1 pedro pedro 864 oct 21 16:41 fichero.dir

Como se puede observar tanto los archivos copia.dir como fichero.dir tienen 864 bytes y fichero.dir fue creado a las 16:41 y copia.dir a las 16:52 horas.

Adición de la salida estándar: >>

Una vez asimilado el concepto de redirección de la salida, veamos el de adición. Si se repite la salida redirección de la salida estándar el fichero receptor de la salida es borrado y creado de nuevo. Pero tenemos la oportunidad de añadir información sin borrar la anterior. Esto se hace con el operador “>>”. Veamos un ejemplo. Vamos a volver a crear el archivo fichero.dir con el resultado de los archivos del directorio y le añadiremos el calendario del año 2015 con la orden “cal 2015”. Luego comprobaremos que el fichero ha cambiado de hora de creación.

$ ls -l > fichero.dir 

$ cal 2015 >> fichero.dir 

$ cat fichero.dir 
total 4
-rw-rw-r-- 1 pedro pedro   0 oct 21 14:30 carta1
-rw-rw-r-- 1 pedro pedro   0 oct 21 14:30 carta2
-rw-rw-r-- 1 pedro pedro   0 oct 21 15:23 carta3
-rw-rw-r-- 1 pedro pedro   0 oct 21 15:23 carta4
-rw-rw-r-- 1 pedro pedro 864 oct 21 16:52 copia.dir
-rw-rw-r-- 1 pedro pedro   0 oct 21 15:10 documento.asc
-rw-rw-r-- 1 pedro pedro   0 oct 21 15:10 documento.doc
-rw-rw-r-- 1 pedro pedro   0 oct 21 15:12 factura.doc
-rw-rw-r-- 1 pedro pedro   0 oct 21 15:20 factura.moc
-rw-rw-r-- 1 pedro pedro   0 oct 21 15:22 factura.xls
-rw-rw-r-- 1 pedro pedro   0 oct 21 17:01 fichero.dir
-rw-rw-r-- 1 pedro pedro   0 oct 21 14:30 micarta
-rw-rw-r-- 1 pedro pedro   0 oct 21 15:04 texto2
-rw-rw-r-- 1 pedro pedro   0 oct 21 14:30 todaslascartas
                            2015
       Enero                Febrero                Marzo          
do lu ma mi ju vi sá  do lu ma mi ju vi sá  do lu ma mi ju vi sá  
             1  2  3   1  2  3  4  5  6  7   1  2  3  4  5  6  7  
 4  5  6  7  8  9 10   8  9 10 11 12 13 14   8  9 10 11 12 13 14  
11 12 13 14 15 16 17  15 16 17 18 19 20 21  15 16 17 18 19 20 21  
18 19 20 21 22 23 24  22 23 24 25 26 27 28  22 23 24 25 26 27 28  
25 26 27 28 29 30 31                        29 30 31              
                                                                  

       Abril                  Mayo                 Junio          
do lu ma mi ju vi sá  do lu ma mi ju vi sá  do lu ma mi ju vi sá  
          1  2  3  4                  1  2      1  2  3  4  5  6  
 5  6  7  8  9 10 11   3  4  5  6  7  8  9   7  8  9 10 11 12 13  
12 13 14 15 16 17 18  10 11 12 13 14 15 16  14 15 16 17 18 19 20  
19 20 21 22 23 24 25  17 18 19 20 21 22 23  21 22 23 24 25 26 27  
26 27 28 29 30        24 25 26 27 28 29 30  28 29 30              
                      31                                          

       Julio                 Agosto              Septiembre       
do lu ma mi ju vi sá  do lu ma mi ju vi sá  do lu ma mi ju vi sá  
          1  2  3  4                     1         1  2  3  4  5  
 5  6  7  8  9 10 11   2  3  4  5  6  7  8   6  7  8  9 10 11 12  
12 13 14 15 16 17 18   9 10 11 12 13 14 15  13 14 15 16 17 18 19  
19 20 21 22 23 24 25  16 17 18 19 20 21 22  20 21 22 23 24 25 26  
26 27 28 29 30 31     23 24 25 26 27 28 29  27 28 29 30           
                      30 31                                       

      Octubre              Noviembre             Diciembre        
do lu ma mi ju vi sá  do lu ma mi ju vi sá  do lu ma mi ju vi sá  
             1  2  3   1  2  3  4  5  6  7         1  2  3  4  5  
 4  5  6  7  8  9 10   8  9 10 11 12 13 14   6  7  8  9 10 11 12  
11 12 13 14 15 16 17  15 16 17 18 19 20 21  13 14 15 16 17 18 19  
18 19 20 21 22 23 24  22 23 24 25 26 27 28  20 21 22 23 24 25 26  
25 26 27 28 29 30 31  29 30                 27 28 29 30 31        
                                                                  
$ ls -l fichero.dir 
-rw-rw-r-- 1 pedro pedro 2936 oct 21 17:01 fichero.dir

La primera orden ha rehecho el archivo fichero.dir nuevamente con el listado de archivos. La segunda añade a archivo.dir el resultado de la orden “cal 2015” sin borrar, es decir añadiendo, los datos. La tercera orden muestra el contenido de archivo.dir con ambos resultados y en la cuarta orden podemos observar que fichero.dir ahora tiene 2936 bytes y ha sido creado a las 17:01 horas.

La entrada estándar

Muchas órdenes de Linux reciben los datos de la entrada estándar. Esa es la situación normal. La entrada estándar es el teclado. La entrada estándar como flujo de datos son introducidos por el teclado y dirigidos a la orden Linux. La orden “cat” sin argumento de nombre de archivo lee la entrada estándar y la redirige a la salida estándar ―pantalla―.

Antes de realizar el siguiente ejercicio tenemos que aprender que para todo linux la señal de fin de fichero (EOF) se realiza desde el teclado con “control-d” o “^D”.

$ cat 
estoy creando
estoy creando
una salida 
una salida 
desde la entrada estandar
desde la entrada estandar
^D
$

Como vemos lo que hace el comando cat sin argumentos es copiar lo que hemos tecleado desde la entrada estándar. Cuando pulsamos “control-d” acabamos la entrada y termina el proceso cat.

Vamos ahora a usar cat como recetor de un archivo. Es decir redireccionamos la entrada a cat desde el archivo copia.dir

$ cat < copia.dir 
total 8
drwxrwxr-x  2 pedro pedro 4096 oct 21 16:41 .
drwxr-xr-x 94 pedro pedro 4096 oct 21 12:59 ..
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 carta1
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 carta2
-rw-rw-r--  1 pedro pedro    0 oct 21 15:23 carta3
-rw-rw-r--  1 pedro pedro    0 oct 21 15:23 carta4
-rw-rw-r--  1 pedro pedro    0 oct 21 14:34 .cartaoculta
-rw-rw-r--  1 pedro pedro    0 oct 21 15:10 documento.asc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:10 documento.doc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:12 factura.doc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:20 factura.moc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:22 factura.xls
-rw-rw-r--  1 pedro pedro    0 oct 21 16:41 fichero.dir
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 micarta
-rw-rw-r--  1 pedro pedro    0 oct 21 15:04 texto2
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 todaslascartas

Vemos cómo hemos usado cat haciendo que la entrada fuera procedente del contenido del archivo copia.dir.

Se puede combinar las operaciones de redirección de la entrada como la salida estándares. En el siguiente ejemplo la orden cat no tiene argumentos de nombres de archivo. Sin argumentos toma la entrada desde el archivo copia.dir y redirecciona la salida a otracopia.dir.

$ cat < copia.dir > otracopia.dir
$ cat otracopia.dir 
total 8
drwxrwxr-x  2 pedro pedro 4096 oct 21 16:41 .
drwxr-xr-x 94 pedro pedro 4096 oct 21 12:59 ..
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 carta1
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 carta2
-rw-rw-r--  1 pedro pedro    0 oct 21 15:23 carta3
-rw-rw-r--  1 pedro pedro    0 oct 21 15:23 carta4
-rw-rw-r--  1 pedro pedro    0 oct 21 14:34 .cartaoculta
-rw-rw-r--  1 pedro pedro    0 oct 21 15:10 documento.asc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:10 documento.doc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:12 factura.doc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:20 factura.moc
-rw-rw-r--  1 pedro pedro    0 oct 21 15:22 factura.xls
-rw-rw-r--  1 pedro pedro    0 oct 21 16:41 fichero.dir
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 micarta
-rw-rw-r--  1 pedro pedro    0 oct 21 15:04 texto2
-rw-rw-r--  1 pedro pedro    0 oct 21 14:30 todaslascartas

Mostrando a la vez el contenido de copia.dir y creando otro archivo llamado otracopia.dir.

Canalizaciones: |

Hay muchísimas ocasiones en las que se necesita enviar el resultado de una orden hacia otra orden. En otras palabras, se envía la salida estándar de una orden a la entrada de otra y no a un archivo. La canalización lpr se usa para enviar datos a la impresora.

$ ls -la | lpr

Hacemos que la salida estándar de ls -la la tome como entrada la orden lpr, como resultado esto llegará a la impresora.

Enviar un archivo a la impresora con cat -n imprimirá el archivo con el número de cada una de las líneas.

$ cat -n fichero.dir | lpr
Las canalización a more

Es una operación muy común canalizar el resultado de ls a la orden more ya que si el resultado prevemos que el resultado del listado de directorios sea demasiado grande, no nos dará tiempo a leerlo. El recurso ls -la | more, entrega al comando more el resultado de la orden ls, lo que permitirá que se detenga el listado hasta que llegue al final de la pantalla y esperará a que pulsemos la barra espaciadora para presentarnos otra página completa o intro para avanzar una sola linea.

$ ls -l /usr/bin | more

Presiona “q”, escape o “control-c” para salir.

Una canalización un poco más compleja. Usamos la orden sort para clasificar el contenido de un fichero dado, llamaremos a este fichero milista, la calalización de la salida estándar de sort se la entregamos a cat -n para que numere las líneas clasificadas, y esto lo canalizamos a la impresora. Así:

$ sort milista | cat -n | lpr

Otra canalización frecuente, se realiza con el comando tee, que se encarga de recoger la salida estandard y dirigirla al fichero especificado en tiempo real ―quiero decir conforme se efectúa la salida estándar―, en otras palabras, gravo en un fichero todo lo que sale por pantalla.

$ cat milista | tee nuevalista
Redirección y canalización del error estándar: >&, 2>

Observemos la siguiente secuencia de órdenes. Luego las explicaré.

$ cat ficheronoexiste
cat: ficheronoexiste: No existe el archivo o el directorio

$ cat ficheronoexiste > ficheronoexiste.err
cat: ficheronoexiste: No existe el archivo o el directorio

$ cat ficheronoexiste.err 

$ cat ficheronoexiste 2> ficheronoexiste.err

$ cat ficheronoexiste.err 
cat: ficheronoexiste: No existe el archivo o el directorio

En la primera orden intento obtener la salida estándar de ficheroquenoexiste ―de hecho no existe :-)― por eso Linux contesta indicándolo.

En la segunda de orden redirijo el flujo de la salida al fichero ficheronoexiste.err, que como vemos en este caso se crea, pero vacío, no contiene nada, porque nada produjo la orden cat.

En la tercera redirigimos el error con los caracteres “2> “ hacia fichernoexiste.err, en esta ocasión se crea con el contenido de la salida de errores producida por la orden cat.

No obstante si deseamos guardar los mensajes de error en el mismo archivo que use para la salida estándar, se necesita redireccionar el error estándar a la salida estándar. Es un poco lioso, lo vemos y lo explico.

$ cat fichernoexiste 1> otrofichero.err 2>&1

$ cat otrofichero.err 
cat: fichernoexiste: No existe el archivo o el directorio

La primera redirección la efectúo a otrofichero.err, la segunda redirección de error la devuelvo a &1, que es otra vez la salida estándar. Pero podemos simplificarlo:

Redirección de todo error a la salida estándar:

$ cat fichernoexiste >& ficheronoexiste.err
linux shell bash

linux shell bash

Epílogo

Esto sólo un compendio de lo que puede hacerse con bash. En el proyecto Lucas Bash podéis ampliar más. En una siguiente entrega describiré las variables en Bash.

Espero y deseo que este artículo haya sido de utilidad. Es muy importante para la continuación de trabajos de calidad recibir algún tipo de feedback por parte de los lectores: es decir, responde con comentarios, evalúa la calidad del trabajo con el sistema de estrellas, comparte con tus redes sociales, da me gusta, marca el blog como favorito. Son pequeños gestos que ayudan a mantener el trabajo de creación.

Clave pública @pedroruizhidalg.pub.key

#aboutpedroruizhidalgo
[aquí la encuesta]
♻ miotroblogsite ahorra papel
Categories: linux, Tecnología, Tecnologías Tags: Etiquetas:

data mining: técnicas y procedimientos

No Comments
técnicas de data mining

@pedroruizhidalg― A principios de 2002, el director del FBI, John Aschcroft, anunciaba que el Departamento de Justicia comenzaría a analizar las bases de datos comerciales referentes a los hábitos de consumo y preferencias de compra de los consumidores estadounidenses. Expertos aseguran que la intención del FBI es aunar toda la información que dispongan en una mega base de datos con el fin de poder hacer el seguimiento ―en USA es casi sospechoso pagar con efectivo repetidas veces, siempre lo hacen con tarjeta― del reguero de información que vamos dejando en nuestro día a día.

Permitidme ilustrarlo con un ejemplo. Fulano de Tal se levanta un sábado y mira su Facebook, contesta a lo que le ha llamado la atención. Consulta su cuenta de Twitter y retuitea la cosa tan graciosa que ha visto. Luego mira su email. Tras esto desayuna, se ducha y se va en moto hacia una gasolinera para poner 10€ de carburante. Va a unos grandes almacenes, en la búsqueda mira una gorra, la fotografía y la envía a su novia a ver qué le parece; se compra un pantalón vaquero y una camiseta para la playa. En la esquina de siempre, le espera su novia, con la que van a tomar algo a un bar de moda. Fotografían ambos la tapa, la mandan a sus redes sociales, algunos amigos contestan con un «like» otros retwitean. Aquí paramos el ejemplo. Ahora vamos a verlo desde el punto de vista de las redes sociales y quien tenga acceso a ellas.

Cuando accedemos a una de nuestras redes sociales, se graba todo, se graba, por ejemplo, si accedemos con móvil, tablet u ordenador de sobremesa, la hora y el lugar desde el que accedemos, el sistema operativo que usamos, el tipo de navegador, el ancho de nuestra página, la última página que hemos visitado, y, desde luego, nuestra IP, por tanto, también se está grabando si accedemos desde wifi o por conexión directa 3 ó 4G. Así que puede reconstruirse la historia que antes he descrito desde la siguiente óptica:

Nuestro protagonista se conecta el sábado a las 8:35 desde una ubicación determinada ―su casa― accedió mediante la aplicación de Facebook que tenía en el móvil, contestó a su amigo de la primo ―nosotros somos quienes describimos las relaciones en facebook― algo relacionado con Messi ―sí, esto también es catalogado, pues es muy importante para los gurús del márketing―, en Twitter se hace eco del chiste del presidente de gobierno ―ya conocemos su tendencia política―, conocemos quienes le han escrito a su cuenta de Google y cuál ha sido su reacción ante ese mail. Ha puesto 10€ de gasolina 98 a las 9:43 ―llegado el caso la gasolinera tiene cámaras― y lo ha pagado con la tarjeta de crédito de su banco número tal. No ha ido al centro comercial por el camino más corto, lo sabemos por el GPS de su móvil, aparca en la puerta de un bar. Usa la talla XXL de camiseta y de pantalón la XL en lo que ha invertido 44.54€ en total, pero con su tarjeta de crédito ―que caduca el próximo enero― lo pagará el mes que viene. En la puerta del bar donde tiene aparcada la moto, se encuentra con su novia a las 11:17 horas, y tomaron unas patatas bravas con cerveza ―ellos mismos lo tuitearon― a su amigo, Fran ―el de Huelva― le gusta la foto de las patatas bravas.

Y así… podíamos seguir hasta obtener un perfil completo de ese Don Nadie, que si bien no nos aporta nada especial, sí que unido al ejército de «donnadies» que, es verdad, llevan vidas grises aburridas y previsibles, sí podemos coleccionar todos esos datos porque a las empresas de márketing les interesa muchísimo.

Clave pública @pedroruizhidalg.pub.key
#aboutpedroruizhidalgo
[polldaddy poll=9120832]
♻ miotroblogsite ahorra papel

manual de gpg (PGP)

No Comments

Extracto

@pedroruizhidalg― PGP,  fue considerada por el gobierno de Estados Unidos como el mayor de los secretos. Tan secreto como el código de lanzamiento de los misiles nucleares. En buena medida, los códigos de los misiles dependían del código PGP. Un día, alguien publicó este código en una web. Aunque hubieron sospechosos no se pudo determinar quien era el «culpable».  La historia es apasionante, y algo farragosa. GPG es un sistema multiplataforma de gestión de llaves utilizado para el cifrado y firma digital de mensajes y archivos. Es un software libre liberado bajo la licencia GPL e implementa el estándar OpenPGP. GPG puede comunicarse con la versión actual de PGP y con cualquier otro sistema que implemente el estándar OpenPGP. GPG es un software híbrido de cifrado que combina tanto criptografía simétrica o de clave privada y criptografía asimétrica o de clave pública.

Nomenclatura y abreviaturas usadas

Criptografía simétrica.
Criptografía asimétrica.
RSA: En criptografía, RSA (Rivest, Shamir y Adleman) es un sistema criptográfico de clave pública desarrollado en 1977. Es el primer y más utilizado algoritmo de este tipo y es válido tanto para cifrar como para firmar digitalmente.
GPG: GnuPG.

Descripción

GPG es un sistema de criptografía de clave pública. Su código es libre, abierto y gratuito. Es multiplataforma, puede ser instalado en Linux, Windows y otros sistemas. De facto viene instalado en la mayoría de las distribuciones Linux. La instalación, si fuera necesario, en ubuntu sería así:

$ sudo apt-get install gnupg
$ gpg < /dev/null

Esta última línea dará un error. Gracias a la ejecución con ese error se han creado los directorios y los archivos de configuración necesarios. Continuamos con la instalación:

$ cp /usr/share/gnupg/options.skel ~/.gnupg/gpg.conf
$ gedit ~/.gnupg/gpg.conf &

Esto debería abrir el archivo de configuración de nuestro usuario. Buscamos la línea keyserver-options auto-key-retrieve y eliminamos el símbolo «#» que debe tener a la izquierda. Si no lo tuviera lo dejamos tal cual. Guardamos y salimos.

Creación de la pareja de claves
$ gpg --gen-key
gpg (GnuPG) 1.4.16; Copyright (C) 2013 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

Por favor seleccione tipo de clave deseado:
 (1) RSA y RSA (predeterminado)
 (2) DSA y Elgamal
 (3) DSA (sólo firmar)
 (4) RSA (sólo firmar)
¿Su selección?: 

Si nuestra intención es tan solo firmar, cualquiera de las opciones nos sirve. Si, como es lógico, ademas, queremos cifrar mensajes de forma que únicamente el receptor pueda descifrarlo y trabajar con el contenido que le enviamos, recomiendo la opción 1.

DSA keypair will have 1024 bits.
ELG-E keys may be between 1024 and 4096 bits long.
What keysize do you want? (2048)
Requested keysize is 2048 bits

Una clave de 1024 es considerada como débil. 4096 puede ser lento. Mi clave personal es de 2048. Seguidamente nos reguntará acerca de la caducidad de la clave.

Please specify how long the key should be valid.
0 = key does not expire
<n> = key expires in n days
<n>w = key expires in n weeks
<n>m = key expires in n months
<n>y = key expires in n years
Key is valid for? (0)
Key does not expire at all
Is this correct? (y/N) y

Supongamos que se usa la clave para enviar trabajos de un curso que terminará en un año, nuestra respuesta sería 1y. 0 para que la clave no expire jamás.

Tras esto nos pedirá algunos datos personales. Es importante dar los correctos, ya que como veremos más adelante, nuestra clave terminará en servidores de claves a nivel mundial. Si nuestra clave no nos representa, simplemente no es confiable. En Linux, generalmente no vas a tener problemas. Si trabajas en Windows te recomiendo no usar acentos tanto en el nombre como en el resto de la información que suministres. Cuando suministres la información el programa te insta a que lo revises cuidadosamente. Así:

You need a user ID to identify your key; the software constructs the user ID
from the Real Name, Comment and Email Address in this form:
"Fulano De Tal (Mi empresa) <fulanodetal@miempresa.com>"
Real name: Fulano De Tal
Email address: fulanodetal@miempresa.com
Comment:
You selected this USER-ID:
"Fulano De Tal <fulanodetal@miempresa.com>"
Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? o

Podemos encontrar que en vez de pedir (O)kay pide (V)ale.

You need a Passphrase to protect your secret key.
Enter passphrase:
Repeat passphrase:

Si estamos trabajando desde un terminal gráfico, vuestro sistema os podría solicitar la contraseña en una ventana emergente. En cualquier caso, suministrar una contraseña que sea segura, que contenga números y símbolos, que no sea una palabra del diccionario, una fecha de nacimiento, o una matrícula. Esta palabra de paso es tu única defensa ante los posibles usos inadecuados. De ahí la importancia de que sea segura.

Ahora viene la parte que me gusta, GPG te invita a que hagas cosas con las ventanas, con el ratón con los discos duros, que abras carpetas, que mires fotos, compiles programas y cosas así. Es porque está calculando números aleatorios con nuestros procesos. Pudiera darse el caso que tengas que volver a repetir ver carpetas porque le falten datos aleatorios, tú simplemente sigue las instrucciones. Un comando que crea bastante entropía es:

$ ls / -laR

Ábrelo en otro terminal. Finalmente:

gpg: key E0CABB25 marked as ultimately trusted
public and secret key created and signed.
gpg: checking the trustdb
gpg: 3 marginal(s) needed, 1 complete(s) needed, PGP trust model
gpg: depth: 0 valid:
2 signed:
0 trust: 0-, 0q, 0n, 0m, 0f, 2u
pub
1024D/E0CBB25 2005-12-22
Key fingerprint = CEDB 1451 1F26 83D9 DB69 7ADA FFEE 1F18 E0CA 9E25
uid
Fulano De Tal <fulanodetal@miempresa.com>
sub
2048g/88885614 2016-12-31

Aquí es importante el número de usuario: E0CBB25, que es tu identidad en el anillo de claves. No te preocupes, siempre puedes volver a recuperarlo. No obstante también puedes usar como identidad tu correo o tu nombre.

¡IMPORTANTÍSIMO: Creación del certificado de revocación!

Seguidamente debes crear un certificado de revocación. Ya que en caso de que tus claves se vieran comprometidas, o tu contraseña averiguada (violada), debes tener las herramientas suficientes para revocar tus claves, tanto en tu propio ordenador con en los servidores de claves mundiales.

$ gpg --gen-revoke -armor --output revoke.key.asc E0CBB25

otra forma sería:

$ gpg --gen-revoke -armor --output revoke.key.asc fulanodetal@miempresa.com

y otra:

$ gpg --gen-revoke -armor --output revoke.key.asc 'Fulano de Tal'

Como resultado obtendrás un archivo llamado revoke.key.asc. La extensión asc es para indicarnos que la revocación la hemos creado en ascii y eso es debido a que hemos incluido en el comando el argumento –armor. Sin ese argumento la clave de revocación sería en formato binario, lo que nos supondría un problema para revocar mediante Internet, en caso de que nuestra clave esté en un servidor público.

Ya tenemos creada nuestro par de claves con el certificado de revocación.

Ejecución

La primera acción a realizar sería proteger nuestro certificado de revocación. Como nunca sabemos en qué circunstancias vamos a tener que realizar la revocación, si desde nuestro ordenador, desde otro, con nuestro sistema operativo, con Windows… en fin, hablamos de una circunstancia futura. Vamos a crear un archivo zip al que vamos luego cifraremos de forma simétrica.

$ zip revoke.zip revoke.key.asc
$ gpg -c revoke.zip

Desgraciadamente, el cifrado simétrico es el más débil de los cifrados, se trata de un archivo con una clave. Quien sepa la contraseña tendrá acceso al contenido. Esto lo realizamos para guardar el archivo en un dispositivo seguro, un cd, un dvd, un pen drive… Algo al que no tenga acceso nadie.

Ahora debemos borrar nuestro archivo revoke.key.asc de forma cuidadosa. Ya que un simple borrado no nos garantiza la eliminación del contenido del archivo en disco. Tan solo, lo elimina de los índices, si bien la información sigue ―o puede seguir― estando ahí.

Difusión de la clave pública

Vamos a crear un archivo en ascii para la difusión de la clave pública. Mediante el siguente comando.

$ gpg -a --export --output mi.pkey.asc fulanodetal@miempresa.com

o bien listando las claves que existen en nuestro sistema y eligiendo el id de usuario. Así:

$ gpg --list-keys
$ gpg -a --export --output mi.pkey.asc E0CBB25

El archivo mi.pkey.asc es nuestra clave. Obviamente el nombre es arbitrario, puedes elegir otro que te guste o se adecúe mejor a tus nemotécnicos.

Ahora tenemos varias opciones:

  • Copiar el archivo en un CD para entregar en mano a nuestros contactos.
  • Enviar nuestro archivo como adjunto a nuestros contactos como adjunto en emails.
  • Publicar en nuestra web nuestra clave pública. Mira la mía.
  • Enviar la clave a un servidor de claves.
    • Yo uso pgp.rediris.es. Redirige a http://www.rediris.es/keyserver/
    • Si en la cadena de búsqueda introducís mi nombre ‘Pedro Ruiz Hidalgo’ aparecen dos entradas. Ambas son mías. La que corresponde a 6-9-2003 ya no me pertenece porque perdí la clave de revocación. Eso estará ahí por los siglos de los siglos.
    • El servidor de rediris, igual que otros, comunica todas las identidades a otros servidores. De esta forma es fácil identificarnos para poder enviarnos mensajes cifrados.
    • Podemos crear nuestra identidad copiando la totalidad de nuestro archivo de clave pública y enviarlo desde web. Otra forma sería así:
$ gpg --keyserver pgp.mit.edu --send-keys E0CABB25
gpg: sending key E0CABB25 to hkp server pgp.mit.edu

La mayoría de los servidores de claves están conectados entre sí. Siempre puedes revocar la clave con el certificado de revocación. Si lo perdieras, la clave deja de pertenecerte. Así de crudo.

Importar la clave de pública de un amigo a nuestro anillo de claves

Supongamos que Silvia me envía un certificado. La voy a incluir en mi anillo de claves, pero como no la conozco en persona no firmaré su clave.

$ gpg --import silvia.pkey.asc
gpg: key E02BF32C: public key "Silvia Pérez <silvia.perez@empresadesilvia.com>" imported
gpg: Total number processed: 1
gpg:
imported: 1

En todo esto hay un punto débil. Que sería fabricar una clave con una identidad falsa y hacerla circular. De forma que os recomiendo que hagáis un uso muy paranóico de la seguridad de las claves.

La huella digital

Cuando importemos el certificado, antes darle carta de credibilidad, usamos la huella digital. Esta huella digital es fácil ser leída por teléfono ―siempre que la llamada la efectuémos nosotros―, entregada en mano, o por cualquier «canal seguro» que no nos dé absoluta confianza.

Listar una huella digital:

$ pgp --fingerprint 'Silvia'
pub   2048R/E02BF32C 2015-10-17
      Huella de clave = AC9E F5FD 1888 5BDE 0C6A  CAB· CE69 CDEF 20BA 9950
uid                  Silvia (Para propósitos de encriptación del sistema) <silvia.perez@laempresade silvia.com>
sub   2048R/E02BF32C 2015-10-17

Si la huella de la clave, transmitida por un «canal seguro» es correcta (AC9E F5FD 1888 5BDE 0C6A CAB· CE69 CDEF 20BA 9950) podemos firmar la clave de Silvia. Así:

$ gpg --sing-key silvia.perez@laempresadesilvia.com

O bien con su ID de usuario. GPG nos mostrará en pantalla información de Silvia, si estamos seguros pulsamos “sí”, no obstante, aún gpg duda de que quien esté tratando de firmar la clave sea realmente el usuario de así que pedirá la palabra de paso de quien está firmando. A partir de este momento la clave de Silvia queda unida a la mía, y, si yo envío mi clave pública estaré también enviando la de Silvia.

Firmar un documento
$ gpg --sign midocumento.doc

Pedirá la clave del usuario. Esto genera un documento llamado “midocumento.doc.gpg”. Este archivo .gpg  podemos entregarlo. Para comprobar la firma:

$ pgp midocumento.doc.gpg
gpg: Signature made vie 23 feb 2015 19:00:43 CET using DSA key ID E0CAFE95
gpg: Good signature from "Fulano de tal <fulanodetal@miempresa.com>"

Tras la comprobación de la firma tenemos otra vez los dos documentos. El original y el firmado pues gpg lo ha separado.

Cifrado para un destinatario en concreto

Expresamos en el recipiente “-r” la identidad del destinatario, bien mediante su Id. de usuario, su correo o simplemente su nombre. Si quiero encriptar un documento para que sea leído exclusivamente por Silvia:

$ gpg --encript -r Silvia documento.doc
Cifrado para varios destinatarios determinados

Ahora, además de cifrar para Silvia, voy a hacer que Antonio tenga también una copia de ese documento cifrado, pues se lo enviaré a ambos por correo. Así:

$ gpg --encrypt -r Silvia -r Antonio [-r otro] documento.doc

Epílogo

Estas son las operaciones básicas con gpg (PGP). Incluyo un buen manual de José Luis Díaz, GnuPG, realizado en 2006.

Espero y deseo que este artículo haya sido de utilidad. Es muy importante para la continuación de trabajos de calidad recibir algún tipo de feedback por parte de los lectores: es decir, responde con comentarios, evalúa la calidad del trabajo con el sistema de estrellas, comparte con tus redes sociales, da me gusta, marca el blog como favorito. Son pequeños gestos que ayudan a mantener el trabajo de creación.

Clave pública: @pedroruizhidalg.pub.key

#aboutpedroruizhidalgo
[polldaddy poll=9120832]
♻ miotroblogsite ahorra papel