Il m’est arrivé plusieurs fois de devoir lire des mots de passe avec Talend (en JAVA) dans une base de données. Tout programmeur sait qu’on NE STOCK JAMAIS un mot de passe en clair dans une base de données. En général on utilise un hash du mot de passe qui nous permet de comparer les mots de passes sans les connaitre. Ces algorithmes sont unidirectionnel et il est donc impossible de retrouver le mot original (sauf si l’on essaye le brute force avec une table de hash, mais bon cela est très compliqué et n’a pas énormément de chance de succès)

Dans mon cas le problème est qu’il s’agit de mot de passe que l’on doit pouvoir décrypter (ex: mot de passe SMTP, FTP, …), on parle bien de Cryptage et Décryptage et non pas de hachage.

Le tout étant géré par une IHM en PHP, il faut que le PHP encrypt et que la fonction JAVA décrypte. L’algorithme que j’ai choisi pour cela est Blowfish.

1. Encryption coté PHP avec BlowFish

Voici une classe statique permettant de crypter et de décrypter des données avec l’algorithme BlowFish. Les méthodes utilisent les librairies Mcrypt, il vous faudra donc activer cette extension si ce n’est pas déjà le cas (très rare dans une installation par défaut).

<?php
/**
 * BlowFishEncrypter
 * @see: http://www.developpez.net/forums/d649031/java/general-java/apis/securite/blowfish-php-java/
 */
class BlowFishEncrypter {

  public static function encryptBlowfish($cleartext, $key = null)
  {
    $cipher = mcrypt_module_open(MCRYPT_BLOWFISH, '', MCRYPT_MODE_CBC, '');
    $key = substr($key, 0, mcrypt_enc_get_key_size($cipher));
    $iv = '00000000';

    // ajout du Padding.
    $cleartext_length = strlen($cleartext) % 8;
    for ($i = $cleartext_length; $i < 8; $i++)
    {
      $cleartext .= chr(8 - $cleartext_length);
    }

    $cipherText = '';
    // 128-bit blowfish encryption:
    if (mcrypt_generic_init($cipher, $key, $iv) != -1)
    {
      // PHP pads with NULL bytes if $cleartext is not a multiple of the block size..
      $cipherText = mcrypt_generic($cipher, $cleartext);
      mcrypt_generic_deinit($cipher);
    }

    return base64_encode($cipherText);
  }

  public static function decryptBlowfish($encrypted, $key = null)
  {

    $encrypted = base64_decode($encrypted);

    $cipher = mcrypt_module_open(MCRYPT_BLOWFISH, '', MCRYPT_MODE_CBC, '');
    $key = substr($key, 0, mcrypt_enc_get_key_size($cipher));
    $iv = '00000000';

    // 128-bit blowfish encryption:
    if (mcrypt_generic_init($cipher, $key, $iv) != -1)
    {
      // PHP pads with NULL bytes if $cleartext is not a multiple of the block size..
      $cleartext = mdecrypt_generic($cipher, $encrypted);
      mcrypt_generic_deinit($cipher);
    }

    // suppression du padding.
    $pad = ord(substr($cleartext, strlen($cleartext) - 1));
    if ($pad > 0 & $pad <= 8)
    {
      $cleartext = substr($cleartext, 0, strlen($cleartext) - $pad);
    }

    return $cleartext;
  }

}

 2. Encryption coté JAVA avec BlowFish

Voici son homologue en java, une fonction qui cryte et décrypte en JAVA. Vous pouvez utiliser ces fonctions dans Talend par exemple afin de récupérer des mots de passe pour un composant (ex: tFTP, tSSH,…) que vous auriez stocké dans une base de données depuis une IMH en PHP.

import javax.crypto.*;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

/**
 * BlowFishEncrypter
 * @see: http://www.developpez.net/forums/d649031/java/general-java/apis/securite/blowfish-php-java/
 */

public class BlowFishEncrypter {

	public static String encryptBlowfish(String data, String Key) {

		try {

			String iv = "00000000";
			IvParameterSpec ivs = new IvParameterSpec(iv.getBytes());
			SecretKey secretKey = new SecretKeySpec(Key.getBytes(), "Blowfish");

			Cipher cipher = Cipher.getInstance("Blowfish/CBC/PKCS5Padding");
			cipher.init(Cipher.ENCRYPT_MODE, secretKey, ivs);

			BASE64Encoder enc = new BASE64Encoder();

			byte[] encoded = cipher.doFinal(data.getBytes());
			return enc.encode(encoded);
		} catch (Exception e) {
			System.out.println(e);
		}
		return null;

	}

	public static String decryptBlowfish(String data, String Key) {

		try {

			BASE64Decoder dec = new BASE64Decoder();
			byte[] decoded = dec.decodeBuffer(data);

			String iv = "00000000";
			IvParameterSpec ivs = new IvParameterSpec(iv.getBytes());

			SecretKey secretKey = new SecretKeySpec(Key.getBytes(), "Blowfish");

			Cipher cipher = Cipher.getInstance("Blowfish/CBC/PKCS5Padding");
			cipher.init(Cipher.DECRYPT_MODE, secretKey, ivs);
			return new String(cipher.doFinal(decoded), "UTF8");
		} catch (Exception e) {
			System.out.println(e);
		}
		return null;

	}
}

Voila! Ces fonctions vont vous permettre de crypter et décrypter librement des deux cotés : Java et PHP, en transitant par une base de données par exemple.

__________________

Voici la solution pour que wordpress arrete de décorer votre texte avec des balises <p> et <br />.

Le responsable est la fonction wpautop(). A lui s’ajoute wptexturize() qui lui convertit certaines entités texte en entités HTML

Il suffit de désactiver ces deux filtres qui sont appliqués par défaut dans « wp-includes/default-filters.php ». Si vous souhaitez le désactiver uniquement dans un template utilisez ces fonctions :

remove_filter( ‘the_content’, ‘wpautop’);

remove_filter( ‘the_content’, ‘wptexturize’);

Il est important d’utiliser la fonction get_the_content() et pas the_content() car si votre XML utilise la balise CDATA votre XML sera corrompu à cause de cette ligne qui se trouve dans la fonction the_content():

$content = str_replace(‘]]>’, ‘]]&gt;’, $content);

Voici un exemple de template wordpress spécialement concu pour traiter le XML :

<?php

<?php

/**
 * @author samuel.mamet@gmail.com
 */

/*
  Template Name: XML Document
*/ 

// Suppression du filtre qui ajoute des <p> et <br /> intenpestif.
remove_filter( 'the_content', 'wpautop'); 

// Convertit certains caractères après certaines balises. ex : --> devient &#8211;>
remove_filter( 'the_content', 'wptexturize'); 

header('Content-type: text/xml');

echo '<?xml version="1.0" encoding="UTF-8"?>' . "\n";
the_post();
echo get_the_content();
?>

A placer dans le script d’intialisation de votre application. dans ce code les classes doivent être dans un dossier « class » et le nom des fichiers correspondent à [nom classe].class.php. Cette fonction marche peut importe le dossier où elle se trouve tant que les conditions mentionnées précédemment sont respectés.

Cela vous évite d’utiliser une multitude d’include ou require.

function __autoload($class_name) {
    $class_path    = dirname(__FILE__).'/class/' . $class_name . '.class.php';
    if (file_exists($class_path))
      include_once $class_path;
}

1. Dans un premier temps il vous faudra télécharger et désarchiver le dump de tom_database_lite.

2. Créez une nouvelle base de données MySQL

CREATE DATABASE tom;

3. Puis injectez le SQL

mysql -u root -p tom < tom_database_lite.sql

mysql -u root -p tom

mysql> show tables;
+-----------------------+
| Tables_in_tom         |
+-----------------------+
| tom_flow_meter        |
| tom_log_tech          |
| tom_stats             |
| tom_v_finished_jobs   |
| tom_v_unfinished_jobs |
+-----------------------+
5 rows in set (0.00 sec)

4. Ouvrez talend puis sélectionnez votre projet.

5. Cliquez Fichier –> Editer les propriétés du projet

6. Allez à la section Job Settings, puis Stats & Logs. Activez le tStatCatcher, tLogCacher et tFlowMeterCatcher

7. Cochez « Dans la base de données » pour la sortie. Choisissez le type de base de données MySQL et entrez vos paramètres afin que cela ressemble à l’exemple ci-dessous. Afin de pouvoir déployer vos jobs sur d’autres serveurs (recette, preproduction, production par exemple), je vous conseille vivement d’utiliser des paramètres de contextes pour vos champs. Créez donc une base de données dans les métadonnées talend et exportez les paramètres en contexte.

Désormais toute exécution de job sera enregistré par défaut dans la base de données. Grace à ces informations vous pourrez :

• Visualiser l’historique d’exécution
• Connaitre les temps d’exécutions de vos traitements
• Visualiser les flux monitorés

Le  job fill_tom_stats_with_subjobs : Le tLoop exécute 10 fois de suite le job enfant (fill_tom_stats). Il y a donc 1 job enfant et 10 exécutions.

mysql> select * from tom_v_finished_jobs;

+----+----------+------------+----------+-----------------------------+-------------+---------+----------+---------+---------+---------------+
| id | root_pid | date       | time     | job                         | job_version | context | duration | success | subjobs | subjobs_execs |
+----+----------+------------+----------+-----------------------------+-------------+---------+----------+---------+---------+---------------+
| 24 | AiTYGk   | 2011-10-27 | 17:19:52 | fill_tom_stats_with_subjobs | 0.1         | Default | 00:00:01 | success |       1 |            10 |
|  2 | HF4JNi   | 2011-10-18 | 23:32:05 | fill_tom_stats              | 0.1         | Default | 00:00:00 | success |       0 |             0 |
+----+----------+------------+----------+-----------------------------+-------------+---------+----------+---------+---------+---------------+
2 rows in set (0.01 sec)

Les champs subjobs et subjob_execs vous donnent des informations concernant les jobs enfants que vous utilisez. Le premier correspond au nombre de jobs enfants distincts présent dans le traitement et le deuxième correspond au nombre d’exécutions des jobs enfants.

Pour conclure, vous disposez ici des informations les plus importantes pour superviser vos traitements. Cependant les tables de logs vous permettent d’avoir plus d’information, notamment concernant les flux monitorés ainsi que les erreurs d’exécutions. Le logiciel tom(‘nt) affiche ces données. Je tacherai de faire des vues SQL permettant cela dès que le temps me le permet.

Voici les conventions officiels de talend que vous entendrez en formation:

• Les lignes de type flux de données vont de gauche a droite (horizontal)
• Les lignes de type itération vont de gauche à droite (horizontal)
• Les liens de type On subjob OK, Component OK et Reject vont de haut en bas (vertical)
• Dans un tMap les flux principaux sont toujours horizontaux et les flux de type lookup verticaux. Les lookups doivent se trouver en haut du tMap.
• Les flux de type reject sont toujours en bas du composant.

Après la théorie, la pratique!

Variante sur les onComponentOK pour rendre le job plus lisible

Optimisation des traitements

• Utilisez une connexion pour l’input et une autre pour l’output. Ceci permet un gain de performance en évitant de créer et fermer des connexions MySQL inutilement.
• Préférez l’option « enable stream » dans les inputs qui traite de gros volumes afin de gagner du temps. Attention au multiples input (en cas d’itération sur un stream) : dans ce cas créer une autre connexion de type input.
• Utilisez des « extend insert » dans les outputs , voir des bulks insert en cas de grosse volumétrie.
• Préférez des INSERT en vous assurant qu’il n’y ait pas de doublons avec un tMap avant l’insertion plutot que des UPDATE OR INSERT
• En règle générale, maximisez la charge sur le serveur MySQL plutôt que Talend. Attention : S’il y a trop de jointures ceci peut au contraire ralentir le traitement. Cette règle n’est donc pas toujours vrai, mais l’est souvent.
• Ne pas utiliser de tUnPivot sur de gros volumes. Préférer une solution alternative (ex: tMap).
• Réduisez au maximum le nombre de colonnes dans les flux. Ne pas remonter 20 colonnes si vous utilisez que de 2 d’entre elles par exemple.
• Ne JAMAIS utiliser un « SELECT * » dans vos input de base de données (ex: tMySQLInput) car si vous changez l’ordre des colonnes vous vous retrouverez dans le meilleur des cas avec une erreur d’exécution du job et dans la majorité (et pire) des cas avec des données corrompu. Imaginez que vos traitements aient corrompu vos données pendant un mois sans que vous vous en soyez rendu compte! Bon courage pour tout réparer!

Contrôle qualité

• Monitorer les flux important pour permettre de détecter un problème éventuel.
• Utiliser le tWarn pour donner des informations sur l’état d’avancement du job. (Visible dans la supervision que je propose)
• Eviter les outputs dans la console pour les jobs qui sont croné. Cela pollue les logs du batch d’exécution.