How to list the available algorithms ?

Question

Hi,
I would like to get all the available algorithms so that the user can choose the one he wants.
Is it possible to write a generic function that can encryt/decrypt a file with an algorithm as parameter
Because I've got the following problem : I use this code to list the available algorithms :
public static String[] getCryptoImpls(String serviceType) {       
        Set result = new HashSet();                
        Provider[] providers = Security.getProviders();
        for (int i=0; i<providers.length; i++) {           
            Set keys = providers[ i].keySet();
            for (Iterator it=keys.iterator(); it.hasNext(); ) {
                String key = (String)it.next();
                key = key.split(" ")[0];   
                if (key.startsWith(serviceType+".")) {
                    result.add(key.substring(serviceType.length()+1));
                } else if (key.startsWith("Alg.Alias."+serviceType+".")) {                   
                    result.add(key.substring(serviceType.length()+11));
        return (String[])result.toArray(new String[result.size()]);
    }    I call it as : getCryptoImpls("Cipher");
But some elements of the list are not available !
Other problem :
I encrypt/decrypt files using a password, and when I use different algorithms when encrypting and
decrypting, it works ! Strange ...
I create a key like this :
SecretKey key = SecretKeyFactory.getInstance(algo).generateSecret(keySpec);here is the whole code for you to understand better :
    /*  CLASSE                  : CryptoUtils                                 */
    /*  PACKAGE                 : crypto.utils                                */   
    /*  AUTEUR                  : Guillaume YVON                              */
    /*  CREATION                : 15-07-2005                                  */
    /*  DERNIERE MODIFICATION   : 17-07-2005                                  */
    /*  DESCRIPTION             : gestion du cryptage / d�cryptage            */
package crypto.utils;
import crypto.component.*;
import java.io.*;
import java.util.*;
import java.security.*;
import javax.crypto.*;
import javax.crypto.spec.*;
import java.security.spec.*;
public class CryptoUtils {   
    public static final int ENCRYPT_MODE = 1;
    public static final int DECRYPT_MODE = 2;
    /* ----- D�claration de variables ----- */
    private static Cipher ecipher;
    private static Cipher dcipher;      
    /* Cr�ation d'un vecteur d'initialisation de 8 octets */
    private static byte[] salt = {
        (byte)0xA9, (byte)0x9B, (byte)0xC8, (byte)0x32,
        (byte)0x56, (byte)0x35, (byte)0xE3, (byte)0x03
    /* Compteur pour l'it�ration */
    private static int iterationCount = 19;
    /* Buffer utilis� pour transporter les octets entre les flux */
    private static byte[] buf = new byte[1024];
    /*            PROCEDURE D'INITIALISATION DES CLES DE CRYPTAGE             */
    /* PARAMETRES D'ENTREE                                                    */
    /*      - password => mot de passe pour le cryptage : String              */
    /* PARAMETRES DE SORTIE                                                   */
    /*      - aucun                                                           */
    private static void init(String password,String algo) {
        try {
            /* G�n�ration de la cl� de cryptage � partir du mot de passe */
            KeySpec keySpec = new PBEKeySpec(password.toCharArray(), salt, iterationCount);            
            SecretKey key = SecretKeyFactory.getInstance(algo).generateSecret(keySpec);
            ecipher = Cipher.getInstance(key.getAlgorithm());
            dcipher = Cipher.getInstance(key.getAlgorithm());
            /* Pr�paration des param�tres pour les ciphers */
            AlgorithmParameterSpec paramSpec = new PBEParameterSpec(salt, iterationCount);
            /* Cr�ation des ciphers */
            ecipher.init(Cipher.ENCRYPT_MODE, key, paramSpec);
            dcipher.init(Cipher.DECRYPT_MODE, key, paramSpec);
        } catch (Exception e){ System.err.println(e); }
    /*                   PROCEDURE DE CRYPTAGE / DECRYPTAGE                   */
    /* PARAMETRES D'ENTREE                                                    */
    /*      - mode        => mode de cryptage/decryptage : int                */
    /*      - in          => flux d'entr�e (lecture) : InputStream            */
    /*      - out         => flux de sortie (�criture) : OutputStream         */
    /*      - srcSize     => taille du fichier source : long                  */
    /*      - progressBar => barre de progression                             */
    /* PARAMETRES DE SORTIE                                                   */
    /*      - aucun                                                           */
    private static void crypt(int mode, InputStream in, OutputStream out, long srcSize,
JProgressBarWindow progressBar){
        try {           
            if(mode == ENCRYPT_MODE){
                /* Les octets �crits dans out seront crypt�s */
                out = new CipherOutputStream(out, ecipher);
            }else if(mode == DECRYPT_MODE){
                /* Les octets lus dans in seront d�crypt�s */           
                in = new CipherInputStream(in, dcipher);
            /* Lit dans le texte clair les octets et �crit dans out pour le cryptage */
            int sum = 0;
            int numRead = 0;           
            while ((numRead = in.read(buf)) >= 0) {               
                out.write(buf, 0, numRead);
                sum += numRead;
                Float percent = sum / (new Float(srcSize)) * 100;
                if(progressBar!=null) progressBar.setValue(percent.intValue());               
            out.close();
        } catch (java.io.IOException e) { System.out.println(e); }
    /*             PROCEDURE DE LANCEMENT DU CRYPTAGE/DECRYPTAGE              */
    /* PARAMETRES D'ENTREE                                                    */
    /*      - mode        => mode de cryptage/decryptage : int                */
    /*      - algo        => algorythme � utiliser : String                   */
    /*      - srcFile     => flux d'entr�e (lecture) : String                 */
    /*      - tgtFile     => flux de sortie (�criture) : String               */
    /*      - password    => taille du fichier source : String                */
    /*      - progressBar => barre de progression : JProgressBarWindow        */
    /*      - text        => texte � afficher : String                        */
    /* PARAMETRES DE SORTIE                                                   */
    /*      - aucun                                                           */
    public static void launch(int mode,String algo,String srcFile,String tgtFile,String password,
                                JProgressBarWindow progressBar,String text){
        try {           
            init(password,algo);                                  
            if(progressBar!=null && text!=null) progressBar.setLabelText(text);
            crypt(mode,new FileInputStream(srcFile),new
FileOutputStream(tgtFile),FileUtils.getFileSize(srcFile), progressBar);                           
        } catch (Exception e) {}
    /*      FONCTION QUI RENVOIE LES IMPLEMENTATIONS DISPONIBLES POUR         */
    /*                          UN TYPE DE SERVICE                            */
    /* PARAMETRES D'ENTREE                                                    */
    /*      - serviceType => nom du service                                   */   
    /* PARAMETRES DE SORTIE                                                   */
    /*      - liste des impl�mentations : String[]                            */
    public static String[] getCryptoImpls(String serviceType) {       
        Set result = new HashSet();                
        Provider[] providers = Security.getProviders();
        for (int i=0; i<providers.length; i++) {           
            Set keys = providers[ i].keySet();
            for (Iterator it=keys.iterator(); it.hasNext(); ) {
                String key = (String)it.next();
                key = key.split(" ")[0];   
                if (key.startsWith(serviceType+".")) {
                    result.add(key.substring(serviceType.length()+1));
                } else if (key.startsWith("Alg.Alias."+serviceType+".")) {                   
                    result.add(key.substring(serviceType.length()+11));
        return (String[])result.toArray(new String[result.size()]);
    /*     FONCTION QUI RENVOIE LA LISTE DES TYPES DE SERVICE DISPONIBLES     */   
    /* PARAMETRES D'ENTREE                                                    */
    /*      - aucun                                                           */   
    /* PARAMETRES DE SORTIE                                                   */
    /*      - liste des services : String[]                                   */
    public static String[] getServiceTypes() {
        Set result = new HashSet();           
        Provider[] providers = Security.getProviders();
        for (int i=0; i<providers.length; i++) {           
            Set keys = providers[ i].keySet();
            for (Iterator it=keys.iterator(); it.hasNext(); ) {
                String key = (String)it.next();
                key = key.split(" ")[0];   
                if (key.startsWith("Alg.Alias.")) {                   
                    key = key.substring(10);
                int ix = key.indexOf('.');
                result.add(key.substring(0, ix));
        return (String[])result.toArray(new String[result.size()]);
}Any tip is welcome !
(sorry for the french comments...)

Answer 1

From 11.1 onwards, the below two views are available to identify the jar files loaded into the Database.
JAVAJAR$
JAVAJAROBJECTS$
By querying the JAVAJAR$ view you can know information about the JAR files loaded into the Database and using JAVAJAROBJECTS$ view you can find all the java objects associated with the given JAR file.
These views are populated everytime you use LOADJAVA with "-jarsasdbobjects" option to load your custom java classes.
But unfortunately this feature is available only from 11.1 onwards and there is no clear workaround for above in 10.2 or earlier.