elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Guía actualizada para evitar que un ransomware ataque tu empresa


  Mostrar Temas
Páginas: [1] 2 3 4
1  Programación / Java / Introducción a la programación con Android en: 10 Junio 2010, 22:28 pm
Me da algo de nostalgia volver preparar un post para este sub foro al que tanto le tengo aprecio. Hace ya más de un año que no soy usuario activo del foro en general, pero esta es la única comunidad de la cual me siento parte, así que me complace estar por aquí de nuevo.

En este caso va un post de introducción a la programación con Android (que es básicamente programación en Java), que es básicamente una adaptación de todos las entradas que he hecho en mi página personal recientemente. Android es un sistema operativo que tiene una acogida cada vez mayor y que, según mi opinión, es el futuro del desarrollo de aplicaciones para dispositivos móviles. Así que ahí va un nuevo aporte después de tanto tiempo...

Introducción a la programación con Android

Android es un estupendo sistema operativo para dispositivos móviles basado en Linux, y que nos proporciona un completo SDK para desarrollar nuestras propias aplicaciones de una manera rápida y divertida.

En esta sección aprenderemos a instalar/configurar el SDK y el plugin para Eclipse.  Haremos el típico Hola Mundo, y explicaré un poco sobre la metodología de programación para esta plataforma. ¡Manos a la obra!

1. Instalar y configurar el SDK de android

Vamos a la página del Android SDK y descargamos la versión para nuestro sistema operativo. Yo uso Gentoo Linux, pero los pasos son prácticamente idénticos en Windows y en Mac. La última versión al escribir esta entrada es android-sdk_r06. Una vez que hayamos descargado el archivo, lo descomprimimos, entramos a la carpeta que se crea y ejecutamos (en Linux):

Código:
tools/android

En Windows:

Código:
SDK Setup.exe

Veremos algo como esto:


Hacemos clic en Available packages y desplegamos el árbol que aparece bajo Sites, Packages and Archives para instalar el API sobre la(s) que deseamos trabajar, y una vez la(s) hayamos seleccionado hacemos clic en Install Selected. En este caso he seleccionado el API 7 (para la versión 2.1 de Android), la documentación del API 7, los ejemplos del API 7 y el SDK del API 4 (para la versión 1.6 de Android). Es importante elegir las APIs adecuadas teniendo el cuenta el tipo de dispositivo para el que estamos desarrollando la aplicación. Escogí en este caso el API 4 puesto que el equipo sobre el que pruebo los programas (HTC Tattoo) viene con Android 1.6 (Donut) [más información sobre las versiones y sus codenames]. Por supuesto, si desarrollas con el API 4 tus programas tienen un 98% de probabilidades de correr sobre las versiones más recientes de Android sin modificación alguna.


Una vez haya terminado de descargar e instalar las APIs podemos crear un dispositivo virtual sobre el que probaremos nuestras aplicaciones. Hacemos clic en Virtual Devices al lado izquierdo, luego sobre el botón New… y configuramos el dispositivo:


Como puede apreciar en la imagen de arriba, debe poner un nombre al dispositivo, seleccionar el API sobre el que va a trabajar, darle un tamaño a la memoria ROM, escoger un tipo de pantalla y algunas configuraciones avanzadas que no se tratarán en este tutorial. Una vez tengamos esto, hacemos clic en Create AVD y si todo sale bien veremos algo como esto:


2. Instalar y configurar el plugin para Eclipse

Para este paso, necesitaremos Eclipse 3.5 (Galileo, recomendado) o 3.4. Abrimos eclipse, vamos a la Window -> Install New Software


Hacemos clic en el botón Add… para añadir el repositorio de Android ( https://dl-ssl.google.com/android/eclipse/ ):


Clic en OK y ahora seleccionamos los plugins a instalar, y seguimos el proceso de instalación:


Una vez instalado, reiniciamos Eclipse y veremos que se han añadido algunos iconos extra en la barra de herramientas, y que además podemos crear proyectos para Android.

3. Hola Mundo en Android

Ahora vamos a crear un nuevo proyecto y aprender un poco más sobre cómo funcionan las aplicaciones para Android.  Hacemos clic en el botón de creación de proyectos Android (o File… -> New Project -> Android Proyect):


Veremos el asistente de creación de proyectos para Android en donde debemos especificar: el nombre del proyecto (HolaParce), el API para el que vamos a desarrollar (1.6 en este caso), el nombre de la aplicación (Hola Parce en este caso), el nombre del paquete (se recomienda que sea un paquete nombrado con el estándar de Java, es decir, un dominio invertido), seleccionamos Create Activity y le damos un nombre (que cumpla las especificaciones de un nombre de clase en Java), y por último seleccionamos la versión mínima del API que deberán tener los dispositivos que corran nuestro aplicativo:



¡Clic en Finish y listo! Ahora podemos probar la aplicación… hacemos clic derecho sobre el Proyecto, seleccionamos Run as… -> Android Application. Se cargará el emulador y después de un par de minutos podremos ver nuestra aplicación:


4. Entendiendo el funcionamiento básico de las aplicaciones en Android

Las aplicaciones en Android funcionan bajo el esquema de “Actividades”. Una actividad presenta una interfaz gráfica (escrita en XML) que permite al usuario interactuar con la aplicación. Cada aplicación tiene varias actividades que se van mostrando al usuario según este las vaya necesitando. Una actividad llama a otra cuando sea necesario, y cada una de las actividades que se vayan mostrando se almacenan en una pila; es decir, cada vez que la aplicación lo requiera inserta una nueva actividad en la pila y, cuando esta ya no se necesite, se hace un push sobre esta lo cual deja en descubierto la actividad que estaba debajo. Importante leer esto para tener claro cada uno de los aspectos fundamentales de las aplicaciones Android.

Ahora, veremos detalladamente qué ocurrió en los pasos que seguimos arriba. Por ejemplo, al crear el proyecto se generan algunos archivos automáticamente. Veamos que hace cada uno de ellos…

Dentro del directorio res se han creado algunos subdirectorios:

  • drawable-hdpi, drawable-mdpi, drawable-ldpi en donde se almacenan las imágenes que va a utilizar nuestra aplicación. La diferencia entre ellas es que debemos colocar las imágenes que aparecerán según el tipo de pantalla del dispositivo. En drawable-hdpi se colocarán las imágenes para dispositivos con alta resolución (High) y en drawable-ldpi (Low) pondremos las imágenes para dispositivos con pantallas pequeñas.
  • values contiene inicialmente el archivo strings.xml, que es donde declaramos las cadenas de texto que usará nuestra aplicación. No es obligatorio definir todas las cadenas de texto allí, pero es bastante recomendable hacerlo. En este caso simplemente contiene la definición de una cadena de texto (llamada hello), que es la que se muestra al ejecutar la aplicación:
Código
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <resources>
  3. <string name="hello">Hello World, HolaParce!</string>
  4. <string name="app_name">Hola Parce</string>
  5. </resources>

  • layout contiene los archivos XML que representan interfaces gráficas. Si echamos un vistazo al archivo generado (main.xml) veremos algo como esto:

Código
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  3. android:orientation="vertical"
  4. android:layout_width="fill_parent"
  5. android:layout_height="fill_parent"
  6. >
  7. <TextView
  8. android:layout_width="fill_parent"
  9. android:layout_height="wrap_content"
  10. android:text="@string/hello"
  11. />
  12. </LinearLayout>
  13.  

  • Los layouts son XML estrictos, así que deben comenzar con el encabezado <?xml version="1.0" encoding="utf-8"?> y todas las etiquetas abiertas deben ser debidamente cerradas.
  • Los LinearLayout representan contenedores de widgets (algo similar al JPanel de swing en Java). Es decir, es la manera de organizar cada grupo de elementos de la interfaz gráfica.
  • En este caso, dentro del contenedor solo tenemos un TextView (que sería algo así como un JLabel de swing en Java).
  • Sea cual sea el elemento que pongamos en el layout, debemos especificar su anchura (android:layout_width) y altura (android:layout_height). Para cada parámetro podemos usar el valor fill_parent o wrap_content. fill_parent hará que el widget ocupe todo el tamaño posible, mientras que wrap_content hará que ocupe el menos posible.
  • El parámetro android:text permite asignar un texto al TextView. En este caso se usa @string/hello que indica que se usará una variable llamada hello. Esta variable puede ser encontrada en el archivo strings.xml dentro del directorio values. También podríamos especificar el texto directamente, por ejemplo: android:text="Hola parcero!"
  • Como tal vez se dio cuenta, es posible editar los archivos XML gráficamente o con el editor de textos de Eclipse.

    Dentro del directorio gen se encuentra un archivo llamado R.java. Este archivo NO debemos modificarlo ya que es Eclipse quien se encarga de poner el código allí dentro. Este archivo sirve básicamente para enlazar las cosas que hagamos en XML con la programación en Java. Por ejemplo, se crea una referencia a la variable hello creada en el archivo strings.xml. Esto permite que podamos referenciar dicha variable desde Java (esto se explica con más detalle abajo).

    Bajo el directorio src se creó un paquete y dentro de él un archivo en Java que es nuestra primera actividad (fíjese cómo la clase creada extiende la clase Activity del paquete android.app):

Código
  1. package net.casidiablo.holaparce;
  2. import android.app.Activity;
  3. import android.os.Bundle;
  4. public class HolaParce extends Activity {
  5. /** Called when the activity is first created. */
  6.    @Override
  7.    public void onCreate(Bundle savedInstanceState) {
  8.        super.onCreate(savedInstanceState);
  9.        setContentView(R.layout.main);
  10.    }
  11. }

Veamos en detalle cada línea:

  • Línea 1 define el nombre del paquete.
  • Líneas 2 y 3 importamos las clases que necesitamos para correr la actividad.
  • En la línea 4 podemos ver que la clase exitiende a Activity.
  • En la línea 7 redefinimos el método onCreate de la clase Activity, el cual es ejecutado al momento de iniciar la aplicación. Note que no es necesario tener un método main; en Android se define una actividad principal que será ejecutada al iniciar la aplicación (más adelante veremos donde se configura esto).
  • En la línea 9 se usa el método setContentView que define cual de las interfaces gráficas creadas en el directorio layout serán usadas. Como parámetro usamos la variable R.layout.main. Esto es algo confuso al principio así que lea atentamente: R, como vimos anteriormente, es una clase generada por Eclipse automáticamente cada vez que creamos nuevos componentes para la aplicación; dentro de ella se crean clases estáticas con variables enteras que representan cada uno de estos componentes (main.xml es entonces una variable entera llamada main, dentro de la clase estática layout, que a su vez se encuentra dentro de la clase R.java). Por ejemplo, para usar la variable hello desde Java, tendríamos que usar una referencia de tipo R.values.hello.

Por último, tenemos el archivo AndroidManifest.xml. Todas las aplicaciones deben tener este archivo y no debe ser renombrado. En él se especifican las opciones generales del programa, como el paquete principal, la actividad que deberá ejecutarse al iniciar la aplicación (y deben incluirse allí TODAS las actividades que se van usar), el icono a usar, los permisos, etc.

Código
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"
  3. package="net.casidiablo.holaparce"
  4. android:versionCode="1"
  5. android:versionName="1.0">
  6. <application android:icon="@drawable/icon" android:label="@string/app_name">
  7. <activity android:name=".HolaParce"
  8. android:label="@string/app_name">
  9. <intent-filter>
  10. <action android:name="android.intent.action.MAIN" />
  11. <category android:name="android.intent.category.LAUNCHER" />
  12. </intent-filter>
  13. </activity>
  14. </application>
  15. <uses-sdk android:minSdkVersion="4" />
  16. </manifest>

5. Operaciones avanzadas: acceder al dispositivo por consola y obtener una shell

Como sabemos, Android está basado en Linux, y como tal posee una interfaz de linea de comandos que podemos acceder usando las herramientas del sdk. Esto lo podemos hacer tanto para dispositivos virtuales, como el de este ejemplo, como para dispositivos reales. En este caso lo haremos con el dispositivo virtual que creamos para el ejemplo. Es tan sencillo como ejecutar esto en consola (en Linux):

Código:
tools/adb -s emulator5554 shell

Lo que hacemos con el comando anterior es indicarle al adb que queremos abrir una shell del dispositivo con serial emulator-5554. Para ver los dispositivos conectados actualmente y sus seriales usamos el comando adb devices. Si todo va bien veríamos algo como esto:

Código:
funtoo@larry tools % ./adb -s emulator-5554 shell
# ls
sqlite_stmt_journals
cache
sdcard
etc
system
sys
sbin
proc
init.rc
init.goldfish.rc
init
default.prop
data
root
dev

Desde dicha shell podemos hacer bastantes cosas, pero la más interesante para mi, es poder usar el SQLite3 para acceder a las bases de datos de las aplicaciones que creemos, lo cual nos permite una depuración mucho más rápida.

Depuración de aplicaciones en Android

Siguiendo con la serie de entradas sobre Android, aprenderemos a depurar de una manera sencilla las aplicaciones que escribamos. Muchas veces, al ejecutar la aplicación obtenemos un mensaje de este tipo:


Cuando estamos desarrollando aplicaciones normales en Java, usualmente imprimimos mensajes en consola que contienen la información de las excepciones que capturamos, y que nos permiten detectar los errores. En Android tendremos hacer uso de la clase Log, que genera logs  (¡capitán obvio al rescate!).

Su uso es bastante simple. Como ejemplo usemos este programa que arrojaría un famoso NullPointerException:

Código
  1. package net.casidiablo.ejemplo;
  2. import android.app.Activity;
  3. import android.os.Bundle;
  4. import android.util.Log;
  5. public class EjemploInvertir extends Activity {
  6. @Override
  7. public void onCreate(Bundle b) {
  8. super.onCreate(b);
  9. setContentView(R.layout.interfaz_grafica);
  10. String x = null;
  11. try {
  12. x.length();
  13. } catch (Exception e) {
  14. Log.d("Al inicio", "El error es: "+e.toString());
  15. }
  16. }
  17. }

En este caso se usó el método d de la clase Log, el cual genera mensajes de tipo DEBUG. Existen otros como v, para VERBOSE, e para ERROR, etc. La lista completa la encuentras en el API de la clase.

Para leer el registro de errores desde Eclipse vamos a Window -> Show view -> Other… Dentro del cuadro de diálogo que se abre seleccionamos Android -> Logcat:


Espero que les sea de ayuda. No duden en comentar sus dudas o sugerencias.
2  Seguridad Informática / Wireless en Linux / La inyección funciona, pero no puedo con el "fake authentication" (aircrack-ng) en: 16 Enero 2009, 15:29 pm
Hola a todos... creo que nunca había posteado en esta sección, así que espero hacerlo bien.

La cosa es la siguiente. Estoy estudiando acerca de las vulnerabilidades de las claves WEP, por lo que estoy jugando con mi AP.

Lo que he podido hacer

Si pongo mi tarjeta en modo monitor, y capturo paquetes con el airodump-ng mientras esté usando la red con otro equipo (descargando un archivo pesado), se generan los suficientes IVs como para descifrar la clave WEP. Esto no tiene ningún misterio, y ni siquiera necesito la inyección.

Para el siguiente ejercicio, quería intentar obtener la clave mientras la red no estuviera en uso, o tuviera muy poco. Para ello, fue necesario recompilar los drivers de mi tarjeta siguiendo estos  pasos:

http://casidiablo.net/compilar-drivers-iwlagn-inyeccion-trafico-cracking-wep/

para habilitar la inyección de paquetes. Y aquí vienen los problemas...

Lo que NO he podido hacer

Pongo la tarjeta en modo monitor, y luego abro una sesión con el airodump para capturar los paquetes. Luego hago un test de inyección, y todo parece funcionar:



Pero cuando deseo hacer un fake authentication (aireplay-ng -1 0 -e NUMICOM -a XXXXXXXXXX -h 00:21:5c:06:35:73 wlan0), me aparece el típico error:

Código:
Attack was unsuccessful. Possible reasons:

    * Perhaps MAC address filtering is enabled.
    * Check that the BSSID (-a option) is correct.
    * Try to change the number of packets (-o option).
    * The driver/card doesn't support injection.
    * This attack sometimes fails against some APs.
    * The card is not on the same channel as the AP.
    * You're too far from the AP. Get closer, or lower
      the transmit rate.

Veamos...

    * Perhaps MAC address filtering is enabled. Es mi AP, y la configuración es esta:



    * Check that the BSSID (-a option) is correct. El BSSID es correcto
    * Try to change the number of packets (-o option). ???
    * The driver/card doesn't support injection. los tests dicen que sí.
    * This attack sometimes fails against some APs. le intenté con otro, y lo mismo.
    * The card is not on the same channel as the AP. están en el canal 6. El router lo tengo en el canal 6 y la tarjeta también (2.437 GHz).
    * You're too far from the AP. Get closer, or lower the transmit rate. Está en el cuarto de al lado.

¿Alguien podría decirme qué más puedo hacer? He intentado además Des-autenticar a uno de los clientes conectados. Según la teoría, el cliente debería desconectarse y en la reconexión le capturo los IVs. Pero no :P no captura nada, y encima de todo el cliente ya no se puede conectar normalmente; me toca reiniciar el AP y luego de ello el cliente puede volver a conectarse.

El caso es que intenté no venir a pedir ayuda, pero dado que llevo dos días y no he podido, pues me rindo.

Un saludo, y gracias por leer.

Datos adicionales

Uso Gentoo Linux con kernel 2.6.27. Los drivers son los últimos (compat-wireless-2009-01-12), y le aplique correctamente los parches para habilitar la inyección. Mi AP es un Linksys WRT54GS. La versión del aircrack es 1.0 rc1. Al ejecutar lsmod:

Código:
Module                  Size  Used by
iwlagn                 71820  0
iwlcore                84480  1 iwlagn
mac80211              162608  2 iwlagn,iwlcore
cfg80211               39088  3 iwlagn,iwlcore,mac80211

El lspci de mi tarjeta:

Código:
02:00.0 Network controller: Intel Corporation Device 4229 (rev 61)
Subsystem: Intel Corporation Device 1100
Flags: bus master, fast devsel, latency 0, IRQ 377
Memory at f4000000 (64-bit, non-prefetchable) [size=8K]
Capabilities: [c8] Power Management version 3
Capabilities: [d0] Message Signalled Interrupts: Mask- 64bit+ Queue=0/0 Enable+
Capabilities: [e0] Express Endpoint, MSI 00
Capabilities: [100] Advanced Error Reporting <?>
Capabilities: [140] Device Serial Number 73-35-06-ff-ff-5c-21-00
Kernel driver in use: iwlagn
Kernel modules: iwlagn
3  Programación / Java / MOVIDO: Algoritmo tipo worms en: 16 Diciembre 2008, 19:22 pm
El tema ha sido movido a Programación General.

https://foro.elhacker.net/index.php?topic=238371.0
4  Programación / Java / MOVIDO: mi primera ves en: 1 Agosto 2008, 23:46 pm
El tema ha sido movido a PHP.

http://foro.elhacker.net/index.php?topic=222718.0
5  Programación / PHP / Cómo crear permalinks agradables en: 28 Junio 2008, 00:23 am
Umm... esto lo escribí ya hace un rato, pero que más da (además que hace mucho que no aporto nada al foro). La idea de este artículo es mostrar un sencillo ejemplo de cómo hacer que los links de nuestras aplicaciones web sean "bonitos". De tal manera no tendríamos links como estos:

http://www.sitio.com/index.php?accion=consultar&objetivo=personas

Sino algo estéticamente más agradable como:

http://www.sitio.com/personas/

¿Qué necesito?

Es necesario tener en cuenta los prerrequisitos para poder hacer esto. Para este ejemplo voy a suponer que la aplicación la estás haciendo sobre el servidor Apache, y que estás programando en PHP+MySQL. Necesitas:

  • Manejar la mayor parte del trabajo con el archivo index.php. Esto más que un requisito es un consejo. Cuando estés desarrollando aplicaciones en PHP es recomendable que la mayor parte del sistema tenga que ser procesado inicialmente por este archivo, el cual se encargará de manejar todas las peticiones y utilizar los módulos que se necesiten. Esto, por supuesto, NO quiere decir que TODO el código vaya dentro del archivo index.php; una buena práctica es separar el código en módulos y llamarlos con funciones como include o require.
  • Es necesario tener instalado el mod_rewrite, el cual se utilizará desde un archivo .htaccess. El ModRewrite es un módulo para Apache que por lo general se configura (definir reglas) en el archivo httpd.conf, pero es posible poner una configuración ModRewrite en cualquier directorio de nuestro servidor web dentro del archivo .htaccess.
  • Puesto que de acuerdo al string que pasemos en la URL se debe determinar qué hacer, es necesario hacer algo de esto:
    • Hacer que dentro de la base de datos la llave primaria de la tabla a consultar sea una cadena de texto, ó
    • Hacer otro campo en la tabla de MySQL aparte de la llave primaria

Ejemplo
Para nuestro ejemplo necesitamos un servidor Apache con ModRewrite, PHP y MySQL. Lo primero es crear la base de datos, así:

Código
  1. CREATE DATABASE ejemplo;
  2. CREATE TABLE contenidos(
  3. id INT(5) PRIMARY KEY AUTO_INCREMENT,
  4. titulo VARCHAR(50),
  5. contenido VARCHAR(1000),
  6. slug VARCHAR(50));

Luego creamos una carpeta dentro del htdocs de apache, en donde pondremos los archivos de nuestro ejempo (mkdir /opt/lampp/htdocs/ejemplo). Hecho esto, lo siguiente es crear el archivo .htaccess, en el cual indicaremos las reglas del ModRewrite. En nuestro ejemplo tenemos algo como esto:

Código
  1. # Esto es un comentario
  2. <IfModule mod_rewrite.c>
  3. RewriteEngine On
  4. RewriteBase /ejemplo/
  5. RewriteCond %{REQUEST_FILENAME} !-f
  6. RewriteCond %{REQUEST_FILENAME} !-d
  7. RewriteRule . /ejemplo/index.php [L]
  8. </IfModule>

Una explicación breve de este .htaccess:

  • En los archivos .htaccess es posible hacer comentarios anteponiendo el simbolo numeral (almohadilla como dicen en España)
  • <IfModule mod_rewrite.c>: Esta instrucción funciona como un if, que verifica si el ModRewrite está instalado.
  • RewriteEngine On, activa el ModRewrite.
  • RewriteBase /ejemplo/, asigna el directorio base donde trabajará el ModRewrite
  • RewriteCond %{REQUEST_FILENAME} !-f y RewriteCond %{REQUEST_FILENAME} !-d, la instrucción RewriteCond funciona como una condición que en caso de ser verdadera hará que se ejecute una regla (RewriteRule) del ModRewrite. Funciona con expresiones regulares. En este caso lo que estamos verificando es si la petición se trata de un archivo (-f) o directorio (-d) que no (!) existe, en cuyo caso ejecuta la RewriteRule de abajo. Pero ¿para qué esto? Dado que las peticiones que hacemos usando URL bonitas no existen físicamente en el servidor, podemos aprovecharlas para indicar que dichas URL las manejará el archivo index.php, es decir, si por ejemplo hacemos una consulta como:
    http://www.sitio.com/link-agradable
    y en dicho servidor no existe ninguna carpeta o archivo que tenga el nombre link-agradable, el control de dicha petición se enviará al archivo index.php.
  • RewriteRule . /ejemplo/index.php [L], ejecuta la regla que en este caso hace que el control de la aplicacion pase al archivo index.php, el cual se encargará de analizar la URL y realizar las operaciones adecuadas. La instrucción [L] hace que cualquier otra regla por debajo de esa linea no se cumpla.
  • </IfModule>, cerramos nuestro if.
Vamos ahora con nuestro archivo index.php:

Código
  1. <?php
  2.   //URL base de la aplicacion
  3.   $base = "http://localhost/ejemplo/";
  4.   //Crear la conexion a la base de datos
  5.   $conexion = mysql_connect("localhost", "root", "");
  6.   mysql_select_db("ejemplo", $conexion);
  7.   //Si se requiere unicamente el index
  8.   if(("http://".$_SERVER['HTTP_HOST'].$_SERVER['REQUEST_URI']) == $base ||
  9.      basename($_SERVER['REQUEST_URI']) == "index.php")
  10.      $contenido = "Lo que vaya en el index por defecto";
  11.   else {
  12.      $id = $_GET["id"];
  13.      //Si es una URL fea-asquerosa...
  14.      if(!empty($id))
  15.         $consulta = mysql_query("SELECT contenido FROM contenidos WHERE id = $id", $conexion);
  16.      //Si es una URL bonita...
  17.      else
  18.      {
  19.         //Obtener el nombre clave
  20.         $slug = basename($_SERVER['REQUEST_URI']);
  21.         $consulta = mysql_query("SELECT contenido FROM contenidos WHERE slug = '$slug'", $conexion);
  22.      }
  23.      //Si la consulta es correcta...
  24.      if(mysql_num_rows($consulta) > 0)
  25.         $contenido = mysql_result($consulta, 0, 0);
  26.      //Informar del terrible error
  27.      else
  28.         $contenido = "Lo que est&aacute;s buscando no existe :P ";
  29.   }
  30. ?>
  31. <html>
  32. <head><title>Un ejemplo</title></head>
  33. <body><?php echo $contenido ?></body>
  34. </html>
  35.  

  • Línea 3: es recomendable para este tipo de aplicaciones (y para casi todas en general), que tengamos una URL fija definida para nuestra aplicación. En este caso almacenamos el string  http://localhost/ejemplo/ en la variable  $base.
  • En las líneas 5 y 6 creamos la conexión a la base de datos.
  • En el if de la línea 8 verificamos si la petición HTTP es para la raiz de nuestro proyecto (llamar simplement al index.php), de lo contrario...
  • En las líneas 12 y 14 verificamos si se trata de una petición GET normal, en la que pasamos pares variable-valor dentro de la URL. En cuyo caso se realiza una consulta a la base de datos tomando en cuenta las variables GET (línea 15).
  • Si la peticion está formada como una URL bonita, creamos una variable llamada $slug que contiene el nombre base de la URI (línea 20), es decir, si la peticion es http://www.sitio.com/link-agradable, el nombre base de la URI es link-agradable. Posteriormente, en la línea 21 hacemos una consulta en la base de datos buscando un registro que contenga dicho slug.
  • En la línea 24 verificamos si la consulta ejecutada anteriormente contiene registros, en cuyo caso pone el contenido en la variable $contenido. Sino, se mete en esa variable un mensaje que dice que no se encontró el registro.

Hecho esto, nuestra aplicación tendrá el siguiente comportamiento:

La aplicación por defecto:



Una consulta a la antigua (URL fea):



Una consulta estéticamente más bonita:



Cuando no encuentra un registro:



Enlaces

P.d. El código es SOLO de ejemplo. Si hacen algo muy parecido podría ser vulnerable, por ejemplo, a inyecciones SQL. En sus aplicaciones tengan cuidado con eso.
P.d. Sobra decir que pueden hacer lo que quieran con el mini-tutorial (copiar, modificar, etc.) con o sin ánimo de lucro. Siempre y cuando se referencie la fuente ;)
6  Media / Juegos y Consolas / Como se llama este juego? en: 28 Mayo 2008, 23:34 pm
Hola...

Quisiera "jugar un jueguito" que jugaba en la infancia (en mi Family), por cosas de nostalgia y eso, pero no recuerdo su nombre. Podría alguien ayudarme?

La descripcion del juego es:

* Es de esos que el control era cuadrado, y solo tenia los botones A, B, y direccionales (lo digo mas que todo para que recuerden lo viejo que es)
* Uno es un soldadito con una pinche pistolita
* Los graficos no son buenos... bueno, para la epoca eran buenos XD
* El soldadito se podia montar en tanques y disparar y matar y hasta el putas
* Veias todo el terreno y todo el cuerpo del muñequito mientras ibas caminando (generalmente hacia arriba). La "camara" era como si estuvieras viendo desde el cielo.

Y pues no recuerdo mas... Alguien lo recuerda?
7  Programación / Java / MOVIDO: mejorar script anti Hoygan en: 31 Marzo 2008, 16:13 pm
El tema ha sido movido a Scripting.

http://foro.elhacker.net/index.php?topic=206597.0
8  Programación / Java / MOVIDO: Ayuda con el spoiler en: 17 Enero 2008, 15:18 pm
Java != javascript. El tema ha sido movido a Dudas Webmasters.

http://foro.elhacker.net/index.php?topic=196119.0
9  Programación / PHP / [SOLUCIONADO] Notificaciones automáticas en: 8 Enero 2008, 18:38 pm
Hola a todos...

Tengo un sistema de información hecho en MySQL y accesado desde PHP. La cosa es que me gustaría que cuando se cumpliese una condición en la base de datos, (específicamente, cuando una fecha sea igual a X), se enviára automáticamente un correo a cierta persona.

La cosa es que no tengo idea de que hacer... alguna vez leí acerca de los Triggers, pero no se si sirvan en este caso. También prodría hacer alguna aplicación a parte (ya no a nivel web, sino de escritorio) que consultara la base de datos una vez al día y se fijara si la condición se cumple o no...

Pero no sé cual es la mejor opción. Según sus experiencias ¿qué debería hacer? Lo otro es que la base de datos no se va a estar actualizando muy seguido, sino cada mes, por mucho.

Un saludo!
Y gracias por leer!
10  Media / Diseño Gráfico / ¿como le redusco el peso a algunas imagenes? en: 16 Diciembre 2007, 14:05 pm
La verdad no tengo ni idea de diseño gráfico, ni el uso de herramientas para la edición de imágenes. El caso es que tengo algunas imagenes en formato GIF y PNG, y me gustaría saber cómo puedo reducir el peso de las imágenes, sin afectar mucho su calidad.

Como uso Gnu/Linux solo cuento con el Gimp y con Inskape para editar las imágenes. ¿Alguien puede darme una mano?

Gracias.
Páginas: [1] 2 3 4
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines