viernes, 17 de octubre de 2014

[Shell] Reloj binario en C

Esta ocasión crearemos un reloj binario en C,en el entorno de escritorio KDE,contamos con un reloj binario como applet,me imagine como programar uno y mas adelante colocare el código.

En primer lugar debemos saber como leerlo,en esta ocasión el reloj se basa en cuatro bits,representados por 1 y 0 como realmente se hace,para el bit activo usamos 1 y para el bit apagado usamos 0,el reloj esta representado en formato de 24 horas y cada hora es un Byte de 4 bits un nibble.

Veamos la notación,por ejemplo las 5 de la tarde es 17 en formato de 24 horas,ahora vamos a dividir los números de uno en uno y nos queda 1 y 7,representados en binario son:

1 = 0001
7 = 0111

Bien la lectura binaria la podemos traducir asi de la forma mas fácil,imaginemos que los numero de arriba corresponden a una potencia de 2,comensando por el 1 y luego el 2 mismo,en nuestro caso cuatro bits:

8 4 2 1

Ahora abajo de esos numero colocamos el 0 o 1 que estén activados para que la suma de el numero en notación decimal,por ejemplo 1 y 7:

bits : 8   4   2   1

1  =   0   0   0   1
7  =   0   1   1   1

Bien ahora sumamos los bits que están activos:

1 = 0+0+0+1 = 1 en decimal

7 = 0+4+2+1 = 7 en decimal

Bien eso es todo ahora si el código,el código cuenta con 6 numero en notación binaria,2 para la hora 2 para los minutos y dos para los segundos:

El código se basa en programación funcional  y llamamos las funciones una a una en el main.



1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
#include <stdio.h>
#include <time.h>
#include <string.h>
#include <stdlib.h>

/*
 * Archivo : relojbinario.c
 * Compila : gcc -o relojbinario relojbinario.c
 */


#define BUF_TIME 60
#define BITS 4

typedef enum {
    ZERO = 0x30,
    UNO,
    DOS,
    TRES,
    CUATRO,
    CINCO,
    SEIS,
    SIETE,
    OCHO,
    NUEVE
} Hora;

typedef struct _f_hora {
    int hora_decena[BITS];
    int hora_unidad[BITS];
    int minuto_decena[BITS];
    int minuto_unidad[BITS];
    int segundo_decena[BITS];
    int segundo_unidad[BITS];
} f_hora;

char formato[] = "%k%M%S";
char fecha[BUF_TIME];
void create_clock();
void create_num(char num,f_hora *hora,int i);
void destroy_Binary(f_hora *hora);
void create_binary(f_hora *hora);
void show_clock(f_hora hora);

int main()
{
    f_hora hora;
    create_clock();
    create_binary(&hora);
    show_clock(hora);
    return 0;
}

void create_clock()
{
    struct tm *tiempo;
    time_t ahora = time(0);
    tiempo = localtime(&ahora);
    strftime(fecha,BUF_TIME,formato,tiempo);
}

void create_binary(f_hora *hora)
{
    int len = strlen(fecha),i;
    if (len == 0)
        exit(1);
    for (i = 0;i< len;i++)
        create_num(fecha[i],hora,i);
}

void create_num(char num,f_hora *hora,int iter)
{
    int aux[BITS],i;
    switch((int)num)
    {
        case ZERO:
            aux[0] = 0;
            aux[1] = 0;
            aux[2] = 0;
            aux[3] = 0;
            break;
        case UNO:
            aux[0] = 0;
            aux[1] = 0;
            aux[2] = 0;
            aux[3] = 1;
            break;
        case DOS:
            aux[0] = 0;
            aux[1] = 0;
            aux[2] = 1;
            aux[3] = 0;
            break;
        case TRES:
            aux[0] = 0;
            aux[1] = 0;
            aux[2] = 1;
            aux[3] = 1;
            break;
        case CUATRO:
            aux[0] = 0;
            aux[1] = 1;
            aux[2] = 0;
            aux[3] = 0;
            break;
        case CINCO:
            aux[0] = 0;
            aux[1] = 1;
            aux[2] = 0;
            aux[3] = 1;
            break;
        case SEIS:
            aux[0] = 0;
            aux[1] = 1;
            aux[2] = 1;
            aux[3] = 0;
            break;
        case SIETE:
            aux[0] = 0;
            aux[1] = 1;
            aux[2] = 1;
            aux[3] = 1;
            break;
        case OCHO:
            aux[0] = 1;
            aux[1] = 0;
            aux[2] = 0;
            aux[3] = 0;
            break;
        case NUEVE:
            aux[0] = 1;
            aux[1] = 0;
            aux[2] = 0;
            aux[3] = 1;
            break;
        default:
            break;
    }
    for (i=0;i<BITS;i++)
    {
        if (iter == 0)
        {
            hora->hora_decena[i] = aux[i];
        }
        else if (iter == 1)
        {
            hora->hora_unidad[i] = aux[i];
        }
        else if (iter == 2)
        {
            hora->minuto_decena[i] = aux[i];
        }
        else if (iter == 3)
        {
            hora->minuto_unidad[i] = aux[i];
        }
        else if (iter == 4)
        {
            hora->segundo_decena[i] = aux[i];
        }
        else
        {
            hora->segundo_unidad[i] = aux[i];
        }
    }
}

void show_clock(f_hora hora)
{
    int i;
    for (i=0;i<BITS;i++)
    {
        printf("\t%d\t",hora.hora_decena[i]);
        printf("\t%d\t",hora.hora_unidad[i]);
        printf("\t%d\t",hora.minuto_decena[i]);
        printf("\t%d\t",hora.minuto_unidad[i]);
        printf("\t%d\t",hora.segundo_decena[i]);
        printf("\t%d\t",hora.segundo_unidad[i]);
        puts("");
    }
}


Para compilar usamos:

gcc -o relojbinario relojbinario.c

Y si lo ejecutamos en linux podemos llamarlo así,para ver como se ejecuta cada segundo:




while [ 1 ];do sleep 1; clear; ./relojbinario; done


-->
Leer más...

jueves, 31 de julio de 2014

Buscar archivos encriptados con gpg en Linux

Veamos como encontrar archivos que estén encriptados con GPG usando la herramienta find,esto nos sirve para encontrar archivos previamente encriptados por si posterior mente queremos o intentaremos abrirlos:


Solo abrimos una terminal y ejecutamos:

find ./ -exec file {} \; | grep 'GPG\|PGP'


Esto funciona para cifrado simétrico como el que vimos en la entrada pasada.

Eso es todo :D

Leer más...

Como encriptar carpetas en Linux con GPG

En esta ocasión vamos a aprender como encriptar una carpeta en Linux,en mi caso Ubuntu 14.04 pero lo podemos hacer con cualquier distribucion de Linux,solo necesitamos tener instalada la herramienta GnuPG que quiere decir : GNU Privacy Guard.

Bien en muchos sistemas con Linux ya biene instalado pero en otros no asi que lo verificamos:

Abrimos una terminal y escribimos:

 which gpg; if [[ $? -eq 0 ]]; then echo "Instalado"; else echo "No instalado"; fi

 Si no lo tenemos instalado buscamos como instalarlo para nuestra distribución de Linux,de hecho el programa que vamos a usar es gpg-zip,que se instala junto a gpg,en sistemas como Gentoo no se si se instale por las flags usadas al compilar asi que revisar bien a la hora de instalar.

Tutorial


Vamos a ver un ejemplo,tengo un codigo en C importante:


Ahora voy a encriptar esa carpeta,en mi caso estoy usando Dolphin en mi caso este explorador de archivos cuenta con una Terminal empotrada,asi que solo la abro:



En otro caso abren una terminal y van al destino donde tienen la carpeta a encriptar:

Bien ahora encriptamos,nosotros vamos a usar una frase para volver a desencriptar(cifrado simétrico) este usa CAST5, esa opcion la llamamos con el parametro -c:

El programa,así vamos hasta el momento:

gpg-zip -c 
Ahora solo debemos mostrar el nombre de salida,al igual que otros programas usamos el parametro -o,asi:

-o salida.gpg
Y por ultimo el nombre de la carpeta,en mi caso prueba,asi queda la linea entera:

gpg-zip -c -o salida.gpg prueba
Al ejecutar esto nos pide una contraseña en GUI:


La escribimos y la reafirmamos y con eso nos crea el fichero cifrado:



Con esto podemos borrar la carpeta original,y podemos ver que es fichero cifrado:


Ahora como lo desencriptamos, con el parametro -d seguido del nombre del gpg,en este caso:

 gpg-zip -d salida.gpg
Nos pide la contraseña y vuelve a "crear" el directorio,eso es todo en este caso usamos un cifrado muy común ya que solo usamos contraseña y tar lo que seria como un comprimido con contraseña(no es asi),pero gpg va mas haya con cifrado asimétrico,firmas,etc.

Aqui un script para realizar lo que vimos en esta entrada de una manera facil:

Solo usamos,para desencriptar:

Nombre_script.sh -d nombre.gpg

Para encriptar:

Nombre_script.sh -e carpeta
No cancelar en fase de encriptacion,que borra el folder y no deja respaldo gpg.

1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
#!/bin/bash

function decripta()
{
    echo "Desencriptando $1"
    gpg-zip -d $1
    if [[ $! -eq 0 ]];
    then
        echo "Hecho"
    else
        echo "Algo salio mal :("
        exit
    fi
    rm $1
}

function encripta()
{
    echo "Encriptando $1"
    gpg-zip -c -o $1.gpg $1
    if [[ $! -eq 0 ]];
    then
        echo "Hecho"
    else
        echo "Algo salio mal :("
        exit
    fi
    rm -rf $1
}

function help()
{
    echo "Uso : $0 [-e] Encriptar
                   [-d] Desencriptar
                                     Archivo"

}

case $1 in
    -e)
        if [[ $2 == '' ]];
        then
            help;
        else
            encripta $2
        fi
    ;;
    -d)
        if [[ $2 == '' ]];
        then
            help;
        else
            decripta $2
        fi
    ;;
    '')
        help
    ;;
esac

Eso es todo :D
Leer más...

jueves, 10 de julio de 2014

Eliminar Pelota que Rebota en KDE imposible

Este tutorial es para poder eliminar el elemento de la pelota roja en el escritorio de KDE,esta pelota esta bien si queremos darle un toque colorido al escritorio,pero lo feo comienza si la configuramos así:


Con rebote automático y con mucha fuerza de rebote,y ni hablar si la encogemos a un tamaño muy pequeño.

Su eliminación es casi imposible y no solo eso,crea un loop que consume mucho cpu :O

Bien para eliminarla vamos a hacerlo desde la consola Konsole,la abrimos y escribimos:

Antes que nada cerramos lo mas importante que estemos haciendo por si algo sale mal:

Eliminamos el escritorio:

kquitapp plasma-desktop

Editamos la configuración:

Con nuestro editor de texto favorito,por ejemplo vim(desde la misma terminal):

vim ~/.kde/share/config/plasma-desktop-appletsrc

O desde un programa gráfico:

kate ~/.kde/share/config/plasma-desktop-appletsrc &

o

gedit ~/.kde/share/config/plasma-desktop-appletsrc &


Buscamos:

AutoBounceEnabled=true



Y lo cambiamos por

AutoBounceEnabled=false

Reiniciamos plama:

 plasma-desktop

Buscamos la pelota y ahora si la quitamos:


Leer más...

Previsualizar Videos y Pdfs en Dolphin Ubuntu

Dolphin muestra vistas previas de  varios archivos como fotos,texto,html,etc pero por defecto no muestra los Videos y PDF,por lo menos en Ubuntu 14.04 con KDE instalado,para poder ver vistas previas hay que hacer varias cosas las cuales muestro a continuación:

1.Instalar lo necesario para ver thumbviews de Vídeos y PDF:

Abrimos una terminal y escribimos:

sudo apt-get install kdegraphics-thumbnailers kffmpegthumbnailer
2. Abrimos la configuración de Dolphin:

Preferencias Dolphin->General->Vistas Previas:
Y activamos todo:


Por ultimo solo activamos el boton de vista previa del menu de Dolphin:


 Eso es todo,ejemplo :


Leer más...