package com.berthou.test.pdf ;
 
import java.io.*;
import java.security.*;
import java.security.cert.Certificate;
import java.util.ArrayList;
import java.util.Calendar;
 
import com.lowagie.text.*;
import com.lowagie.text.pdf.*;
 
public class test_pdf  {
	/**
	 * Name of the PDF document
	 */
	static String dirname  = "D:\\" ;// "D:\\"
	static String fname  = "HelloWorld_sign" ;
 
	public static void main(String[] args) {
		try {
			test_pdf.verifyPdf() ;
		}
		catch(Exception e) {
			System.err.println(e.getMessage());
		}
	}
 
	public static final boolean verifyPdf()
                   throws IOException, DocumentException, Exception
	{
		KeyStore kall = PdfPKCS7.loadCacertsKeyStore();
 
		PdfReader reader = new PdfReader(dirname + fname +".pdf");
		AcroFields af = reader.getAcroFields();
 
		// Search of the whole signature
		ArrayList names = af.getSignatureNames();
 
		// For every signature :
		for (int k = 0; k < names.size(); ++k) {
		   String name = (String)names.get(k);
  		   // Affichage du nom
		   System.out.println("Signature name: " + name);
		   System.out.println("Signature covers whole document: "
                                + af.signatureCoversWholeDocument(name));
  		   // Affichage sur les revision - version
		   System.out.println("Document revision: " + af.getRevision(name) + " of "
                                + af.getTotalRevisions());
		   // Debut de l'extraction de la "revision"
		   FileOutputStream out = new FileOutputStream("d:\\revision_"
                                + af.getRevision(name) + ".pdf");
		   byte bb[] = new byte[8192];
		   InputStream ip = af.extractRevision(name);
		   int n = 0;
		   while ((n = ip.read(bb)) > 0) out.write(bb, 0, n);
		   out.close();
		   ip.close();
		   // Fin extraction revision
 
		   PdfPKCS7 pk = af.verifySignature(name);
		   Calendar cal = pk.getSignDate();
		   Certificate pkc[] = pk.getCertificates();
		   // Information about the certificat, le signataire
		   System.out.println("Subject: "
                                + PdfPKCS7.getSubjectFields(pk.getSigningCertificate()));
		   // Le document à t'il ete modifié ?
		   System.out.println("Document modified: " + !pk.verify());
 
		   // Is the certificate avaible ? Be carefull we search the chain of certificat
		   Object fails[] = PdfPKCS7.verifyCertificates(pkc, kall, null, cal);
		   if (fails == null)
		       System.out.println("Certificates verified against the KeyStore");
		   else
		       System.out.println("Certificate failed: " + fails[1]);
		}
		return true ;
	}
}

package com.berthou.web.filtre;
 
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
 
public final class StatsFilter implements Filter {
    private FilterConfig filterConfig = null;
    private String appli = "" ;
 
    public void doFilter(ServletRequest request, ServletResponse response,
        FilterChain chain) throws IOException, ServletException {
        if (filterConfig == null)  return;
 
        String key = "" ;
    	long startTime = System.currentTimeMillis();
        try {
    		key = appli + ((HttpServletRequest)request).getServletPath() ;
    		// On ajoute la page dans la liste des pages en cours
    		MonitorJsp.action( MonitorJsp.ACT_ADD, key, 0) ;
    		chain.doFilter(request, response);
    		// On supprime la page dans la liste des pages en cours (+temsp d'execution)
    		MonitorJsp.action( MonitorJsp.ACT_DEL, key, (System.currentTimeMillis() - startTime) ) ;
        } catch (IOException io) {
    		// Une erreur ce produit => on la trace puis on la renvoie
    		MonitorJsp.action( MonitorJsp.ACT_ERR, key, (System.currentTimeMillis() - startTime) ) ;
    		throw io ;
        } catch (ServletException se) {
    		// Une erreur ce produit => on la trace puis on la renvoie
    		MonitorJsp.action( MonitorJsp.ACT_ERR, key, (System.currentTimeMillis() - startTime) ) ;
    		throw se ;
        }
    }
    /**
     * Lecture des paramètres d'exécution (dans web.xml)
     *  Ici uniquement la zone APPLICATION
     */
    public void init(FilterConfig filterConfig) throws ServletException {
	this.filterConfig = filterConfig;
	appli = filterConfig.getInitParameter("APPLICATION") ;
    }
 
    public void destroy() {
	this.filterConfig = null;
    }
}

package com.berthou.web.filtre;
 
import java.text.SimpleDateFormat;
import java.util.*;
import java.io.* ;
 
/**
 * Classe de suppervision permettant de suivre l'état de certains objets
 * c'est un classe <b>static</b>
 *
 * @author rberthou
 *
 */
public class MonitorJsp {
	public static final String version = "MonitorJsp V1.00 du 4 Septembre 2008";
 
	static protected Hashtable map = new Hashtable(100);
 
	static final int ACT_ADD = 1 ;
	static final int ACT_DEL = 2 ;
	static final int ACT_ERR = 5 ;
 
    public static synchronized void action(int act, String key, long delay) {
 
    	ItemMonitor itm = (ItemMonitor)map.get(key) ;
    	if ( itm == null ) {
    		if (act == ACT_ADD) {
    			itm = new ItemMonitor() ;
    			map.put(key, itm) ;
    		}
    	} else {
			if (act == ACT_ADD) itm.add() ; 	       else
   			if (act == ACT_DEL) itm.remove(delay) ; else
   			if (act == ACT_ERR) itm.error(delay) ;
    	}
    }
    ..... [CUT] ....
  }

package com.berthou.web.filtre;
 
public class ItemMonitor {
	private long nbrun  = 0  ; // Nombre d'execution
	private long nbact = 0 ;   // Nombre de page active
	private long nberr = 0 ;    // Nombre d'erreur
	private long mints = 0 ;    // Temps min
	private long maxts = 0 ;   // Temps Max
	private long lastAcc = 0 ; // date last exec
 
	/**
	 * Constructeur
	 */
	public ItemMonitor() {
		this.add() ;
	}
 
	public void reset() {
		nbrun  = 0  ;
		nberr = 0 ;
		mints = 0 ;
		maxts = 0 ;
	}
 
	public void add() {
		nbact++ ;
		lastAcc = System.currentTimeMillis() ;
	}
 
	public void remove(long delay) {
		nbrun++ ;
		nbact-- ;
 
		sumts += delay ;
		if (mints < 1 || delay < mints) mints = delay ;
		if (delay > maxts) maxts = delay ;
	}
 
	public void error(long delay) {
		nberr++ ;
		nbact-- ;
	}
      ..... [CUT] .....
}

    <filter>
      <filter-name>StatsFilter</filter-name>
      <filter-class>com.berthou.web.flitre.StatsFilter</filter-class>
      <init-param>
          <param-name>APPLICATION</param-name>
          <param-value>TEST1</param-value>
      </init-param>
    </filter>
 
    <filter-mapping>
       <filter-name>StatsFilter</filter-name>
       <url-pattern>*.jsp</url-pattern>
    </filter-mapping>

<%@ import="com.berthou.web.filtre.*,java.util.*"%>
<%
	// Get iterator for keys in HashMap
	Hashtable monitorSession = (Hashtable)MonitorJsp.cloneIt("b");
	Iterator sessionIter     = monitorSession.keySet().iterator();
	String id = "" ;
	ItemMonitor itm = null ;
%>
<table><thead><tr>
  <th>id</th><th>act</th><th>run</th><th>err</th><th>last</th><th>min/max</th><th>Sum</th>
</tr></thead>
<tbody><%
while(sessionIter.hasNext() ) {
  id = (String)sessionIter.next();
  itm = (ItemMonitor)monitorSession.get(id);
  try
  {
		%><tr valign="top"><td ><%=id%></td><%=itm.toHtmlString()%></tr><%
  }
  catch ( java.lang.IllegalStateException ie ) {
  }
}
%>
</tbody></table>

<%@ page language="java" import="com.berthou.sql.*"%>
<%
java.sql.Connection conn = .... ; // Initialize you connection
 
// Load a hard coded liste
MemoryTable.loadListe("TEST_L_ETAT","    = ;V=Valide;E=En erreur;I=Incomplete;" ) ;
 
// Load a SQL Query liste
// Research of the service code and of the description of the actifs service.
String sql = "select cdserv, libelle from service where status = 'O' " ;
MemoryTable.loadQuery(conn, "TBL_SERV",sql ) ;
%>

<%@ page language="java" import="com.berthou.sql.*"%>
....
<% String service = "1305" ; %>
Service : <%=service%> - <%=MemoryTable.getValue("TBL_SERV", service)%>
(affiche Service : 1305 - Libelle du service1305)
 
Service :
<select name="service"><%=MemoryTable.getListe("TBL_SERV", service)%></select>
(build a combobox by activating the asked service)

package com.berthou.sql;
 
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Hashtable;
import java.util.StringTokenizer;
import java.util.Vector;
 
import org.apache.log4j.Logger;
 
/**
 * @author rberthou
 *
 * Creating 3 févr. 2001
 * Package  com.berthou.sql
 * Projet   tools
 * -------+------------+-------------------------------------------------------------------------
 *   Ver  | Date       | Comments
 * -------+------------+-------------------------------------------------------------------------
 *  2.00  | 04/04/2006 | List's add and radio button (+ comments)
 *  1.00  | 03/02/2001 | Creation
 * -------+------------+-------------------------------------------------------------------------
 */
public class MemoryTable {
 
	private static final Logger logger = Logger.getLogger(MemoryTable.class);
 
	static protected Hashtable h = new Hashtable(10, 1);
 
	/**
	 * Reload of the data of a guery
	 *
	 * @param Connection
	 *            conn : used connection
	 * @param String
	 *            tableName : Name of the Query
	 * @param String
	 *            Sql : Ordre SQL à executer
	 * @param boolean
	 *            tr : true if trim colonne code
	 *
	 * @return int rc : nombre d'enregistrements chargés
	 */
	static public synchronized int reloadQuery(Connection conn,
			String tableName, String sql, boolean tr) throws SQLException {
		/* Si la table est déja chargé on la recharge */
		freeTable(tableName);
 
		return loadQuery(conn, tableName, sql, tr);
	}
 
	/**
	 * rechargement des données d'un query
	 *
	 * @param Connection
	 *            conn : Connexion utilisée
	 * @param String
	 *            tableName : Nom du Query
	 * @param String
	 *            Sql : Ordre SQL à executer
	 *
	 * @return int rc : nombre d'enregistrements chargés
	 */
	static public synchronized int reloadQuery(Connection conn,
			String tableName, String sql) throws SQLException {
		return reloadQuery(conn, tableName, sql, false);
	}
 
	/**
	 * chargement des données d'une table
	 *
	 * @param Connection
	 *            conn : Connexion utilisée
	 * @param String
	 *            tableName : Nom du Query
	 * @param String
	 *            Sql : Ordre SQL à executer
	 *
	 * @return int rc : nombre d'enregistrements chargés
	 */
	static public synchronized int loadQuery(Connection conn, String queryName,
			String sql) throws SQLException {
		return loadQuery(conn, queryName, sql, false);
	}
 
	/**
	 * chargement des données d'une table
	 *
	 * @param Connection
	 *            conn : Connexion utilisée
	 * @param String
	 *            tableName : Nom du Query
	 * @param String
	 *            Sql : Ordre SQL à executer
	 * @param boolean
	 *            isTrim : Vrai si colonne code a trim
	 *
	 * @return int rc : nombre d'enregistrements chargés
	 */
	static public synchronized int loadQuery(Connection conn, String queryName,
			String sql, boolean isTrim) throws SQLException {
		if (isLoaded(queryName))
			return ((Vector) h.get(queryName)).size();
 
		int rc = 0;
		Vector v = new Vector(10, 5);
 
		try {
			Statement stmt = conn.createStatement();
 
			/* Execution */
			ResultSet rs = stmt.executeQuery(sql);
			if (rs != null) {
				ResultSetMetaData rsdt = rs.getMetaData();
				/* Si utile recherche de la liste des colonnes */
				int K = rsdt.getColumnCount();
				/* Lecture des données et mémorisation dans un Vecteur */
				while (rs.next()) {
					String[] s = new String[K];
					for (int I = 0; I < K; I++) {
						if (I == 0 && isTrim)
							s[I] = rs.getString(I+1).trim();
						else
							s[I] = rs.getString(I+1);
					}
					rc++;
					v.add(s);
				}
				/* Ajout de ce Vecteur dans la HashTable */
				h.put(queryName, v);
				rs.close();
			}
			stmt.close();
		} catch (SQLException e) {
			logger
					.error("unable to fetch table [" + queryName + "] err : "
							+ e);
			throw e;
		} finally {
 
		}
 
		if (rc > 0)
			logger.info("Chargement de la table/query [" + queryName + "] : "
					+ rc);
 
		return rc;
	}
 
	/**
	 * rechargement des données d'une liste
	 *
	 * @param String
	 *            tableName : Nom de la liste
	 * @param String
	 *            valeurs : liste des valeurs
	 *
	 * @return int rc : nombre d'enregistrements chargés
	 */
	static public synchronized int reloadListe(String tableName, String sql) {
		/* Si la table est déja chargé on la recharge */
		freeTable(tableName);
 
		return loadListe(tableName, sql);
	}
 
	/**
	 * rechargement des données d'une liste
	 *
	 * @param String
	 *            tableName : Nom de la liste
	 * @param String
	 *            valeurs : liste des valeurs
	 *
	 * @return int rc : nombre d'enregistrements chargés
	 */
	static public synchronized int loadListe(String tableName, String sql) {
		if (isLoaded(tableName))
			return ((Vector) h.get(tableName)).size();
 
		int rc = 0;
		Vector v = new Vector(5, 2);
		StringTokenizer stoken = new StringTokenizer(sql, ";");
 
		/* Lecture des données et mémorisation dans un Vecteur */
		while (stoken.hasMoreElements()) {
			String[] s = new String[2];
			String token = stoken.nextToken();
			int i = token.indexOf('=');
			s[0] = token.substring(0, i); // cle
			s[1] = token.substring(i + 1); // valeur
			rc++;
			v.add(s);
		}
		/* Ajout de ce Vecteur dans la HashTable */
		h.put(tableName, v);
 
		if (rc > 0)
			logger.info("Chargement de la table/liste [" + tableName + "] : "
					+ rc);
 
		return rc;
	}
 
	/**
	 * Nombre de tables chargées
	 *
	 * @return int r : nombre de table
	 */
	static public synchronized int size() {
		return h.size();
	}
 
	/**
	 * Test si une table est chargée
	 *
	 * @param String
	 *            tableName : Nom de la table
	 *
	 * @return boolean b : oui ou non...
	 */
	static public synchronized boolean isLoaded(String tableName) {
		return h.containsKey(tableName);
	}
 
	/**
	 * libération d'une table
	 *
	 * @param String
	 *            tableName : Nom de la table
	 */
	static public synchronized void freeTable(String tableName) {
		if (h.containsKey(tableName))
			h.remove(tableName);
	}
 
	/**
	 * Lecture des données d'une table
	 *
	 * @param String
	 *            tableName : Nom de la table
	 *
	 * @return Vector v : les données
	 */
	static public synchronized Vector getTable(String tableName)
			throws SQLException {
		return (Vector) h.get(tableName);
	}
 
	/**
	 * Formatage des données d'une table sous forme d'une combobox
	 *
	 * @param String
	 *            tableName : Nom de la table
	 * @param String
	 *            val : Valeur selectionnée
	 *
	 * @return String s : les données (format : &lt;option ... )
	 */
	static public synchronized String getListe(String tableName, String val)
			throws SQLException {
		StringBuffer sb = new StringBuffer("");
		Vector v = getTable(tableName);
 
		if (v != null) {
			int K = v.size();
			String[] s;
			for (int I = 0; I < K; I++) {
				s = (String[]) v.elementAt(I);
				if (s.length > 1) {
					if (s[0].equals(val))
						sb.append("<option value=\"" + s[0] + "\" selected>"
								+ s[1] + "</option>\r\n");
					else
						sb.append("<option value=\"" + s[0] + "\">" + s[1]
								+ "</option>\r\n");
				}
			}
		}
 
		return sb.toString();
	}
 
	/**
	 * Formatage des données d'une table sous forme de radio boutons
	 *
	 * @param String :
	 *            Nom de la zone HTML (name = )
	 * @param String
	 *            tableName : Nom de la table
	 * @param String
	 *            val : Valeur selectionnée
	 * @param String
	 *            after : Le code html a ajouter apres chaque ligne
	 *            (&lt;br/&gt;)
	 *
	 * @return String s : les données (format : &lt;option ... )
	 */
	static public synchronized String getRadio(String nm, String tableName,
			String val, String after) throws SQLException {
		StringBuffer sb = new StringBuffer("");
		Vector v = getTable(tableName);
 
		if (after == null)
			after = "\r\n";
 
		if (v != null) {
			int K = v.size();
			String[] s;
			for (int I = 0; I < K; I++) {
				s = (String[]) v.elementAt(I);
				if (s.length > 1) {
					sb.append("<input type=\"RADIO\" name=\"" + nm + "\" id=\""
							+ nm + "\" value=\"" + s[0] + "\"");
					if (s[0].equals(val))
						sb.append(" checked");
					sb.append(">" + s[1] + "</input>" + after);
				}
			}
		}
 
		return sb.toString();
	}
 
	/**
	 * Lecture d'une valeur
	 *
	 * @param String
	 *            tableName : Nom de la table
	 * @param String
	 *            val : Valeur selectionnée
	 *
	 * @return String s : le libelle
	 */
	static public synchronized String getValue(String tableName, String val) throws SQLException {
		String r = "";
		Vector v = getTable(tableName);
 
		if (v != null) {
			int K = v.size();
			String[] s;
			for (int I = 0; I < K; I++) {
				s = (String[]) v.elementAt(I);
				if (s.length > 1) {
					if (s[0].equals(val)) {
						r = s[1];
						break;
					}
				}
			}
		}
 
		return r;
	}
}

try {
	KeyStore ks = KeyStore.getInstance("Windows-ROOT");
	ks.load(null, null) ;
	java.util.Enumeration en = ks.aliases() ;
 
	while (en.hasMoreElements()) {
		String aliasKey = (String)en.nextElement() ;
		Certificate c = ks.getCertificate(aliasKey) ;
		System.out.println("---> alias : " + sss) ;
		System.out.println("    Certificat : " + c.toString() ) ;
 
		if (aliasKey.equals("myKey") ) {
		      PrivateKey key = (PrivateKey)ks.getKey(aliasKey, "monPassword".toCharArray());
		      Certificate[] chain = ks.getCertificateChain(aliasKey);
		}
	}
 
} catch (Exception ioe) {
	System.err.println(ioe.getMessage());
}