Tecnologia Actual

Ocultar codigo PL/SQL (Oracle)

2010-01-10T19:31:00.000-08:00

Imaginemos un escenario en el cual hemos desarrollado un procedimiento almacenado en PL/SQL y deseamos evitar que alguien, incluido el DBA, pueda ver y/o modificar el código fuente. ¿Es eso posible?, definitivamente sí: Oracle provee el utilitario Wrap para lograrlo, pero implicaba invocarlo desde el Sistema Operativo; a partir de 10g es posible invocarlo desde dentro de la base de datos. Veamos cómo hacer uso de ambas modalidades.

Primero un vistazo al código que me interesa ocultar:

[oracle@sys ~]$ cat salary.sql
CREATE OR REPLACE
FUNCTION salary (
empno emp.empno%TYPE )
RETURN NUMBER
IS
sal emp.sal%TYPE;
BEGIN
SELECT sal INTO salary.sal
FROM emp
WHERE empno = salary.empno;
RETURN ( salary.sal );
END;

La primera alternativa es usar el utilitario Wrap desde el Sistema Operativo.

Hay que invocarlo referenciando al archivo que contiene el código fuente.
[oracle@sys ~]$ wrap iname=salary.sql

PL/SQL Wrapper: Release 10.2.0.4.0- Production on Sat Nov 01 14:21:47 2009

Copyright (c) 1993, 2004, Oracle. All rights reserved.

Processing salary.sql to salary.plb
Verificamos el resultado.
[oracle@sys ~]$ cat salary.plb
CREATE OR REPLACE
FUNCTION salary wrapped
a000000
367
abcd
abcd
abcd
abcd
abcd
abcd
abcd
abcd
abcd
abcd
abcd
abcd
abcd
abcd
abcd
8
cc d6
+/IgG5qcUWhn5W4aX1Z1gJbmalUwgy5KLcvWfHSi2sHVSCY2DKrK4KYn8hQGyrdN4JG7orD5
ELaEY9EXT7sxm8hT0NF8GQX2BSRNdGc/i2nS6FUq4oJr3+Z/vda3u1pli6dW3SXcl4vlGtfr
ShxK0Ikb/IzmSgsWLtX2Nyo5Ob28iiwzrfFQOmdO1j2jRP8s5Z3aTTuovLrHOuGA3Hyl

/
Introducimos el código en la base de datos.

[oracle@sys ~]$ sqlplus scott/tiger @salary.plb

SQL*Plus: Release 10.2.0.4.0 - Production on Sat Nov 1 14:23:59 2009

Copyright (c) 1982, 2007, Oracle. All Rights Reserved.

Connected to:
Oracle Database 10g Enterprise Edition Release 10.2.0.4.0 - Production
With the Partitioning, OLAP, Data Mining and Real Application Testing options

Function created.
Comprobamos que la funcion está operativa.
SCOTT@orcl > select salary( 7654 ) from dual;

SALARY(7654)
------------
1312.5

SCOTT@orcl >

Como resultado tenemos ahora un procedimiento almacenado cuyo código fuente es ininteligible a simple vista.

¿Qué hacer si el código ya está en la base de datos? Pues podemos extraerlo a un archivo y seguir el procedimiento previo, pero tambien es posible hacer uso del mejorado package DBMS_DDL, entonces manos a la obra.
Usaremos la siguiente rutina para transformar el código fuente.

[oracle@csys ~]$ cat wrapped.sql
DECLARE
v_source DBMS_SQL.VARCHAR2A;
BEGIN
v_source(1) := 'CREATE OR REPLACE ';
FOR s IN ( SELECT line, text
FROM user_source
WHERE name = 'SALARY'
ORDER BY line )
LOOP
v_source(s.line+1) := s.text;
END LOOP;
dbms_ddl.create_wrapped(
ddl => v_source,
lb => 1,
ub => v_source.count );
END;
Ahora lo ejecutamos.

SCOTT@orcl > @wrapped

PL/SQL procedure successfully completed.
Verificamos que el código fuente fue modificado.
SCOTT@orcl > select text from user_source
2 where name = 'SALARY' order by line;

TEXT
--------------------------------------------------------------------------------
FUNCTION salary wrapped
a000000
369
abcd
abcd
abcd
abcd
abcd
abcd
abcd
abcd
abcd
abcd
abcd
abcd
abcd
abcd
abcd
8
c3 d2
NL5qz7Eyn6/UUHrpUacIYXrnSkQwgy7wLcsVfHSiWHOUxMoNmSQvf6CVAlrwXr70aca5WXwI
/nAKWlYzkLkxeCuI8kessTO0QSAhNtwDkRNJ6sbC/1+niQxcN3d3A9MG5qanSMCbmJCZRkFk
zHqG9AcGWonxLvVFqyc+fCfcn4q5PwtD7ZLkhFU52f6bi7u9g2dWnLjOpqUrlos=
Finalmente veamos si está operativo.

SCOTT@orcl > select salary( 7654 ) from dual;

SALARY(7654)
------------
1312.5

Nuevamente el objetivo se ha cumplido!

En conclusión, hemos visto dos formas de transformar nuestro código fuente en un texto indescifrable apoyados de Wrap. El código mostrado no está libre de errores ni está optimizado, pero les puede servir como una base.

Oracle/Linux & Memoria

2009-10-14T13:25:00.000-07:00

Nada es perfecto. Y muchas de las novedades en los mainframes es poseer muchos GB de ram fisica a disposicion, de esta manera se confia ciegamente un administrador de sistemas que si posee 64GB de ram fisica la swap seria innecesaria o como maxima instancia, no mas de 2GB de swap.

Cuanta swap realmente requiere el sistema para Oracle? la documentacion oficial de Oracle se basa en un estandar, si posees de 8GB o mas fisica debes otorgar el mismo espacio de swap en disco. Lo que la documentacion oficial no detalla es la manera como los sistemas POSIX compatibles manejan la distribucion de ram. En sistemas Unixes comerciales se puede manipular el manejo de la swap ya que estos sistemas otorgan 2 opciones eager y lazy. Solia pensar que esta caracteristica era unica de los sistemas comerciales Unixes como Solaris o HP-UX, hasta que indague los parametros del kernel en Linux.

uno de los parametros 'swappiness' especifica la forma como el kernel de Linux maneja y distribuye el uso de memoria y cuando debe paginar a la swap del disco. Por defecto en los sistemas tipo-unix Linux la swappiness viene en 60% lo cual especifica mientras mas alto el porcentaje mas paginacion hacia la swap de parte de las aplicaciones. Mientras mas reducido el porcentaje, menos swap se recurrira y mas cache y memoria ram se aprovechara.

Si nuestra base de datos dispone de muchas instancias, dispondra de la misma cantidad de subprocesos por instancia (20 o mas subprocesos por instancia de Oracle iniciada) podemos verificar que seccion de segmento en memoria compartida ocupan los subprocesos de Oracle con el comando:

bash$ ipcs -m

Si vamos a dar uso masivo de la pool cache de Oracle, y queremos respuesta rapida del sistema lo mas ventajoso es reducir la lectura en disco (lo que implica reducir la utilizacion de la swap) como podemos manipular esto en Linux? reduciendo el parametro 'swappiness' a 5% o 0% para sacar la mayor ventaja de la cache de ram y la ram fisica (Siempre y cuando dispongamos de mucha memoria ram fisica) sino disponemos de mucha memoria ram fisica, no es factible reducir la paginacion hacia la swap puesto que esto puede causar estragos y lentitud de respuesta del CPU al utilizar toda la cache y ram fisica disponible, (recordando que la ram fisica de la mayoria de PC requieren refresco constante para no perder los datos) de igual manera si usamos la pool cache de Oracle se crearan masivos logs de parte de la cache usada por Oracle y la cache usada por el sistema operativo, pero por otro lado si se aumenta extremadamente la 'swappiness' a 90% o 80% para utilizar menos ram fisica y mas swap esto causa lentitud de lectura de disco para respuesta de solicitud, y de paso mucha espera de I/O al tener procesos bloqueados.

Entonces que es lo conveniente? dependendiendo sus necesidades, se ha elegir el que mas convenga. Yo particularmente utilizo 'swappiness' en 0% o 5% y desabilito la cache pool de Oracle, para evitar doble buffering en la cache de memoria y en la cache de disco...

Ate Logo :)

Mucho Tiempo...

2009-10-14T12:55:00.000-07:00

Un tiempecito sin retornar a mi Blog. Aveces tanto trabajo y estudios conduce al retiro =)

La novedad de la compra de SUN por parte de Oracle afecta a gran parte del actual mercado y el futuro de las cosas, una de las mas afectadas fue el motor MySQL, terminada la compra poco tiempo despues como arte de magia 'desaparecio' de la web de MySQL la version alpha 6.0 que incluia el motor de almacenamiento 'Falcon' el cual pretendia sustituir en un futuro cercano el motor 'InnoDB' (perteneciente a Oracle) y con mejoras que dicho motor aun no posee. En cambio surgio MySQL 5.4 con una extrema mejora de optimizacion a subconsultas en motores de almacenamiento 'InnoDB' algo bastante curioso y que da mucho que pensar.... ha trabajado Oracle en personalizacion de MySQL que por tal razon desaparecio el motor 'Falcon' junto a la rama 6.x?

:) A lugar...

Ulimit un RSBAC oculto :)

2008-07-12T07:27:00.000-07:00

La primera vez que instale FreeBSD me sorprendio la manera en la cual yo podia decidir cuantos servicios x usuario podia ejecutar, cuanta capacidad de ram podia este usuario consumir del sistema, cuantos procesos podia ejecutar, cuantos archivos podia abrir, etc. Todo era sencillamente en un simple archivo de texto indicarle un 1 ('activado') o 0 ('desactivado') pasado como parametro al kernel. Y me pregunte porque en Linux esta funcionalidad no existe? Luego me he topado con smrole en Solaris, que es un comando que nos permite controlar lo mismo, muchos pensamos que Linux no posee esta funcionalidad integrada. Y en caso de poseerla, o poseer algo similar es una funcionalidad extra tipo Selinux, o Rsbac que son parches para el kernel.

Pero existe algo comun en todos los Linuxes, y que muchos usuarios desconocen su existencia. Esta funcionalidad es 'ulimit'

Ulimit es un comando especial de la terminal, mayormente utilizado para controlar los servicios, cantidad de archivos a abrir, cantidad de consumo de ram, etc, que un usuario especifico pueda ejecutar en una terminal (Y como todos sabemos todos los servicios se ejecutan en una terminal). Podemos jugar con ulimit, en modo global o en modo solo aplicable a 1 usuario.

En modo global incluye editar 'ulimit' en /etc/profile pero si editamos a modo global aplicaria al usuario root por igual, pero si editamos .bashrc en cada $HOME de 1 usuario especifico y ponemos permisos chmod 600 donde solo root sea duenio, tendremos a dicho usuario controlado al nivel que queramos.

Para conocer nuestra limitante en una terminal basta con escribir :

bash$ ulimit -u

Si dice unlimited es porque tenemos acceso sin ninguna restriccion, si queremos algo mas detallado al respecto usamos:

bash$ ulimit -a
bash-3.1$ ulimit -a
core file size (blocks, -c) 0
data seg size (kbytes, -d) unlimited
file size (blocks, -f) unlimited
pending signals (-i) 8182
max locked memory (kbytes, -l) 32
max memory size (kbytes, -m) unlimited
open files (-n) 1024
pipe size (512 bytes, -p) 8
POSIX message queues (bytes, -q) 819200
stack size (kbytes, -s) 8192
cpu time (seconds, -t) unlimited
max user processes (-u) 8182
virtual memory (kbytes, -v) unlimited
file locks (-x) unlimited

si queremos controlar las opciones que proporciona ulimit basta con agregar a .bashrc

ulimit -n 30

Donde el parametro -n indica cantidad de archivos que puede un usuario abrir. Podemos tambien hacerlo temporal en nuestra propia shell para probar, luego verificamos con ulimit -a los cambios.

:)

KDE 4 en Slackware 12.1 o (current).

2008-07-12T07:17:00.000-07:00

Muchos usuarios tienen la duda, de como obtener paquetes precompilados de KDE 4 para Slackware 12.1 o rama current.

me alegra informarles, que existen paquetes ya precompilados disponibles para nuestro apreciado Slackware :) He aqui el Link. En ingles pero este senor es el responsable por el momento de crear paquetes precompilados de KDE 4 para Slackware, tambien ha sido halagado por el mismo Patrick Volkerding (Desarrollador principal de Slackware) en relacion a lo estables que son estos paquetitos en Slackware.

http://geektime.wordpress.com/2008/04/23/kde-4-on-slackware-120/

Maria nuevo Motor Almacenamiento Mysql

2008-06-07T05:35:00.000-07:00

No es tan nuevo, pero me entere un poco tarde Sonreir

Mysql lanzo una version testing en Enero 2008 de Maria. Un nuevo motor de almacenamiento no transaccional, desarrollado como una extension del famoso Myisam.

Maria aporta las mismas funcionalidades que Myisam, con la unica diferencia que es 'efectivo contra fallas' cosa que Myisam no, la definicion de 'efectivo contra fallas' implica que luego de hacer un proceso tipo backup, transacciones remota de una tabla a otro servidor y que haya por desgracia una falla electrica y se corte repentinamente nuestro intercambio, en tablas Myisam ocurria la dificultad que nos resultaba dificil recuperar los datos de dicha tabla y aveces usando 'repair table' no funcionaba.

Y es aqui cuando Maria funciona ya que Maria si tiene capacidad de recobrar data rota con una gran facilidad.

El motor de almacenamiento Maria No esta disponible oficialmente dentro de ninguna version Mysql, mas bien esta dentro de una version Mysql 5.x considerada como testing por el simple hecho de tener a Maria embebido sin embargo los fuentes de este Mysql con Maria se pueden conseguir desde la web oficial de Mysql o Sun. Se pretende, en un futuro integrar Maria de manera oficial dentro de Mysql, con el objetivo de sustituir a Myisam.

Bourne o C Shell

2008-06-05T12:06:00.001-07:00

Como usuarios de Linux & Unix. Debemos conocer bien la terminal, sabemos (y para quienes no lo saben Cheesy) que la terminal en Linux/Unix es simplemente un interprete de comandos. La via por donde el usuario puede comunicarse con el SO. En estos sistemas existen sin embargo, varios clientes terminales en los cuales podemos destacar :

Bourne Shells :

/bin/sh
/bin/bash
/bin/ksh

C Shells ::

/bin/csh
/bin/tcsh

Las mas usadas por nosotros (Linuxeros Sonrisa) es la tipica 'bash'. En sistemas Unixes (BSD, HP-UX, Solaris). Por defecto se utiliza o /bin/sh o /bin/ksh.

Un poquito de historia :

La primera 'shell' en nacer fue /bin/sh que es una shell creada por Sthepen Bourne, sustituyendo a la shell de Thompsom en los sistemas Unixes alla por los 70 y algo.
La bourne shell 'sh' se hizo tan popular que aun hoy dia uno de sus hijos son los mas usados. Y obviamente mas adelante GNU no podia quedarse fuera de este proyecto Sonrisa y nacio la primera Gnu-Bourne-Shell (Basada en sh) - nuestra querida 'bash'
Por igual forma otras companias no podian quedarse sin su propia version de shell bourne, y tambien surgio korn shell. Estas 3 shells, son totalmente compatibles entre si, y cualquier bourne-script funciona en (bash, sh, korn).

Pero como todo tiene una contraparte, no olvidemos las C - shells.
Las C-shells son (csh & tcsh) aunque tiene la misma funcionalidad que las Bourne Shells (funcionar como interprete de comandos) se desarrollo para los amantes del lenguaje 'C' por ser sus C-shell-script tan parecido a este lenguaje.
La C-Shell fue desarrollada por la gente de 'Berkeley' (Nuevamente tenemos la mano maestra de estos genios Cheesy ). Aunque como todo lo que sale de Berkeley, esta terminal no es tan popular como su competencia las Bourne Shells.
Su objetivo esta mas dirigido a programadores que a administradores, y un C-Shell-Script no precisamente va a funcionar en una terminal bourne y viceversa, ya que la sintaxis de interpretar comandos es distinta. Las C-Shells incluyen funciones, parametros, matrices, muy distintas a las que las Bourne Shells pueden soportar y viceversa.

Aunque tanto con cualquier shell Bourne o cualquier shell C Shell, se pueden desarrollar scripting, es de gusto y decision final del usuario cual de los dos distintos tipos de interpretes utilizar.

Yo utilizo bastante, la Bourne shell /bin/sh aveces /bin/bash, pero me he adaptado un poco a /bin/sh.

Cual es la preferida por ti

System V vs BSD Scripts

2008-06-05T11:54:00.001-07:00

La primera vez que me instale Slackware.. hace ya unos anitos, recuerdo que me sentia rara porque queria reiniciar servicios o desabilitarlos buscando en '/etc/init.d' o sus respectivos runlevels '/etc/rcx.d' Pero me di una sorpresa al ver que no existia ni la carpeta init.d, ni rcx.d de cada runlevel, nisiquiera /etc/pam.d

Yo que venia de Linuxes que si incluian estos menesteres(Mandrake, Suse, RedHat, Debian). Me sorprendi un poco y tuve que indagar porque esto era asi o donde slackware guardaba los demonios. Ahi fue que me tope con que hay sistemas Linux & Unixes que poseen sus scripts de arranque basado en BSD scripts o System V. Slackware estaba y aun esta basado en scripts de inicio BSD Scripts. Ahora ustedes se preguntaran que son scripts de inicios System V y que son BSD scripts.

La mayoria de Linuxes y Unixes (Solaris & HP-UX) poseen sus scripts de inicio basados en System V, cuando un sistema esta basado en System V, divide los servicios a cargar por defecto en varias carpetas por cada runlevel. Por ejemplo, el runlevel 5 en Linux es al cual ingresamos por defecto despues que termina de cargar el sistema. Este runlevel en los sistemas basados en System V tiene los servicios a cargar en '/etc/rc5.d' ahi dentro vemos muchos enlazes directos a los servicios de '/etc/init.d' todo lo que aparezca dentro de '/etc/rc5.d' es lo que va a cargar o es lo que vemos cargando cuando iniciamos el sistema. Si por ejemplo dentro de la carpeta '/etc/rc5.d' se encuentra el enlace 'mysql', bastaria con borrar mysql de /etc/rc5.d y ya este no cargaria por defecto cada vez que ingresemos al sistema, que es el runlevel 5.

Ahora.. como si se hace asi en System V, como se hace en sistemas BSD scripts?

Existen otros Unixes y Linux (minoria) que aun trabaja con BSD scripts, entre estos tenemos (Slackware, Crux, Arch Linux) y los BSD (FreeBSD, OpenBSD, NetBSD). Aqui no existe 1 carpeta para cada runlevel como si existe en un System V. Aqui existe 1 solo archivo de configuracion, que es el que indica que servicios cargar y cuales no a la hora de iniciar el sistema... y cualquier cambio a este archivito aplica a todos los runlevels (Van captando la diferencia?).

En slackware dicho archivo se llama rc.M se encuentra en /etc/rc.d (que seria el equivalente a '/etc/init.d' en un System V). en rc.M vemos que servicios el sistema por defecto carga al iniciar y cuales no, si queremos apagar uno podemos o comentarlo en rc.M o quitarle los permisos de ejecucion al demonio que tambien esta dentro de '/etc/rc.d'.

En los sistemas BSD (FreeBSD por ejemplo y Crux o Arch linux), igual que slackware tenemos 1 solo archivo de configuracion para todos los runlevels. dicho archivito se llama rc.conf y esta en '/etc' Como slackware en rc.conf estan todos los demonios a cargar para todos los runlevels, aqui activamos o desactivamos servicios solo editando ese archivo.

En resumen ::
System V : 1 carpeta por cada runlevel dicha carpeta contiene dentro enlacez simbolicos a los demonios que debe cargar. Cada carpeta de runlevel, cualquier cambio solo aplica para ese runlevel.

BSD Scripts: 1 solo archivo de configuracion, donde se editan los servicios que deben o no subir, cualquier cambio aplica para todos los runlevels.

Cual es mejor? ninguno, son solo distintas maneras de manejar el asunto Sonrisa

Como me doy cuenta cuando un sistema es System V o BSD scripts?
Sencillo, cuando iniciamos un Unix o Linux donde se nos permita ver en el proceso de inicio antes de llegar al prompt login o al servidor X (Gnome, KDE, etc). si nuestro sistema va cargando asi :

Samba .............. (OK)
networking ..............(OK)
sound ...................(OK)

Es un sistema tipo System V. Ya sabemos que como tal, debe tener una carpeta de demonios llamada 'init.d' generalmente ubicada en '/etc' pero hay unixes que la ubican en otro lado (HP-UX por ejemplo). Y que como es System V no solo tiene init.d tambien tiene subcarpetas por cada runlevel.

Ahora si el sistema va iniciando asi ::

raid6: using algorithm sse2x2 (1901 MB/s)
md: raid6 personality registered for level 6
md: raid5 personality registered for level 5
md: raid4 personality registered for level 4
raid5: automatically using best checksumming function: pIII_sse
pIII_sse : 4182.000 MB/sec
raid5: using function: pIII_sse (4182.000 MB/sec)
md: multipath personality registered for level -4
device-mapper: ioctl: 4.11.0-ioctl (2006-10-12) initialised: dm-devel@redhat.com
TCP cubic registered
Initializing XFRM netlink socket
NET: Registered protocol family 1
NET: Registered protocol family 17
Using IPI Shortcut mode

Y va cargando un poco rapido, estamos frente a un sistemas BSD-Scripts. Ya saben que dentro debe tener algun rc.conf o rc.M donde manipule los servicios a cargar al inicio y que cualquier cambio aplica para todos los runlevels.

Umask en Unix/Linux

2008-06-03T12:55:00.000-07:00

Alguna vez se han preguntado como sabe Unix/Linux cuando creo un directorio nuevo o un archivo que permisos otorgar por defecto??? Sabes como tu como administrador puedes manipular dichos permisos?.

En los distintos sistemas Unixes/Linux tenemos una variable de entorno que controla esto llamada umask. Umask no es mas que otra forma de administrar los permisos bajo sistemas unixes/linux, y podemos encontrar una entrada de el en /etc/profile, por lo general siempre lo veremos asi :

umask 022

Los permisos en Linux/Unix se otorgan como octal, decimal o simbolo:

Octal : 0000
decimal : 000
simbolos : u, a, +, -

como manipulamos umask con los permisos estandares de nuestro sistema? sencillo, toda carpeta recien creada en Linux tiene los permisos 755, y si es un archivo de texto 655.. Ahora te preguntaras porque 755 y 655 y no 777 o 666? o 700 o 600? sencillo, porque si tenemos definido una umask 022 que es la estandar en /etc/profile, todos los permisos de los nuevos archivos se restaran con el octal que tengamos como umask. Por lo cual realmente todas las carpetas se crean con permisos 777 y los archivos de textos 666 pero si restamos ambos a la umask ya definida en /etc/profile como 022, obtenemos lo siguiente :

umask = 022
carpeta = 777
archivo = 666

022 - 777 = 755
022 - 666 = 644

Captan la idea? no podemos restar el primer 7 ni el primer 6 ya que 0 no tiene valor, pero si podemos restar 2 - 7 y 6 - 2, y es aqui que se definen los permisos reales que tendran todos los archivos y carpetas que recien vayamos creando. Ahora, que ocurre si modificamos el umask 022 de /etc/profile y decimos que quiero un umask 077 y guardamos los cambios en /etc/profile actualizamos con el comando source /etc/profile y creamos una carpeta nueva, que ocurrira aqui?? ya nuestra carpeta no tendra permisos 755 sino :

umask 077
carpeta 777
077 - 777 = 700

Todas las nuevas carpetas se crearan con permisos 700, donde solo el duenio tendra acceso a entrar, modificar, borrar, actualizar, etc. Lo mismo ocurre si volvemos a modificar la entrada umask en /etc/profile y decimos que ya no queremos una umask 077 sino umask 066, y actualizamos /etc/profile y creamos un archivo de texto nuevo. Ya nuestro archivo no tendra permisos 644 como ocurre cuando tenemos umask 022. Aqui seria :

umask 066.
archivo 666
066 - 666 = 600

Donde solo el duenio o creador del archivo tendra acceso a modificarlo, insertar, verlo, leerlo, etc. Tambien podemos jugar con umask fuera de editar /etc/profile (ya que editar /etc/profile indica que se apliquen a todos los usuarios del sistema). sencillamente abrimos una terminal, y ejecutamos umask valor, donde valor es el valor temporal que queremos asignar a esa seccion que tengo abierta en la terminal, y la cual se aplicara solo mientras mantenga esa seccion abierta, y cree nuevas carpetas o archivos dentro de dicha seccion.

Espero que la explicacion de umask les haya sido de utilidad.

Mysql Falcon

2008-05-25T12:45:00.000-07:00

Much@s conocemos las grandes ventajas de las bases de datos relacionales, sobretodo si es de codigo libre, como el caso de Postgresql y Mysql. Hablemos sobre Mysql en si, Mysql se ha caracterizado por ser el RDBMS mas rapido que existe dentro de las DB relacionales existentes (Oracle, SQL Server, DB2, etc).

Mysql tambien se diferencia de sus amigas en muchas cosas, ademas de ser una DB relacional posee distintos motores de almacenamientos de datos, que las demas DB no poseen. En Mysql version 5.1.x he inferiores teniamos los siguientes motores de almacenamientos disponibles :

Myisam :: El motor por defecto de Mysql, indice alto de lectura, no posee capacidad ni soporte para claves foraneas ni referencias. Un gran ambito de escritura sobre este motor alenta sobre manera la DB, pero para lectura es bastante rapida. Es un motor No transaccional, lo que indica que cualquier peticion realizada por un usuario o administrador se aplica inmediato en la tabla y no somos capacez de usar rollback, ya que el cambio es real no virtual como ocurre en una tabla transaccional.

InnoDB :: Motor de almacenamiento transaccional perteneciente a la compania de Oracle. Posee la caracteristica de soportar claves foraneas y referencias. Tambien posee la capacidad de crear un archivo distinto por cada tabla. No es tan rapida como su contraparte Myisam, pero maneja la data en un modo mas seguro.

Federated :: Motor de almacenamiento No transaccional, su funcion principal es permitir al administrador que los objectos de una tabla sean guardados en un servidor Mysql remoto y no local.

NDBCluster :: Utilizado para realizar clusteres de discos en varias DB Mysql locales.

Memory & Example :: Motores no transacionales, su uso es mas para testing.

Mirando una breve descripcion de los motores de almacenamientos disponibles en Mysql, nos encontramos con un nuevo motor de almacenamiento en Mysql 6.x el cual aun es alpha y esta en version beta. Hablamos de Falcon.

Falcon es un nuevo motor de almacenamiento totalmente GPL y totalmente transaccional , tiene soporte para claves foraneas y referencias. Tambien posee una nueva implementacion que es la creacion de tablespaces (como en Oracle) donde podemos asignar un datafile para guardar los objetos de nuestras tablas.

Las caracteristicas de estos tablespaces a diferencia de un tablespace Oracle, es que Falcon crea un datafile de 16KB por defecto, el cual automaticamente ira automentando de tamano mientras tengamos capacidad en el disco duro. No ocurre asi en un datafile de Oracle donde debemos indicar su tamano y si queremos agrandar o reducir debemos alterar la DB Oracle. Otra utilidad de un datafile en Falcon es, que al eliminar nuestro tablespace, este automaticamente eliminar el datafile que le pertenece, otra ventaja sobre un tablespace de Oracle que no elimina datafiles.

Otra ventajilla de un tablespace Falcon, es que su datafile incluye al igual que los demas motores de almacenamiento de Mysql (exceptuando Myisam), los indices y la data de una tabla dentro del mismo archivo. Esto, muchos DBA Oracle piensan que es una desventaja, ya que se tiene la creencia por ley que los indices deben estar en otro HD distinto a la data, y esto debe ser asi en Oracle u otra DB relacional, pero no en Mysql. La razon? la siguiente :

Oracle lee alternadamente 1 indice, 1 data, 1 indice, 1 data dentro de sus archivos. Si los indices y la data se encuentran en el mismo HD, imaginen la presion que esto causaria al HD y la banda ancha en si.

Mysql con Falcon, al tener indices y data en 1 solo archivo, lee de antemano primero todos los indices y luego la data no lee alternadamente como lo hace Oracle en 2 archivos distintos, sino que lee 1 solo primero todos los indices, y luego toda la data, lo cual arregla este problemita de saturamiento de lectura por el cual hay que separar indices y data en 2 HD distintos.

El motor de almacenamiento Falcon solo viene disponible en Mysql 6.x. Para crear un tablespace usamos :

mysql> create tablespace fulano
add datafile 'fulano.fts'
engine = falcon;

Con esto creamos 1 nuevo tablespace con 1 datafile llamado fulano.fts, podemos verificar en el diccionario de metadata de Mysql sobre la existencias de todos nuestros tablespaces en la DB, pero si nuestro tablespace en cuestion no tiene aun objetos guardados (una tabla), no aparecera a la hora que hagamos :

mysql> select * from information_schema.falcon_tables;

Hasta el momento no se soporta agregar mas datafiles a un tablespace, aunque en un futuro la pretension existe. Ya creado nuestro tablespace fulano, creamos una tabla con el mismo motor de almacenamiento y le asignamos su respectivo tablespace.

mysql> create table prueba ( nombres char(20), apellidos char(20)) engine = falcon tablespace fulano;

Ahora que existe un objeto real en el datafile fulano.fts podemos verificar la existencia de dicho tablespace :

mysql> select * from information_schema.falcon_tables;

Para eliminar un tablespace existente, debemos tener claro que no debe contener ningun objeto, de lo contrario no podremos eliminarlo y nos dara error. Para borrar un tablespace hacemos :

mysql> drop tablespace fulano engine = falcon;

Un Saludo :)

Perl y DBI

2008-05-25T12:40:00.001-07:00

#Se coloca el interprete al inicio del archivo, obviarlo si se va a ejecutar en SO Windows
#!/usr/bin/perl
# Usamos el paradigma strict, para que explicitamente nos revise el codigo y debamos programar lo mas estructurado posible.
use strict;
# Damos uso del modulo DBI para trabajar con los binarios de Mysql
use DBI;

# Pedimos informacion al usuario
print STDOUT "Inserte servidor, database, usuario, contrasena\n";
# Capturamos la entrada del flujo de entrada stdin y guardamos en una variable escalar.
chomp (my $respuesta = );

# Dividimos los datos de dicha variable escalar con el comando split, y se lo asignamos a una variable de arreglos.
my @respuesta1 = split(/\s+/, $respuesta);

# Damos uso de las funciones de DBI y los datos insertados por el usuario para conectarnos a Mysql.
my $coneccion = DBI->connect("dbi:mysql:$respuesta1[1]:$respuesta1[0]", $respuesta1[2], $respuesta1[3], { RaiseError => 1, PrintError => 1, AutoCommit => 0 });

# Verificamos que la variable coneccion no esta vacia y que se definio
if ( defined $coneccion ) {
if (!$coneccion) {
print STDOUT $coneccion->errstr;
exit(1);
}
else {
eval {
# Esto es una funcion, que trabajara con distintas opciones de un Menu a elegir
sub Menu() {
print STDOUT "QUe desea hacer?\n1 - Ver primary key\n2 - Ver data\n3 - Crear Tabla\n4 - Borrar Tabla\n5 - Salir\n";
my $respuesta2 = ;
chomp $respuesta2;
# Validamos si la respuesta fue 5 antes de la variable variable, para que se cierre la aplicacion.
if ($respuesta2 eq 5 ) { exit(1); }
print STDOUT "Inserte nombre de la tabla\n";
chomp (my $variable = );

# Empezamos a validar los resultados y a realizar las opciones segun han sido elegidas por el usuario.
if ($respuesta2 eq 1) {
my $peticion = $coneccion->prepare( qq{ SHOW INDEXES FROM $variable } );
$peticion->execute();

while (my @todo = $peticion->fetchrow_array) {
print STDOUT "\n@todo\n";
}
system("sleep 01");
$peticion->finish();
# Terminamos y regresamos nuevamente al Menu.
return Menu();
}
elsif ($respuesta2 eq 2) {
my $peticion1 = $coneccion->prepare( qq{ SELECT * FROM $variable });
$peticion1->execute();

while (my @todo1 = $peticion1->fetchrow_array) {
print STDOUT "\n@todo1\n";
}
system("sleep 01");
$peticion1->finish();
return Menu();
}
elsif ($respuesta2 eq 3) {
my $peticion1 = $coneccion->prepare( qq{ $variable });
$peticion1->execute();
if ($peticion1) { print STDOUT "Realizado!\n"; } else { print STDOUT "Error en la creacion\n"; }
system("sleep 01");
$peticion1->finish();
return Menu();
}
elsif ($respuesta2 eq 4) {
my $peticion1 = $coneccion->prepare( qq{ DROP TABLE $variable });
$peticion1->execute();

if ($peticion1) { print STDOUT "Realizado\n"; } else { print STDOUT "Error\n"; }

system("sleep 01");
$peticion1->finish();
return Menu();
}
}
} & Menu();
}
}
# Nos desconectamos completamente de Mysql, asi liberamos memoria.
$coneccion->disconnect();

Api C de Mysql

2008-05-24T09:05:00.000-07:00

/* Para compilar este ejemplo, hay que tener Mysql instalado o los Headers de Mysql instalados en un PATH reconocible de nuestro SO. Para compilar bajo Linux/Unix con gcc hacemos :

gcc -o archivo prueba.c -I/usr/local/include/mysql -lmysqlclient -lnsl -lm -lz
*/

// Se declaran los headers que vamos a usar.
#include
#include
#include

// Declaramos una estructura, que guarda funciones de la Api C de Mysql
struct data {
MYSQL coneccion;
MYSQL_ROW columna;
MYSQL_RES *respuesta;
} info;

// Se declara parte del query a hacerse
char peticion[40] = "SELECT * FROM ";

main(void)
{
// Hacemos un puntero que apunte a la direccion en memoria de la estructura anterior.
struct data *p = &info;
// Creamos el Objeto Mysql
mysql_init(&p->coneccion);
char respuesta[15];

fprintf(stdout, "Nombre de la Base de Datos\n");
fscanf(stdin, "%s", &respuesta);

const char *servidor = "localhost";
const char *usuario = "marian";
const char *contrasena = "123";
const char *data = "primaria";

if (!mysql_real_connect(&p->coneccion, servidor, usuario, contrasena, data, 0, NULL, 0))
{
fprintf(stderr, "%s", mysql_error(&p->coneccion));
return 1;
}

// Seleccionamos la Db a usar
mysql_select_db(&p->coneccion,data);

// Se concatena el nombre de la DB con el query
strcat(peticion, respuesta);

if (mysql_query(&p->coneccion, peticion)) {
fprintf(stderr, "%s\n", mysql_error(&p->coneccion));
return 1;
}

// Preparamos a ejecutar la peticion anterior
p->respuesta = mysql_use_result(&p->coneccion);

while((p->columna = mysql_fetch_row(p->respuesta)) != NULL) {
fprintf(stdout, "%s %s\n", p->columna[0], p->columna[1]);
}

// Liberamos memoria usada por el Query
mysql_free_result(p->respuesta);

// Desconectamos el programa de Mysql
mysql_close(&p->coneccion);

return 0;
}

Ataques PDOS, ¿la nueva pesadilla?

2008-05-24T08:41:00.001-07:00

Podríamos agachar la cabeza, y decir que los ataques PDOS (Permanent Denial-Of-Service), serán una pesadilla de ahora en más… pero sería como aceptar que recién ahora nacen, y muchos dudan que esto sea así.

Un ataque de denegación de servicio permanente implica que un sistema es dañado, a tal punto de que se dañan partes físicas de la máquina afectada, las cuales deben ser reemplazadas para -solventar- el problema.Este tipo de ataques, según los expertos en seguridad, se lleva acabo por medio del aprovechamiento de vulnerabilidades en las actualizaciones de Firmware, y podrían tener consecuencias muy graves en entornos corporativos, donde el Hardware utilizado normalmente tiene precios un tanto desorbitados.

Uno de los expertos, Smith, apoda esta modalidad como Phlashing, y asegura que puede hacer una demostración de forma remota hacia sistemas vulnerables que tengan actualización por medio de funciones de red (vía web, por ejemplo), detectándolos con su herramienta PhlashDance, que busca en los archivos binarios (del Firmware), e incluso lanzando un ataque desde allí hacia las potenciales víctimas encontradas.

Si bien muchos dicen que los ataques PDOS son nuevos (en base a este hallazgo), otros dudan de que sea una técnica que se viene usándose desde hace tiempo, y que hasta el momento se calificaba como “una simple falla en el Hardware” en muchas organizaciones.

Sin duda, un detalle a tener en cuenta a futuro… a la hora de comprar Hardware con funciones como estas.