source: fedd/abac-src/ttg/credential/Application.java @ 7321a43

package com.nailabs.abac.credential;

import java.io.*;
import java.util.*;
import java.security.*;
import org.w3c.dom.*;

import org.apache.xml.security.utils.XMLUtils;

/**
 * Generic command-line processing necessary for signing credentials and 
 * marking adsd's with hash digests. Portions borrowed from <a href=
 * "http://isrl.cs.byu.edu">ISRL</a> researcher, Michael Halcrow.
 */
public class Application {
    /** the keystore type is "JKS" by default */
    private static String KEYSTORE = "JKS";
    /** 
     * the command line arguments are not directly accessible to desecents 
     * but may be accessed using the <CODE>flagExists()</CODE> and 
     * <CODE>flagValue()</CODE> methods.
     */
    private String argv[] = null;

    //
    // Shared application fields
    //
    /** flag for compiling in the debugging routines */
    protected static boolean DEBUG = true;
    /** the application name, which should be supplied by descendents */
    protected String name = "foobar";
    /** parsed XML document in a DOM-structured tree */
    protected Document doc;
    protected Element docElement;
    /** output stream defaults to standard output */
    protected PrintStream out = System.out;

    //
    // Shared commmand line option fields
    //
    /** the XML input file */
    protected File inXML;
    /** the XML output file */
    protected File outXML;
    /** the keystore containing key material default instance JKS */
    protected KeyStore keyStore;
    /** the file name and path of the serialize keystore */
    protected String keys = null;
    /** password for keystore. <EMP>this is a BAD security practice</EMP> */
    protected String password = null;
    /** the alias of the signing/verifying key, if any */
    protected String alias = null;
    /** include transform information in XML */
    protected boolean includeTransform = false;
    /** include certificate in XML signature */
    protected boolean includeCert = true;
    /** a boolean for whether to include comments */
    protected boolean noComments = false;

    static {
        org.apache.xml.security.Init.init();
    }

    public Application(String argv[]) {
        this.argv = argv;
    }

    /** 
     * command line parsing method, which searches for two choices (e.g. 
     * <pre>flagValue("-h", "--help")</pre>)
     * @param firstChoice the command line option search term
     * @param secondChoice the command line option search term
     * @returns the next string in argument list from specified flag or null
     */
    protected String flagValue( String firstChoice, String secondChoice ) {
        String toReturn;
        if( ( toReturn = flagValue( firstChoice ) ) == null )
            return flagValue( secondChoice );
        else
            return toReturn;
    }

    /** 
     * search the command line arguments for the specified flag 
     * @param flag the command line option search term
     * @returns the next string in argument list from specified flag or null
     */
    protected String flagValue( String flag ) {
        for( int x = 0; x < argv.length; x++ ) {
            if( argv[x].equals( flag ) ) {
                try {
                    return argv[x+1];
                } catch( Exception e ) {
                    return null;
                }
            }
        }
        return null;
    }

    /** 
     * search command line arguments for a boolean argument.
     * @param firstChoice usually the single dash and character form 
     * @param secondChoice usually a GNU double dashed argument
     * @returns true if found, false is absent
     */
    private boolean flagExists( String firstChoice, String secondChoice ) {
        boolean toReturn;
        if( flagExists( firstChoice ) )
            return true;
        else
            return flagExists( secondChoice );
    }

    /** 
     * search the command line argument for the specified boolean argument.
     * @param flag the search term
     * @returns true if found, false if not found
     */
    private boolean flagExists( String flag ) {
        for( int x = 0; x < argv.length; x++ ) {
            if( argv[ x ].equals( flag ) ) {
                return true;
            }
        }
        return false;
    }

    /** convenience method for constructing a file and catching exceptions */
    private File getFile(String path) {
        try {
            return new File(path);
        } catch(Exception ex) {
            ex.printStackTrace();
        }
        return null;
    }

    /**
     * a generic parsing method for parsing the command line options.
     */
    protected void parseParameters() {
        String inName, outName, keystore;

        if( flagExists( "-h", "--help" ) ) {
            out.print(name);
            out.println(" [options]");
            out.println("Options:");
            out.print("\t-i, --input file");
            out.println("\tInput XML document." );
            out.print("\t-o, --output file");
            out.println("\tOutput XML document." );
            out.print("\t-nc, --no-comments");
            out.println("\tDo not include comments in the digest.");
            out.print("\t-nt, --notransform");
            out.println("\tDo not include transform in signature." );
            out.print("\t-c, --includeCert");
            out.println("\tInclude the signing certificate in signature" );
            out.print("\t-i, --input file");
            out.println("\tInput XML document." );
            out.print("\t-k, --keystore file");
            out.println("\tKey store containing the keys to sign/verify" );
            out.print("\t-a, --alias");
            out.println("\t\tthe key store alias of the signator" );
            out.println();
            System.exit(0);
        }
        // grab the input file
        if((inName = flagValue("-i", "--input" )) == null) { 
            inName = "in.xml"; 
        }
        inXML = getFile(inName);
        // grab the output file
        if((outName = flagValue("-o", "--output")) == null) {
            outName = "out.xml.xml";
        }
        outXML = getFile(outName);
        // grab the password for the command line, if any
        if((password = flagValue("-p","--password")) == null) {
            password = "rtml";
        }
        // load the keystore
        if((keys = flagValue("-k", "--keystore")) == null) {
            keys = "keystore.jks";
        }

        // grab the alias from the command line 
        if((alias = flagValue("-a","--alias")) == null) {
            alias = "rtml";
        }
        includeCert = (flagExists( "-c", "--include-certs"))? true: false;
        noComments  = (flagExists( "-nc", "--no-comments"))? true: false;
        includeTransform = (flagExists( "-nt", "--no-transform"))? true: false;
    }

    /** 
     * loads the keystore from a file, if specified. This method may be 
     * overridden in sub-classes.
     */
    protected void getKeys() {
        if(keys != null) {
            try {
                if( DEBUG ) {
                    System.out.println( "Loading keystore from " + keys);
                }
                FileInputStream fis = new FileInputStream(keys);
                keyStore = KeyStore.getInstance("JKS");
                keyStore.load( fis, password.toCharArray() );
            } catch( Exception e ) {
                e.printStackTrace();
                keyStore = null;
            }
        }
    }
    
    /** parse a file into a DOM object */
    protected void readDoc() {
        javax.xml.parsers.DocumentBuilderFactory dbf =
            javax.xml.parsers.DocumentBuilderFactory.newInstance();
        dbf.setNamespaceAware(true);
        try {
            javax.xml.parsers.DocumentBuilder db = dbf.newDocumentBuilder();
            try {
                doc = db.parse(inXML);
                docElement = doc.getDocumentElement();
            } catch( org.xml.sax.SAXException saxe ) {
                saxe.printStackTrace();
            } catch( java.io.IOException ioe ) {
                ioe.printStackTrace();
            }
        } catch(javax.xml.parsers.ParserConfigurationException pce) {
            pce.printStackTrace();
        }
    }

    /** write the dom object tree into an XML formatted file */
    protected void writeDoc() {
        try {
            FileOutputStream fos = new FileOutputStream(outXML);
            XMLUtils.outputDOMc14nWithComments(docElement,fos);
            fos.close();
        } catch( java.io.FileNotFoundException fnfe ) {
            fnfe.printStackTrace();
        } catch( java.io.IOException ioe ) {
            ioe.printStackTrace();
        }
    }

}