Changeset 91


Ignore:
Timestamp:
16/02/05 11:19:32 (16 years ago)
Author:
nbennett
Message:

xml-sig & web services

Location:
dataportal/trunk/acmnerc/src/uk/ac/cclrc/authorisation
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • dataportal/trunk/acmnerc/src/uk/ac/cclrc/authorisation/ACGen.java

    r78 r91  
    1 //package src.uk.ac.cclrc.authorisation; 
    21package uk.ac.cclrc.authorisation; 
    32 
     
    1312import java.util.*; 
    1413 
     14import org.apache.xml.security.utils.*; 
     15import org.apache.xml.security.signature.*; 
     16import org.apache.xml.security.transforms.*; 
     17import org.apache.xml.security.*; 
     18import ac.dl.xml.*; 
     19 
     20import uk.ac.cclrc.authorisation.util.*; 
     21 
     22 
    1523public class ACGen { 
    1624     
     
    2129    private String certFile; 
    2230    private String keyFile; 
    23      
     31    private java.security.cert.X509Certificate x509Cert; 
     32 
    2433    //use for Java KeyStore 
    25     RSAPrivateKey prvKey; 
    26     RSAPublicKey pubKey; 
    27     String algorithm; 
     34    private RSAPublicKey pubKey; 
     35    private String signatureAlgorithm, digestAlgorithm; 
     36    private PrivateKey newPrvKey; 
     37     
    2838    static Logger log = Logger.getLogger(ACGen.class); 
    2939     
    30     public ACGen() 
    31     throws IOException, GeneralSecurityException, InvalidKeyException { 
     40     
     41    public ACGen() throws IOException, GeneralSecurityException { 
    3242        // certFile = System.getProperty("user.home")+File.separator+".globus"+File.separator+"portalcert.pem"; 
    3343        //keyFile = System.getProperty("user.home")+File.separator+".globus"+File.separator+"portalkey.pem"; 
     
    4050    } 
    4151    //not needed 
     52    /* 
    4253    public String getACInString(String attributeString) 
    4354    throws InvalidKeyException, NoSuchAlgorithmException, SignatureException { 
    4455        messageText = attributeString; 
    45         Signature signer = Signature.getInstance(algorithm); 
     56        Signature signer = Signature.getInstance(digestAlgorithm + "with" + signatureAlgorithm); 
    4657        signer.initSign(prvKey); 
    4758        signer.update(messageText.getBytes()); 
     
    6475        return stringEncoding; 
    6576    } 
    66      
     77    */ 
     78     
     79    // NOT USED FOR XML SIGNATURE         
    6780    /** Method generates signature of the message using the pvt key of server */ 
     81    /* 
    6882    public String getSignatureString(String attributeString) throws Exception{ 
    6983        messageText = attributeString; 
    70         Signature signer = Signature.getInstance(algorithm); 
     84        Signature signer = Signature.getInstance(digestAlgorithm + "with" + signatureAlgorithm); 
    7185        signer.initSign(prvKey); 
    7286        signer.update(messageText.getBytes()); 
     
    90104        return stringEncoding; 
    91105    } 
    92      
     106    */ 
     107    
     108    // INCLUDED FOR XML SIGNATURE     
     109    /** Signs an unsigned user attribute list and returns the resulting authorisation token as a JDOM document 
     110     *@param AttributeList attList The user's personal attribute details 
     111     *@exception Exception 
     112     *@return org.jdom.Document The signed authorisation token 
     113     */             
     114    public Document sign( AttributeList attList ) throws Exception 
     115    { 
     116        // get User Access privileges from Database 
     117        org.w3c.dom.Document doc = attList.getDOMDocument(); 
     118        Constants.setSignatureSpecNSprefix(""); 
     119         
     120        String issuerName = attList.getIssuerName(); 
     121        String holder = attList.getHolder(); 
     122        byte[] holderBytes = holder.getBytes(); 
     123        byte[] encodedHolderBytes = org.globus.util.Base64.encode( holderBytes ); 
     124        String encodedHolderString = new String( encodedHolderBytes ); 
     125        File signatureFile = new File( issuerName + "_" + encodedHolderString + "_signature.xml"); 
     126        
     127        XMLSignature sig = null; 
     128 
     129        String baseURI = signatureFile.toURL().toString(); 
     130 
     131        System.out.println("**********************************************"); 
     132        System.out.println("Get signature algorithm type from properties file"); 
     133        System.out.println("//////////////////////////////////////////////"); 
     134        System.out.println( signatureAlgorithm ); 
     135        System.out.println("");          
     136 
     137        //Create an XML Signature object from the document, BaseURI and signature algorithm 
     138        if( signatureAlgorithm.equals( "RSA" ) ) 
     139        { 
     140            sig = new XMLSignature(doc, baseURI, XMLSignature.ALGO_ID_SIGNATURE_RSA); 
     141        } 
     142        else if( signatureAlgorithm.equals( "DSA" ) ) 
     143        { 
     144            sig = new XMLSignature(doc, baseURI, XMLSignature.ALGO_ID_SIGNATURE_DSA); 
     145        } 
     146        else 
     147        { 
     148            throw new GeneralSecurityException( "signature algorithm specified in config file not valid" ); 
     149        } 
     150 
     151        org.w3c.dom.Element root = doc.getDocumentElement(); 
     152 
     153 
     154        //Append the signature element to the root element before signing because 
     155        //this is going to be an enveloped signature (i.e. enveloped by the document). 
     156        //Two other possible forms are enveloping where the document is inside the 
     157        //signature and detached where they are separate. 
     158        root.appendChild(sig.getElement()); 
     159 
     160        sig.getSignedInfo() 
     161         .addResourceResolver(new org.apache.xml.security.samples.utils.resolver 
     162            .OfflineResolver()); 
     163 
     164        System.out.println("**********************************************"); 
     165        System.out.println("Append signature element to token before signing" + 
     166            "because this will be an enveloped signature"); 
     167        System.out.println("//////////////////////////////////////////////"); 
     168        System.out.println(""); 
     169        System.out.println("");          
     170 
     171        //create the transforms object for the Document/Reference 
     172        Transforms transforms = new Transforms(doc); 
     173 
     174        //First we have to strip away the signature element (it's not part of the 
     175        //signature calculations). The enveloped transform can be used for this. 
     176        transforms.addTransform(Transforms.TRANSFORM_ENVELOPED_SIGNATURE); 
     177 
     178        System.out.println("**********************************************"); 
     179        System.out.println("Specify that transform must be used which strips away signature element before signing"); 
     180        System.out.println("//////////////////////////////////////////////"); 
     181        System.out.println(""); 
     182        System.out.println("");          
     183 
     184        //Part of the signature element needs to be canonicalized. It is a kind 
     185        //of normalizing algorithm for XML. 
     186        transforms.addTransform(Transforms.TRANSFORM_C14N_WITH_COMMENTS); 
     187 
     188        System.out.println("**********************************************"); 
     189        System.out.println("Specify canonicalisation transform to be used."); 
     190        System.out.println("//////////////////////////////////////////////"); 
     191        System.out.println(""); 
     192        System.out.println("");          
     193 
     194        //Add the above Document 
     195        sig.addDocument("", transforms, Constants.ALGO_ID_DIGEST_SHA1); 
     196 
     197        System.out.println("**********************************************"); 
     198        System.out.println("Specify digest algorithm to be used."); 
     199        System.out.println("//////////////////////////////////////////////"); 
     200        System.out.println(""); 
     201        System.out.println("");          
     202 
     203        sig.addKeyInfo(x509Cert); 
     204        sig.addKeyInfo(x509Cert.getPublicKey()); 
     205 
     206        System.out.println("**********************************************"); 
     207        System.out.println("Add key information to the signature"); 
     208        System.out.println("//////////////////////////////////////////////"); 
     209        System.out.println(""); 
     210        System.out.println("");          
     211 
     212        sig.sign( newPrvKey ); 
     213 
     214        System.out.println("**********************************************"); 
     215        System.out.println("Perform actual signing"); 
     216        System.out.println("//////////////////////////////////////////////"); 
     217        System.out.println(""); 
     218        System.out.println("");          
     219 
     220        FileOutputStream f = new FileOutputStream(signatureFile); 
     221        //XMLUtils.outputDOMc14nWithComments(doc, f); 
     222        XMLOutputter outputter = new XMLOutputter(); 
     223         
     224        System.out.println("");                         
     225        System.out.println("");                 
     226         
     227        Document jdomDoc = Converter.DOMtoJDOM( doc ); 
     228        outputter.output( jdomDoc, f ); 
     229        f.close();         
     230 
     231        return jdomDoc; 
     232    } 
     233     
     234    // NOT USED FOR XML SIGNATURE     
     235    /* 
     236    public String getDigestString(String attributeString) throws Exception{ 
     237        messageText = attributeString; 
     238        MessageDigest digester = MessageDigest.getInstance(digestAlgorithm); 
     239        digester.update(messageText.getBytes()); 
     240        byte digestBytes[] = digester.digest(); 
     241         
     242        //return Base64 encoding of the signature 
     243        byte[] encode = org.globus.util.Base64.encode(digestBytes); 
     244        BufferedReader reader= new BufferedReader(new InputStreamReader(new ByteArrayInputStream(encode))); 
     245        String stringEncoding = ""; 
     246        try{ 
     247            stringEncoding = reader.readLine(); 
     248            reader.close(); 
     249        } 
     250        catch(Exception e){ 
     251            try{ 
     252                 
     253                reader.close(); 
     254            } 
     255            catch(Exception ignore){} 
     256        } 
     257        return stringEncoding; 
     258    } 
     259    */ 
     260     
     261    /* 
    93262    //use when this works 
    94263    private void openHostKey(String certFile, String keyFile) 
     
    100269        // hostPublicKey = hostCertificate.getPublicKey(); 
    101270    } 
    102      
     271     */ 
     272     
     273    // NOT USED FOR XML SIGNATURE     
     274    /* 
    103275    public boolean verifyAttributeCertificate(String messageText, String signatureText) 
    104276    throws NoSuchAlgorithmException, InvalidKeyException, SignatureException { 
    105277         
    106278        byte[] decode = org.globus.util.Base64.decode(signatureText.getBytes()); 
    107         Signature sigVerifier = Signature.getInstance(algorithm); 
     279        Signature sigVerifier = Signature.getInstance(digestAlgorithm + "with" + signatureAlgorithm); 
    108280        sigVerifier.initVerify(pubKey); 
    109281        sigVerifier.update(messageText.getBytes()); 
    110282        return sigVerifier.verify(decode); 
    111283    } 
    112      
    113      
     284     */ 
     285     
     286    // AMENDED FOR XML SIGNATURE 
     287    /** Extracts the value of the specified element within the DN 
     288     *@exception java.io.IOException 
     289     *@exception java.security.GeneralSecurityException 
     290     */             
    114291    private void loadKeyStore() throws IOException, GeneralSecurityException{ 
    115292         
     
    119296        } 
    120297        catch(IOException ioe){ 
    121             log.error("Unable to find "+Config.getContextPath()+"authorisation.prop",ioe); 
     298            log.error("Unable to find config file: "+Config.getContextPath()+"authorisation.prop",ioe); 
    122299            throw ioe; 
    123300        } 
     
    125302         
    126303        //String keyStoreFileName = System.getProperty("user.home")+File.separator+".keystore"; 
     304        String keyStoreType = prop.getProperty("keystore_type"); 
     305        if( keyStoreType == null ) 
     306        { 
     307            throw new GeneralSecurityException( "The type of keystore is not specified in the config file" ); 
     308        }                 
     309         
    127310        String keyStoreFileName = prop.getProperty("keystore"); 
    128311        String keyStorePasswd = prop.getProperty("keystore_passwd"); 
    129312        String keyStoreAlias = prop.getProperty("keystore_alias"); 
    130         algorithm = prop.getProperty("algorithm"); 
     313        if( keyStoreAlias == null ) 
     314        { 
     315            throw new GeneralSecurityException( "The keystore alias is not specified in the config file" ); 
     316        }                 
     317         
     318        signatureAlgorithm = prop.getProperty("signature_algorithm"); 
     319        if( signatureAlgorithm == null ) 
     320        { 
     321            throw new GeneralSecurityException( "The signature algorithm to be applied to the attribute certificate " + 
     322                "is not specified in the config file" ); 
     323        }                 
     324        /* 
     325        digestAlgorithm = prop.getProperty("digest_algorithm"); 
     326        if( digestAlgorithm == null ) 
     327        { 
     328            throw new GeneralSecurityException( "The digest algorithm to be applied to the attribute certificate " + 
     329                "is not specified in the config file" ); 
     330        }                 
     331        */ 
    131332        // System.out.println(keyStoreFileName); 
    132333        if(keyStoreFileName == null || keyStoreFileName.equals("")) keyStoreFileName = System.getProperty("user.home")+File.separator+".keystore"; 
    133334        if(keyStorePasswd == null || keyStorePasswd.equals("")) keyStorePasswd = "changeit"; 
    134335         
    135         KeyStore keystore = KeyStore.getInstance("JKS"); 
     336        KeyStore keystore = KeyStore.getInstance(keyStoreType); 
    136337        keystore.load(new FileInputStream(keyStoreFileName), keyStorePasswd.toCharArray()); 
    137338        Key key = keystore.getKey(keyStoreAlias, keyStorePasswd.toCharArray()); 
    138339        if(key == null)throw new GeneralSecurityException("No private key loaded"); 
    139         prvKey = (RSAPrivateKey)key; 
     340        newPrvKey = (PrivateKey)key; 
     341        //prvKey = (RSAPrivateKey)key; 
    140342        java.security.cert.Certificate cert = keystore.getCertificate(keyStoreAlias); 
    141         if(key == null)throw new GeneralSecurityException("No certificate loaded"); 
     343         
     344        x509Cert = (java.security.cert.X509Certificate)cert; 
     345         
     346        if(x509Cert == null)throw new GeneralSecurityException("No certificate loaded"); 
    142347        pubKey = (RSAPublicKey)cert.getPublicKey(); 
    143348         
    144349        // NDB - demo-code 
    145350        System.out.println("**********************************************"); 
    146         System.out.println("Get authorisation server's private and public keys from its keystore"); 
    147         System.out.println("//////////////////////////////////////////////"); 
    148         System.out.println( prvKey ); 
    149         System.out.println(""); 
    150         System.out.println(""); 
    151         System.out.println( pubKey ); 
    152         System.out.println(""); 
    153         System.out.println("");          
    154     } 
    155      
     351        System.out.println("Get authorisation server's private and public keys from its keystore to allow creation of digital signature"); 
     352        System.out.println("//////////////////////////////////////////////"); 
     353        System.out.println(""); 
     354        System.out.println("");          
     355    } 
     356    /* 
    156357    public static void main(String args[]) { 
    157358        try { 
     
    160361            String messageString = "This is the string to be tested..."; 
    161362            String signature = acGen.getSignatureString(messageString); 
     363             
    162364            System.out.println(signature); 
    163365             
     
    168370        } 
    169371    } 
     372     */ 
     373     
     374    // INCLUDED FOR XML SIGNATURE 
     375    static { 
     376        org.apache.xml.security.Init.init(); 
     377    } 
     378 
    170379} 
  • dataportal/trunk/acmnerc/src/uk/ac/cclrc/authorisation/AttributeList.java

    r78 r91  
    11/* 
    2  * AttributeCertificate.java 
     2 * AttributeList.java 
    33 * 
    44 * Created on July 16, 2003, 6:31 PM 
     
    2626public class AttributeList { 
    2727     
    28     /** Creates a new blank instance of AttributeCertificate */ 
    29     // public AttributeList() { 
    30     // } 
    31      
    32    /* public AttributeList(String userDn,String facilityName, String issuerDn, String notBefore, String  notAfter) throws ClassNotFoundException,SQLException { 
    33         this.issuerName = facilityName; 
    34         this.holder = userDn; 
    35         this.issuer=issuerDn; 
    36         this.validityNotAfter=notAfter; 
    37         this.validityNotBefore=notBefore; 
    38         this.loadFromDb(userDn,facilityName,issuerDn); 
    39     }*/ 
    4028    static Logger log = Logger.getLogger(AttributeList.class); 
    4129     
    42     // public AttributeList(String version, String userDn, String issuerDn, String issuerName, String signatureAlgorithm, 
    43     // String issuerSerialNumber, int[] notBefore, int[] notAfter, String aDPView, String aWrapperGroup, String aDataAccessGroup) throws ClassNotFoundException,SQLException { NDB 
    44     public AttributeList(String version, String userDn, String issuerDn, String issuerName, String signatureAlgorithm, 
    45       String issuerSerialNumber, int[] notBefore, int[] notAfter, String aDataAccessGroup, String origin) throws ClassNotFoundException,SQLException { 
    46         
    47      
     30    public AttributeList(String version, String userDn, String issuerDn, String issuerName, String issuerSerialNumber, 
     31        int[] notBefore, int[] notAfter, HashSet roleHashSet, String origin) 
     32    { 
    4833        PropertyConfigurator.configure(Config.getContextPath()+"logger.properties"); 
    4934        this.version = version; 
     
    5136        this.issuer=issuerDn; 
    5237        this.issuerName = issuerName; 
    53         this.signatureAlgorithm = signatureAlgorithm; 
    5438        this.issuerSerialNumber = issuerSerialNumber; 
    5539         
    5640        this.validityNotAfter=notAfter; 
    5741        this.validityNotBefore=notBefore; 
    58         // this.aDPView = aDPView; NDB 
    59         // this.aWrapperGroup = aWrapperGroup; NDB 
    60         this.aDataAccessGroup = aDataAccessGroup; 
     42        this.roleSet = roleHashSet; 
     43 
    6144        this.provenance = origin; 
    6245    } 
    63     public AttributeList(org.jdom.Element acInfo) throws Exception { 
     46     
     47    public AttributeList(org.jdom.Element acInfo) throws Exception 
     48    { 
    6449        PropertyConfigurator.configure(Config.getContextPath()+"logger.properties"); 
    65         try { 
    66             parseAttributeList(acInfo); 
    67              
    68         } catch (Exception e) { 
    69             
    70             throw e; 
    71         } 
    72     } 
    73      
    74     public String getAcInfoAsXMLString() throws Exception{ 
    75          
     50        parseAttributeList(acInfo); 
     51    } 
     52     
     53    //NOT CURRENTLY USED 
     54    /* 
     55    public String getAcInfoAsXMLString() throws Exception 
     56    { 
    7657        try { 
    7758            Document doc = this.getJDOMDocument(); 
     
    7960            XMLOutputter outputter = new XMLOutputter(); 
    8061            return outputter.outputString(doc); 
     62     
    8163        } catch (Exception e) { 
    82             log.error("Unable to create AttributeLost as String",e); 
     64            log.error("Unable to create Attribute List as XML String",e); 
    8365            throw e; 
    8466        } 
    85     } 
    86      
     67     
     68    } 
     69     */ 
     70     
     71    // NOT CURRENTLY USED 
    8772    /** This method is used to generate the ACInfo section of the authorisationToken 
    8873     *@param org.w3c.dom.Element  The resultSet Holding the one instance of the user 
    8974     *@exception    java.sql.SQLException 
    9075     */ 
    91     public org.w3c.dom.Element getAcInfoAsW3CElement() throws Exception{ 
    92          
    93          
     76    /* 
     77    public org.w3c.dom.Element getAcInfoAsW3CElement() throws Exception 
     78    {         
    9479        // Convert to XML String and Return 
    95         //XMLOutputter outputter = new XMLOutputter(); 
    96         //return outputter.outputString(doc); 
    9780        try { 
    9881            Document doc = this.getJDOMDocument(); 
     
    10083            org.w3c.dom.Element el = w3cDoc.getDocumentElement(); 
    10184            return el; 
    102         } catch (Exception e) { 
    103             log.error("Unable to create AttributeLost as Element",e); 
    104             throw e; 
    105         } 
    106          
    107     } 
    108      
    109     public Document getJDOMDocument() { 
    110  
    111             Document doc = new Document(); 
    112             Element root = new Element("acInfo"); 
    113              
    114              
    115             //Build XML file 
    116             doc.setRootElement(root); 
    117             //set version 
    118             Element versionElement = new Element("version"); 
    119             versionElement.setText(version); 
    120             //set holder 
    121             Element holderElement = new Element("holder"); 
    122             holderElement.setText(holder); 
    123             //set issuer 
    124             Element issuerElement = new Element("issuer"); 
    125             issuerElement.setText(issuer); 
    126             //set issuer 
    127             Element issuerNameElement = new Element("issuerName"); 
    128             issuerNameElement.setText(issuerName); 
    129             //setissuerSerialNumber 
    130             Element issuerSerialNumberElement = new Element("issuerSerialNumber"); 
    131             issuerSerialNumberElement.setText(issuerSerialNumber); 
    132             //set SignatureAlgorithm 
    133             Element signatureAlgorithmElement = new Element("signatureAlgorithm"); 
    134             signatureAlgorithmElement.setText(signatureAlgorithm); 
    135             //set validity 
    136             Element validityElement = new Element("validity"); 
    137             //set validity not before 
    138             Element validityNotBeforeElement = new Element("notBefore"); 
    139             //turn array into string 
    140             StringBuffer notBefore = new StringBuffer(); 
    141             for(int i = 0;i<validityNotBefore.length;i++){ 
    142                 if(i == (validityNotBefore.length -1)) notBefore.append(validityNotBefore[i]); 
    143                 else notBefore.append(validityNotBefore[i]+" "); 
    144             } 
    145              
    146             validityNotBeforeElement.setText(notBefore.toString()); 
    147             //set validity not after 
    148             Element validityNotAfterElement = new Element("notAfter"); 
    149             StringBuffer notAfter = new StringBuffer(); 
    150             for(int i = 0;i<validityNotAfter.length;i++){ 
    151                 if(i == (validityNotAfter.length -1)) notAfter.append(validityNotAfter[i]); 
    152                 else notAfter.append(validityNotAfter[i]+" "); 
    153             } 
    154              
    155             validityNotAfterElement.setText(notAfter.toString()); 
    156             //set Attributes 
    157             Element attributesElement = new Element("attributes"); 
    158             //set Attributes DP view 
    159             // Element attributesDPViewElement = new Element("DPView"); NDB 
    160             // attributesDPViewElement.setText(aDPView); NDB 
    161             //set Attributes Wrapper Group 
    162             // Element attributesWrapperGroupElement = new Element("wrapperGroup"); NDB 
    163             // attributesWrapperGroupElement.setText(aWrapperGroup); NDB 
    164             //set Attributes Data access Group 
    165             Element attributesDataAccessGroupElement = new Element("dataAccessGroup"); 
    166             attributesDataAccessGroupElement.setText(aDataAccessGroup); 
    167  
    168             //set issuer 
    169             Element provenanceElement = new Element("provenance"); 
    170             provenanceElement.setText(provenance); 
    171              
    172              
    173             //Create XML tree 
    174             root.addContent(versionElement); 
    175             root.addContent(holderElement); 
    176             root.addContent(issuerElement); 
    177             root.addContent(issuerNameElement); 
    178             root.addContent(issuerSerialNumberElement); 
    179             root.addContent(signatureAlgorithmElement); 
    180             validityElement.addContent(validityNotBeforeElement); 
    181             validityElement.addContent(validityNotAfterElement); 
    182             root.addContent(validityElement); 
    183             // attributesElement.addContent(attributesDPViewElement); NDB 
    184             // attributesElement.addContent(attributesWrapperGroupElement); NDB 
    185             attributesElement.addContent(attributesDataAccessGroupElement); 
    186             root.addContent(attributesElement); 
    187             root.addContent(provenanceElement); 
    188             return doc; 
    189          
    190     } 
    191      
    192     public boolean isValid()  { 
    193         try { 
    194              
    195             /*double creationTime = Double.parseDouble(validityNotBefore); 
    196             double validTill = Double.parseDouble(validityNotAfter); 
    197             System.out.println(validTill +" - "+creationTime); 
    198             System.out.println(validTill -creationTime); 
    199             System.out.println(); 
    200             System.out.println((validTill - creationTime)); 
    201             return (validTill - creationTime)/1000;*/ 
    202              
    203             GregorianCalendar notBeforeCal = new GregorianCalendar(validityNotBefore[0],validityNotBefore[1],validityNotBefore[2],validityNotBefore[3],validityNotBefore[4],validityNotBefore[5]); 
    204             GregorianCalendar notAfterCal = new GregorianCalendar(validityNotAfter[0],validityNotAfter[1],validityNotAfter[2],validityNotAfter[3],validityNotAfter[4],validityNotAfter[5]); 
    205             GregorianCalendar now = new GregorianCalendar(); 
    206              
    207             if(now.before(notBeforeCal)) return false; 
    208             if(now.after(notAfterCal)) return false; 
    209             return true; 
    210              
    21185             
    21286        } catch (Exception e) { 
    213             log.error("Unable to check validilty time",e); 
    214             return false; 
    215              
    216         } 
     87            log.error("Unable to create Attribute Certificate as Element",e); 
     88            throw e; 
     89        } 
     90    } 
     91     */ 
     92     
     93    /** This method generates an empty namespace-aware DOM Document 
     94     *@exception java.lang.Exception 
     95     *@return org.w3c.dom.Document an empty DOM Document 
     96     */ 
     97    public org.w3c.dom.Document getDOMDocument() throws Exception 
     98    { 
     99        javax.xml.parsers.DocumentBuilderFactory dbf = javax.xml.parsers.DocumentBuilderFactory.newInstance(); 
     100 
     101        //XML Signature needs to be namespace aware 
     102        dbf.setNamespaceAware(true); 
     103 
     104        javax.xml.parsers.DocumentBuilder db = null; 
     105        org.w3c.dom.Document w3cDoc = null; 
     106         
     107        db = dbf.newDocumentBuilder(); 
     108        w3cDoc = db.newDocument(); 
     109        Document jdomDoc = Converter.DOMtoJDOM( w3cDoc ); 
     110        jdomDoc = populateJDOMDoc( jdomDoc ); 
     111        w3cDoc = Converter.JDOMtoDOM( jdomDoc ); 
     112         
     113        return w3cDoc; 
     114    } 
     115     
     116    /** This method creates an empty Attribute Certificate as a JDOM Document 
     117     *@param org.jdom.Document doc empty JDOM Document to which attribute certificate elements are added 
     118     *@return org.jdom.Document empty Attribute Certificate 
     119     */ 
     120    private Document populateJDOMDoc( Document doc ) 
     121    { 
     122        Element attCert = new Element("attributeCertificate"); 
     123        Element acInfo = new Element("acInfo"); 
     124 
     125        //Build XML file 
     126        doc.setRootElement(attCert); 
     127        //set version 
     128        Element versionElement = new Element("version"); 
     129        versionElement.setText(version); 
     130        //set holder 
     131        Element holderElement = new Element("holder"); 
     132        holderElement.setText(holder); 
     133        //set issuer 
     134        Element issuerElement = new Element("issuer"); 
     135        issuerElement.setText(issuer); 
     136        //set issuer 
     137        Element issuerNameElement = new Element("issuerName"); 
     138        issuerNameElement.setText(issuerName); 
     139        //setissuerSerialNumber 
     140        Element issuerSerialNumberElement = new Element("issuerSerialNumber"); 
     141        issuerSerialNumberElement.setText(issuerSerialNumber); 
     142        //set validity 
     143        Element validityElement = new Element("validity"); 
     144        //set validity not before 
     145        Element validityNotBeforeElement = new Element("notBefore"); 
     146        //turn array into string 
     147        StringBuffer notBefore = new StringBuffer(); 
     148        for(int i = 0;i<validityNotBefore.length;i++){ 
     149            if(i == (validityNotBefore.length -1)) notBefore.append(validityNotBefore[i]); 
     150            else notBefore.append(validityNotBefore[i]+" "); 
     151        } 
     152 
     153        validityNotBeforeElement.setText(notBefore.toString()); 
     154        //set validity not after 
     155        Element validityNotAfterElement = new Element("notAfter"); 
     156        StringBuffer notAfter = new StringBuffer(); 
     157        for(int i = 0;i<validityNotAfter.length;i++){ 
     158            if(i == (validityNotAfter.length -1)) notAfter.append(validityNotAfter[i]); 
     159            else notAfter.append(validityNotAfter[i]+" "); 
     160        } 
     161 
     162        validityNotAfterElement.setText(notAfter.toString()); 
     163        //set Attributes 
     164        Element attributesElement = new Element("attributes"); 
     165 
     166        Element roleSetElement = new Element("roleSet"); 
     167 
     168        Iterator roleSetIt = roleSet.iterator(); 
     169        while( roleSetIt.hasNext() ) 
     170        { 
     171            String role = (String) roleSetIt.next(); 
     172            Element roleElement = new Element( "role" ); 
     173            Element roleName = new Element( "name" ); 
     174            roleSetElement.addContent( roleElement ); 
     175            roleElement.addContent( roleName ); 
     176            roleName.setText( role ); 
     177        } 
     178 
     179        //set issuer 
     180        Element provenanceElement = new Element("provenance"); 
     181        provenanceElement.setText(provenance); 
     182 
     183        //Create XML tree 
     184        attCert.addContent(acInfo); 
     185        acInfo.addContent(versionElement); 
     186        acInfo.addContent(holderElement); 
     187        acInfo.addContent(issuerElement); 
     188        acInfo.addContent(issuerNameElement); 
     189        acInfo.addContent(issuerSerialNumberElement); 
     190        validityElement.addContent(validityNotBeforeElement); 
     191        validityElement.addContent(validityNotAfterElement); 
     192        acInfo.addContent(validityElement); 
     193        attributesElement.addContent( roleSetElement ); 
     194        acInfo.addContent(attributesElement); 
     195        acInfo.addContent(provenanceElement); 
     196 
     197        return doc; 
     198    } 
     199     
     200    // NOT CURRENTLY USED 
     201    public Document getJDOMDocument() { 
     202 
     203        Document doc = new Document(); 
     204        populateJDOMDoc( doc ); 
     205        return doc; 
     206    } 
     207     
     208    /** Used to check the time-validity of an attribute certificate 
     209     *@return boolean whether the attribute certificate is still valid or not 
     210     */ 
     211    public boolean isValid()  { 
     212         
     213        GregorianCalendar notBeforeCal = new GregorianCalendar(validityNotBefore[0],validityNotBefore[1],validityNotBefore[2],validityNotBefore[3],validityNotBefore[4],validityNotBefore[5]); 
     214        GregorianCalendar notAfterCal = new GregorianCalendar(validityNotAfter[0],validityNotAfter[1],validityNotAfter[2],validityNotAfter[3],validityNotAfter[4],validityNotAfter[5]); 
     215        GregorianCalendar now = new GregorianCalendar(); 
     216 
     217        if(now.before(notBeforeCal)) return false; 
     218        if(now.after(notAfterCal)) return false; 
     219        return true; 
    217220    } 
    218221    public void setVersion(String version){ 
     
    222225        return this.version; 
    223226    } 
    224      
    225227    public void setHolder(String holder){ 
    226228        this.holder = holder; 
     
    241243        return this.issuerName; 
    242244    } 
    243     public void setSignatureAlgorithm(String sigAglorithm){ 
    244         this.signatureAlgorithm=sigAglorithm; 
    245     } 
    246     public String getSignatureAlgorithm(){ 
    247         return signatureAlgorithm; 
    248     } 
    249245    public void setIssuerSerialNumber(String serialNumber){ 
    250246        this.issuerSerialNumber=serialNumber; 
     
    265261        return this.validityNotAfter; 
    266262    } 
    267     /* NDB 
    268     public void setDPView(String aDPView){ 
    269         this.aDPView=aDPView; 
    270     } 
    271     public String getDPView(){ 
    272         return this.aDPView; 
    273     } 
    274     public void setWrapperGroup(String aWrapperGroup){ 
    275         this.aWrapperGroup=aWrapperGroup; 
    276     } 
    277     public String getWrapperGroup(){ 
    278         return aWrapperGroup; 
    279     } 
    280      */ 
    281     public void setDataAccessGroup(String aDataAccessGroup){ 
    282         this.aDataAccessGroup=aDataAccessGroup; 
    283     } 
    284     public String getDataAccessGroup(){ 
    285         return aDataAccessGroup; 
    286     } 
    287  
     263    public HashSet getRoleSet(){ 
     264        return roleSet; 
     265    } 
    288266    public void setProvenance(String origin){ 
    289267        this.provenance=origin; 
     
    293271    } 
    294272    
    295      
    296     private void parseAttributeList(Element acInfo) throws Exception { 
    297         try { 
    298              
    299             List elementList = acInfo.getChildren(); 
    300             Iterator iterator = elementList.iterator(); 
    301             String elementName; 
    302             while (iterator.hasNext()) { 
    303                 Element next = (Element) iterator.next(); 
    304                 elementName=next.getName(); 
    305                  
    306                 if(elementName.equals("version")){ 
    307                      
    308                     this.version = next.getText().trim(); 
    309                 } 
    310                 if(elementName.equals("holder")){ 
    311                      
    312                     this.holder = next.getText().trim(); 
    313                 } 
    314                 if(elementName.equals("issuer")){ this.issuer = next.getText().trim(); } 
    315                 if(elementName.equals("issuerName")){this.issuerName = next.getText().trim() ;} 
    316                 if(elementName.equals("issuerSerialNumber")){ this.issuerSerialNumber = next.getText().trim();} 
    317                 if(elementName.equals("signatureAlgorithm")){ this.signatureAlgorithm = next.getText().trim();} 
    318                 if(elementName.equals("validity")){ 
    319                      
    320                     List validityList = next.getChildren(); 
    321                     Iterator validityIterator = validityList.iterator(); 
    322                     while (validityIterator.hasNext()) { 
    323                          
    324                         Element validityNext = (Element) validityIterator.next(); 
    325                         String validityElementName = validityNext.getName(); 
    326                          
    327                         if(validityElementName.equals("notBefore")){ 
    328                             String notB = validityNext.getText().trim(); 
    329                             String[] notBS = notB.split(" "); 
    330                             int[] notBI = new int[notBS.length]; 
    331                             for(int i= 0; i<notBS.length;i++){ 
    332                                 notBI[i] = Integer.parseInt(notBS[i]); 
    333                                  
    334                             } 
    335                             this.validityNotBefore = notBI; 
     273    /** Used to set the fields of the AttributeList object when an unsigned attribute certificate is passed in. 
     274     *@param org.jdom.Element acInfo the attribute certificate  
     275     *@exception java.lang.Exception 
     276     */ 
     277    private void parseAttributeList(Element acInfo) throws Exception 
     278    { 
     279        List elementList = acInfo.getChildren(); 
     280        Iterator iterator = elementList.iterator(); 
     281        String elementName; 
     282        roleSet = new HashSet(); 
     283 
     284        while (iterator.hasNext()) { 
     285            Element next = (Element) iterator.next(); 
     286            elementName=next.getName(); 
     287 
     288            if(elementName.equals("version")){ 
     289 
     290                this.version = next.getText().trim(); 
     291            } 
     292            if(elementName.equals("holder")){ 
     293 
     294                this.holder = next.getText().trim(); 
     295            } 
     296            if(elementName.equals("issuer")){ this.issuer = next.getText().trim(); } 
     297            if(elementName.equals("issuerName")){this.issuerName = next.getText().trim() ;} 
     298            if(elementName.equals("issuerSerialNumber")){ this.issuerSerialNumber = next.getText().trim();} 
     299            if(elementName.equals("validity")){ 
     300 
     301                List validityList = next.getChildren(); 
     302                Iterator validityIterator = validityList.iterator(); 
     303                while (validityIterator.hasNext()) { 
     304 
     305                    Element validityNext = (Element) validityIterator.next(); 
     306                    String validityElementName = validityNext.getName(); 
     307 
     308                    if(validityElementName.equals("notBefore")){ 
     309                        String notB = validityNext.getText().trim(); 
     310                        String[] notBS = notB.split(" "); 
     311                        int[] notBI = new int[notBS.length]; 
     312                        for(int i= 0; i<notBS.length;i++){ 
     313                            notBI[i] = Integer.parseInt(notBS[i]); 
     314 
    336315                        } 
    337                         if(validityElementName.equals("notAfter")){ 
    338                             String notA = validityNext.getText().trim(); 
    339                             String[] notAS = notA.split(" "); 
    340                             int[] notAI = new int[notAS.length]; 
    341                             for(int i= 0; i<notAS.length;i++){ 
    342                                 notAI[i] = Integer.parseInt(notAS[i]); 
    343                                  
    344                             } 
    345                             this.validityNotAfter = notAI; 
    346                              
    347                              
     316                        this.validityNotBefore = notBI; 
     317                    } 
     318                    if(validityElementName.equals("notAfter")){ 
     319                        String notA = validityNext.getText().trim(); 
     320                        String[] notAS = notA.split(" "); 
     321                        int[] notAI = new int[notAS.length]; 
     322                        for(int i= 0; i<notAS.length;i++){ 
     323                            notAI[i] = Integer.parseInt(notAS[i]); 
     324 
    348325                        } 
    349                          
     326                        this.validityNotAfter = notAI; 
    350327                    } 
    351328                } 
    352                  
    353                 if(elementName.equals("attributes")){ 
    354                      
    355                     List attributeList = next.getChildren(); 
    356                     Iterator attributeIterator = attributeList.iterator(); 
    357                     while (attributeIterator.hasNext()) { 
    358                          
    359                         Element attribNext = (Element) attributeIterator.next(); 
    360                         String attribElementName = attribNext.getName(); 
    361                         /* NDB 
    362                         if(attribElementName.equals("DPView")){ 
    363                              
    364                             this.aDPView = attribNext.getText().trim(); 
     329            } 
     330 
     331            if(elementName.equals("attributes")){ 
     332 
     333                List attributeList = next.getChildren(); 
     334                Iterator attributeIterator = attributeList.iterator(); 
     335                while (attributeIterator.hasNext()) { 
     336 
     337                    Element attribNext = (Element) attributeIterator.next(); 
     338                    String attribElementName = attribNext.getName(); 
     339                    if(attribElementName.equals("roleSet")) 
     340                    { 
     341                        List roleSetList = attribNext.getChildren(); 
     342                        Iterator roleSetIterator = roleSetList.iterator(); 
     343                        while( roleSetIterator.hasNext() ) 
     344                        { 
     345                            Element roleSetNext = (Element) roleSetIterator.next(); 
     346                            String roleSetElementName = roleSetNext.getName(); 
     347 
     348                            if( roleSetElementName.equals( "role" ) ) 
     349                            { 
     350                                List roleList = roleSetNext.getChildren(); 
     351                                Iterator roleIterator = roleList.iterator(); 
     352                                while( roleIterator.hasNext() ) 
     353                                { 
     354                                    Element roleNext = (Element) roleIterator.next(); 
     355                                    String roleElementName = roleNext.getName(); 
     356 
     357                                    if( roleElementName.equals( "name" ) ) 
     358                                    { 
     359                                        String role = roleNext.getText().trim(); 
     360                                        roleSet.add( role ); 
     361                                    } 
     362                                } 
     363                            } 
    365364                        } 
    366                         if(attribElementName.equals("wrapperGroup")){ this.aWrapperGroup = attribNext.getText().trim();} 
    367                          */ 
    368                         if(attribElementName.equals("dataAccessGroup")){ this.aDataAccessGroup = attribNext.getText().trim();} 
    369                          
    370365                    } 
    371                     ; 
    372                      
    373                      
    374366                } 
    375                 if(elementName.equals("provenance")){this.provenance = next.getText().trim() ;} 
    376367            } 
     368            if(elementName.equals("provenance")){this.provenance = next.getText().trim() ;} 
     369        } 
    377370             
    378         } catch (Exception e) { 
    379             log.error("Unable to parse AttibuteList",e); 
    380             throw e; 
    381         } 
    382371    } 
    383372     
     
    386375    private String issuer; 
    387376    private String issuerName; 
    388     private String signatureAlgorithm; 
    389377    private String issuerSerialNumber; 
    390378    private int[] validityNotBefore; 
    391379    private int[] validityNotAfter; 
    392      
    393     // private String aDPView; NDB 
    394     // private String aWrapperGroup; NDB 
    395     private String aDataAccessGroup; 
     380    private HashSet roleSet; 
    396381    private String provenance; 
    397      
    398      
    399382} 
  • dataportal/trunk/acmnerc/src/uk/ac/cclrc/authorisation/client/TokenReader.java

    r78 r91  
     1 
    12/* 
    23 * TokenReader.java 
     
    1617import org.globus.gsi.bc.BouncyCastleOpenSSLKey; 
    1718import uk.ac.cclrc.authorisation.*; 
     19import uk.ac.cclrc.authorisation.util.*; 
    1820import org.apache.log4j.*; 
    1921import org.jdom.*; 
     
    2325import java.io.*; 
    2426import org.globus.util.Base64; 
     27import ac.dl.xml.*; 
     28 
     29import org.apache.xml.security.utils.*; 
     30import org.apache.xml.security.signature.*; 
     31import org.apache.xpath.XPathAPI; 
     32import org.apache.xml.security.samples.utils.resolver.OfflineResolver; 
     33import org.apache.xml.security.keys.KeyInfo; 
     34import org.apache.xml.security.c14n.*; 
     35 
    2536 
    2637public class TokenReader { 
     
    3647    RSAPublicKey pubKey; 
    3748     
    38     public TokenReader() 
    39     throws IOException, GeneralSecurityException, InvalidKeyException { 
     49    public TokenReader() throws IOException, CertificateException 
     50    { 
    4051        // certFile = System.getProperty("user.home")+File.separator+".globus"+File.separator+"portalcert.pem"; 
    4152         
     
    4758        PropertyConfigurator.configure(Config.getContextPath()+"logger.properties"); 
    4859        //Using SUN Java Key Store for now 
    49         Properties prop = new Properties(); 
     60        prop = new Properties(); 
    5061        try{ 
    5162            prop.load(new FileInputStream(Config.getContextPath()+"authorisation.prop")); 
    5263        } 
    5364        catch(IOException ioe){ 
    54             log.error("Unable to find "+Config.getContextPath()+"authorisation.prop",ioe); 
     65            log.error("Unable to find config file: "+Config.getContextPath()+"authorisation.prop",ioe); 
    5566            throw ioe; 
    5667        } 
    5768        String filename = prop.getProperty("certificate"); 
    58         if(filename == null) throw new FileNotFoundException("null not found on the system"); 
     69        if(filename == null) throw new FileNotFoundException("keystore certificate not specified in config file"); 
    5970        File certFile = new File(filename); 
    60         if(!certFile.exists()) throw new FileNotFoundException(certFile.getAbsolutePath()+" not found on the system"); 
     71        if(!certFile.exists()) throw new FileNotFoundException("Keystore certificate: " + certFile.getAbsolutePath()+" not found on the system"); 
    6172        InputStream inStream = new FileInputStream(certFile); 
    6273        CertificateFactory cf = CertificateFactory.getInstance("X.509"); 
     
    6576        pubKey = (RSAPublicKey)cert1.getPublicKey(); 
    6677    } 
    67      
     78 
     79    // NOT USED FOR XML SIGNATURE 
    6880    /** Method to verify Attribute Certificate 
    6981     ** @param String attributeCertificate 
    7082     *  @return boolean true/false 
    7183     **/ 
     84    /* 
    7285    public AttributeList getAttributes(org.w3c.dom.Element authorisationToken) throws NoSuchAlgorithmException, InvalidKeyException, SignatureException, InvalidAuthorisationTokenException, Exception { 
    7386        try { 
    7487            DOMBuilder builder = new DOMBuilder(); 
    7588            Element root = builder.build(authorisationToken); 
    76             Element acInfo = root.getChild("acInfo"); 
    77             Element signature = root.getChild("signature"); 
     89            List topElements = root.getChildren(); 
     90            Element acInfo = (Element)topElements.get( 0 ); 
     91            Element signature = (Element)topElements.get( 1 ); 
    7892             
    7993            if (verifyauthorisationToken(acInfo,signature)) { 
     
    92106        } 
    93107    } 
    94      
     108     */ 
     109     
     110    // NOT USED FOR XML SIGNATURE     
    95111    /** Method to verify Attribute Certificate 
    96112     * @param String messageText 
     
    98114     *  @return boolean true/false 
    99115     **/ 
     116    /* 
    100117    public boolean verifyauthorisationToken(String messageText, String signatureText) 
    101118    throws NoSuchAlgorithmException, InvalidKeyException, SignatureException { 
     
    105122        return sigVerifier.verify(signatureText.getBytes()); 
    106123    } 
    107      
     124     */ 
     125 
     126    // NOT USED FOR XML SIGNATURE     
    108127    /** Method to verify Attribute Certificate 
    109128     * @param Element acInfo 
     
    111130     *  @return boolean true/false 
    112131     **/ 
     132    /* 
    113133    private boolean verifyauthorisationToken(Element acInfo, Element signature)   throws NoSuchAlgorithmException, InvalidKeyException, SignatureException   { 
    114134         
    115135        XMLOutputter outputter = new XMLOutputter(); 
    116136        String messageText = outputter.outputString(acInfo); 
    117          
    118         String signatureText = signature.getText(); 
     137        Namespace sigNS = signature.getNamespace(); 
     138        String signatureText = signature.getChild("SignatureValue",sigNS).getText(); 
     139        String sigMethodText = signature.getChild("SignedInfo",sigNS).getChild("SignatureMethod",sigNS).getText(); 
     140        String digestMethodText = signature.getChild("SignedInfo",sigNS).getChild("Reference",sigNS).getChild("DigestMethod",sigNS).getText(); 
    119141        //decode the signiture text 
    120142        byte[] decode = org.globus.util.Base64.decode(signatureText.getBytes()); 
    121143         
    122          
    123          
    124         Signature sigVerifier = Signature.getInstance("SHA1withRSA"); 
     144        Signature sigVerifier = Signature.getInstance( digestMethodText + "with" + sigMethodText ); 
    125145        sigVerifier.initVerify(pubKey); 
    126146        sigVerifier.update(messageText.getBytes()); 
     
    135155         
    136156    } 
    137      
     157     */ 
     158     
     159    // INCLUDED FOR XML SIGNATURE     
     160    /** This method takes a digitally signed authorisation token and extracts the attribute list, 
     161     * i.e. the user's personal attributes 
     162     *@param org.w3c.dom.Element authorisationToken The signed authorisation token 
     163     *@exception java.lang.Exception 
     164     *@exception uk.ac.cclrc.authorisation.client.InvalidAuthorisationTokenException 
     165     *@return uk.ac.cclrc.authorisation.AttributeList the user's personal attributes 
     166     */         
     167    public AttributeList getACInfo(org.w3c.dom.Element authorisationToken) throws InvalidAuthorisationTokenException, Exception { 
     168        
     169        Document jdomAttList = Converter.DOMtoJDOM( authorisationToken.getOwnerDocument() ); 
     170        AttributeList tempAttList = new AttributeList( jdomAttList.getRootElement().getChild("acInfo") ); 
     171        String issuerName = tempAttList.getIssuerName(); 
     172        String holder = tempAttList.getHolder(); 
     173        byte[] holderBytes = holder.getBytes(); 
     174         
     175        byte[] encodedHolderBytes = org.globus.util.Base64.encode( holderBytes ); 
     176        String encodedHolderString = new String( encodedHolderBytes ); 
     177         
     178        String signatureFileName = issuerName + "_" + encodedHolderString + "_signature.xml"; 
     179 
     180        boolean schemaValidate = false; 
     181        
     182        Element acInfo = null; 
     183        DOMBuilder builder = new DOMBuilder(); 
     184        Element root = builder.build(authorisationToken); 
     185        List topElements = root.getChildren(); 
     186        acInfo = (Element)topElements.get( 0 ); 
     187  
     188/* 
     189        Element signatureElement = null;  
     190        signatureElement = (Element)topElements.get( 1 ); 
     191 */ 
     192 
     193  //      final String signatureSchemaFile = "data/xmldsig-core-schema.xsd"; 
     194         
     195        javax.xml.parsers.DocumentBuilderFactory dbf = javax.xml.parsers.DocumentBuilderFactory.newInstance(); 
     196/* 
     197        if( schemaValidate ) 
     198        { 
     199            dbf.setAttribute("http://apache.org/xml/features/validation/schema", Boolean.TRUE); 
     200            dbf.setAttribute( "http://apache.org/xml/features/dom/defer-node-expansion", Boolean.TRUE); 
     201            dbf.setValidating(true); 
     202            dbf.setAttribute("http://xml.org/sax/features/validation", Boolean.TRUE); 
     203        } 
     204*/ 
     205        dbf.setNamespaceAware(true); 
     206        dbf.setAttribute("http://xml.org/sax/features/namespaces", Boolean.TRUE); 
     207 
     208        /* 
     209        if( schemaValidate ) 
     210        { 
     211            dbf.setAttribute( "http://apache.org/xml/properties/schema/external-schemaLocation", 
     212                Constants.SignatureSpecNS + " " + signatureSchemaFile); 
     213        } 
     214         */ 
     215        File f = new File(signatureFileName); 
     216 
     217        System.out.println("**********************************************"); 
     218        System.out.println("Try to verify signature file associated with the authorisation token whose data is to be extracted"); 
     219        System.out.println("//////////////////////////////////////////////"); 
     220        System.out.println(""); 
     221        System.out.println(""); 
     222 
     223        javax.xml.parsers.DocumentBuilder db = dbf.newDocumentBuilder(); 
     224        db.setErrorHandler(new org.apache.xml.security.utils.IgnoreAllErrorHandler()); 
     225 
     226        /* 
     227        if( schemaValidate ) 
     228        { 
     229            db.setEntityResolver(new org.xml.sax.EntityResolver() 
     230            { 
     231                public org.xml.sax.InputSource resolveEntity( String publicId, String systemId) 
     232                  throws org.xml.sax.SAXException 
     233                { 
     234                    if (systemId.endsWith("xmldsig-core-schema.xsd")) 
     235                    { 
     236                        try 
     237                        { 
     238                            return new org.xml.sax.InputSource( 
     239                                new FileInputStream(signatureSchemaFile)); 
     240                        } 
     241                        catch (FileNotFoundException ex) 
     242                        { 
     243                            throw new org.xml.sax.SAXException(ex); 
     244                        } 
     245                    } 
     246                    else 
     247                    { 
     248                        return null; 
     249                    } 
     250                } 
     251            } ); 
     252        } 
     253*/ 
     254        org.w3c.dom.Document doc = db.parse(new java.io.FileInputStream(f)); 
     255 
     256        //org.w3c.dom.Document doc = authorisationToken.getOwnerDocument(); 
     257         
     258        org.w3c.dom.Element nscontext = XMLUtils.createDSctx(doc, "ds", Constants.SignatureSpecNS); 
     259        org.w3c.dom.Element sigElement = (org.w3c.dom.Element) XPathAPI.selectSingleNode( doc, 
     260            "//ds:Signature[1]", nscontext); 
     261        XMLSignature signature = new XMLSignature(sigElement, f.toURL().toString()); 
     262 
     263        signature.addResourceResolver(new OfflineResolver()); 
     264 
     265        KeyInfo ki = signature.getKeyInfo(); 
     266 
     267        if (ki != null) 
     268        { 
     269            X509Certificate cert = ki.getX509Certificate(); 
     270            if (cert != null) 
     271            { 
     272                boolean validSignature = signature.checkSignatureValue(cert); 
     273                if( !validSignature ) 
     274                { 
     275                    log.error( "The XML signature in the authorisation token is invalid" ); 
     276                    throw new InvalidAuthorisationTokenException( "The XML signature in the authorisation token is invalid" ); 
     277                } 
     278                else 
     279                { 
     280                    System.out.println("Signature is valid"); 
     281                } 
     282            } 
     283            else 
     284            { 
     285                PublicKey pk = signature.getKeyInfo().getPublicKey(); 
     286 
     287                if (pk != null) 
     288                { 
     289                    System.out.println("**********************************************"); 
     290                    System.out.println("Try to verify the signature using the public key"); 
     291                    System.out.println("//////////////////////////////////////////////"); 
     292                    System.out.println(""); 
     293                    System.out.println(""); 
     294 
     295                    boolean validSignature = signature.checkSignatureValue( pk ); 
     296                    if( !validSignature ) 
     297                    { 
     298                        log.error( "The XML signature in the authorisation token is invalid" ); 
     299                        throw new InvalidAuthorisationTokenException( "The XML signature in the authorisation token is invalid" ); 
     300                    } 
     301 
     302                } 
     303                else 
     304                { 
     305                    throw new GeneralSecurityException( "Did not find a public key or certificate, so can't check the signature" ); 
     306                } 
     307            } 
     308        } 
     309        else 
     310        { 
     311            throw new GeneralSecurityException( "Did not find KeyInfo, so can't check the signature" ); 
     312        } 
     313 
     314        AttributeList al = new AttributeList(acInfo); 
     315                 
     316        if (al.isValid()) // check if remaining time is still present in Token 
     317            return al; 
     318        else 
     319            throw new InvalidAuthorisationTokenException("Token timeout, request for new token"); 
     320    } 
     321     
     322    // INCLUDED FOR XML SIGNATURE     
     323    static 
     324    { 
     325      org.apache.xml.security.Init.init(); 
     326    } 
     327 
    138328} 
  • dataportal/trunk/acmnerc/src/uk/ac/cclrc/authorisation/server/ACServer.java

    r90 r91  
    4141import java.util.*; 
    4242 
     43import org.apache.xml.security.utils.*; 
     44 
     45 
    4346/** 
    4447 * @author  asm67 
     
    5255     
    5356    private Properties prop; 
    54     // move this to properties file and also DB properties 
    55      
    5657    private StringFormatter sf;     
    5758    private String version="1.0"; 
    5859    private String issuerSerialNumber = "1"; // serial counter not yet implemented     
    59     private String certFile, facility, signatureAlgorithm, server, port, dbName, userName; 
     60    private String certFile, facility, signatureAlgorithm, server, port, dbName, userName, tokenLifetime, userDn; 
     61    private String canonicalization, digestAlgorithm, canonURL, signatureURL, sigMethodURL, referenceURL, digestURL; 
    6062    private String password, dbDriverString, dbDriverClass, stdRolesQuery, demoRolesQuery; 
    6163    private String userQuery, mappedRolesQuery1, mappedRolesQuery2;     
     
    6769    private Connection conn; 
    6870    private Statement stat; 
     71    private uk.ac.cclrc.authorisation.AttributeList list; 
    6972     
    7073    /** Creates a new instance of ACServer */ 
    71     public ACServer() throws IOException,Exception{ 
     74    public ACServer() throws IOException,GeneralSecurityException,Exception{ 
     75         
    7276        PropertyConfigurator.configure(Config.getContextPath()+"logger.properties"); 
     77         
    7378        try{ 
    7479            //set config properties here 
    7580            prop = new Properties(); 
    7681            prop.load(new FileInputStream(Config.getContextPath()+"authorisation.prop")); 
    77             certFile = prop.getProperty("cert_file"); 
    78             facility = prop.getProperty("facility"); 
    79             server = prop.getProperty("server"); 
    80             port = prop.getProperty("port"); 
    81             dbName = prop.getProperty("db_name"); 
    82             userName = prop.getProperty("username"); 
    83             password = prop.getProperty("passwd"); 
    84             signatureAlgorithm = prop.getProperty("algorithm"); 
    85              
    86             dbName = prop.getProperty("db_name"); 
    87             userName = prop.getProperty("username"); 
    88             password = prop.getProperty("passwd"); 
    89             dbDriverString = prop.getProperty("db_driver_string"); 
    90             dbDriverClass = prop.getProperty("db_driver_class"); 
    91             mapFilePath = prop.getProperty("map_file_location"); 
    92             mappingPreference = prop.getProperty("mapping_preference"); 
    93              
    94             String quotedStdRolesQuery = prop.getProperty("std_roles_query"); 
    95             sf = new StringFormatter( quotedStdRolesQuery ); 
    96             stdRolesQuery = sf.removeQuotes(); 
    97              
    98             String quotedDemoRolesQuery = prop.getProperty("demo_roles_query"); 
    99             sf.setNewString( quotedDemoRolesQuery ); 
    100             demoRolesQuery = sf.removeQuotes(); 
    101  
    102             String quotedAffilOrgsQuery = prop.getProperty("affil_orgs_query"); 
    103             sf.setNewString( quotedAffilOrgsQuery ); 
    104             affilOrgsQuery = sf.removeQuotes(); 
    105  
    106             String quotedAffilOrgsQuery2 = prop.getProperty("affil_orgs_query2"); 
    107             sf.setNewString( quotedAffilOrgsQuery2 ); 
    108             affilOrgsQuery2 = sf.removeQuotes(); 
    109              
    110             dbDNstartValue = prop.getProperty("db_DN_start_value"); 
    111              
    112             String quotedDBDNequalityString = prop.getProperty("db_DN_equality_string"); 
    113             sf.setNewString( quotedDBDNequalityString ); 
    114             dbDNequalityString = sf.removeQuotes();             
    115  
    116             String quotedDBDNdelimString = prop.getProperty("db_DN_delim_string");             
    117             sf.setNewString( quotedDBDNdelimString ); 
    118             dbDNdelimString = sf.removeQuotes();      
    119              
    120             String quotedUserQuery = prop.getProperty("user_query"); 
    121             sf.setNewString( quotedUserQuery ); 
    122             userQuery = sf.removeQuotes(); 
    123  
    124             String quotedMappedRolesQuery1 = prop.getProperty("mapped_roles_query_pt1"); 
    125             sf.setNewString( quotedMappedRolesQuery1 ); 
    126             mappedRolesQuery1 = sf.removeQuotes(); 
    127  
    128             String quotedMappedRolesQuery2 = prop.getProperty("mapped_roles_query_pt2"); 
    129             sf.setNewString( quotedMappedRolesQuery2 ); 
    130             mappedRolesQuery2 = sf.removeQuotes();             
    131  
    132             String quotedPubKeyQuery = prop.getProperty("pub_key_query"); 
    133             sf.setNewString( quotedPubKeyQuery ); 
    134             pubKeyQuery = sf.removeQuotes();                         
    135              
    13682        } 
    13783        catch(IOException e){ 
    138             log.fatal("FileNotFound " +Config.getContextPath()+"authorisation.prop", e); 
     84            log.fatal("Config File Not Found: " +Config.getContextPath()+"authorisation.prop", e); 
    13985            throw e; 
    14086        } 
    141         catch(Exception e){ 
    142             log.fatal("Error", e); 
    143             throw e; 
    144         } 
    145          
    146     } 
    147      
     87         
     88        certFile = prop.getProperty("certificate"); 
     89        if( certFile == null ) 
     90        { 
     91            throw new GeneralSecurityException( "The path to the certificate (associated with the private key " + 
     92                "used to sign the attribute certificate) is not specified in the config file" ); 
     93        } 
     94 
     95        facility = prop.getProperty("facility"); 
     96        if( facility == null ) 
     97        { 
     98            throw new GeneralSecurityException( "The facility hosting this authorisation server is not specified " + 
     99                "in the config file" ); 
     100        } 
     101                 
     102        server = prop.getProperty("server"); 
     103        if( server == null ) 
     104        { 
     105            throw new GeneralSecurityException( "The name/URL of the database server containing the user/role data" + 
     106                "is not specified in the config file" ); 
     107        } 
     108         
     109        port = prop.getProperty("port"); 
     110        if( port == null ) 
     111        { 
     112            throw new GeneralSecurityException( "The port for queries to the database server containing user/role data" + 
     113                "is not specified in the config file" ); 
     114        } 
     115         
     116        dbName = prop.getProperty("db_name"); 
     117        if( dbName == null ) 
     118        { 
     119            throw new GeneralSecurityException( "The name of the database containing the user/role data" + 
     120                "is not specified in the config file" ); 
     121        } 
     122         
     123        userName = prop.getProperty("username"); 
     124        /* 
     125        if( userName == null ) 
     126        { 
     127            throw new GeneralSecurityException( "The user-name for queries to the database server containing user/role data" + 
     128                "is not specified in the config file" ); 
     129        } 
     130         */ 
     131         
     132        password = prop.getProperty("passwd"); 
     133        /* 
     134        if( password == null ) 
     135        { 
     136            throw new GeneralSecurityException( "The password for queries to the database server containing user/role data" + 
     137                "is not specified in the config file" ); 
     138        } 
     139         */ 
     140         
     141        signatureAlgorithm = prop.getProperty("signature_algorithm"); 
     142        if( signatureAlgorithm == null ) 
     143        { 
     144            throw new GeneralSecurityException( "The signature algorithm to be used for digitally signing attribute certificates" + 
     145                "is not specified in the config file" ); 
     146        } 
     147         
     148        dbDriverString = prop.getProperty("db_driver_string"); 
     149        if( dbDriverString == null ) 
     150        { 
     151            throw new GeneralSecurityException( "The database driver string used to get a connection to the user/role database " + 
     152                "is not specified in the config file" ); 
     153        }         
     154         
     155        dbDriverClass = prop.getProperty("db_driver_class"); 
     156        if( dbDriverClass == null ) 
     157        { 
     158            throw new GeneralSecurityException( "The jdbc database driver class used to get a connection to the user/role database " + 
     159                "is not specified in the config file" ); 
     160        }                 
     161         
     162        mapFilePath = prop.getProperty("map_file_location"); 
     163         
     164        mappingPreference = prop.getProperty("mapping_preference"); 
     165        if( mappingPreference == null ) 
     166        { 
     167            throw new GeneralSecurityException( "The preference for either a mapping file or a mapping database table " + 
     168                "is not specified in the config file" ); 
     169        }         
     170         
     171        tokenLifetime = prop.getProperty("token_lifetime"); 
     172        if( tokenLifetime == null ) 
     173        { 
     174            throw new GeneralSecurityException( "The standard lifetime for attribute certificates is not specified in the config file" ); 
     175        }             
     176 
     177        String quotedStdRolesQuery = prop.getProperty("std_roles_query"); 
     178        sf = new StringFormatter( quotedStdRolesQuery ); 
     179        stdRolesQuery = sf.removeQuotes(); 
     180/* 
     181        String quotedDemoRolesQuery = prop.getProperty("demo_roles_query"); 
     182        sf.setNewString( quotedDemoRolesQuery ); 
     183        demoRolesQuery = sf.removeQuotes(); 
     184*/ 
     185        String quotedAffilOrgsQuery = prop.getProperty("affil_orgs_query"); 
     186        sf.setNewString( quotedAffilOrgsQuery ); 
     187        affilOrgsQuery = sf.removeQuotes(); 
     188 
     189        String quotedAffilOrgsQuery2 = prop.getProperty("affil_orgs_query2"); 
     190        sf.setNewString( quotedAffilOrgsQuery2 ); 
     191        affilOrgsQuery2 = sf.removeQuotes(); 
     192 
     193        dbDNstartValue = prop.getProperty("db_DN_start_value"); 
     194        if( dbDNstartValue == null ) 
     195        { 
     196            throw new GeneralSecurityException( "The first field of distinguished names is not specified in the config file" ); 
     197        }                 
     198 
     199        String quotedDBDNequalityString = prop.getProperty("db_DN_equality_string"); 
     200        sf.setNewString( quotedDBDNequalityString ); 
     201        dbDNequalityString = sf.removeQuotes();             
     202 
     203        String quotedDBDNdelimString = prop.getProperty("db_DN_delim_string");             
     204        sf.setNewString( quotedDBDNdelimString ); 
     205        dbDNdelimString = sf.removeQuotes();      
     206 
     207        String quotedUserQuery = prop.getProperty("user_query"); 
     208        sf.setNewString( quotedUserQuery ); 
     209        userQuery = sf.removeQuotes(); 
     210 
     211        String quotedMappedRolesQuery1 = prop.getProperty("mapped_roles_query_pt1"); 
     212        sf.setNewString( quotedMappedRolesQuery1 ); 
     213        mappedRolesQuery1 = sf.removeQuotes(); 
     214 
     215        String quotedMappedRolesQuery2 = prop.getProperty("mapped_roles_query_pt2"); 
     216        sf.setNewString( quotedMappedRolesQuery2 ); 
     217        mappedRolesQuery2 = sf.removeQuotes();             
     218 
     219        String quotedPubKeyQuery = prop.getProperty("pub_key_query"); 
     220        sf.setNewString( quotedPubKeyQuery ); 
     221        pubKeyQuery = sf.removeQuotes();                         
     222 
     223        // not needed in XML signature 
     224        /* 
     225        canonicalization = prop.getProperty("canon_algorithm"); 
     226        digestAlgorithm = prop.getProperty("digest_algorithm"); 
     227        canonURL = prop.getProperty("canonicalization_URL"); 
     228        signatureURL = prop.getProperty("signature_URL"); 
     229        sigMethodURL = prop.getProperty("sigMethod_URL"); 
     230        referenceURL = prop.getProperty("reference_URL"); 
     231        digestURL = prop.getProperty("digest_URL"); 
     232         */ 
     233    } 
     234     
     235    // NOT CURRENTLY USED 
    148236    /** This method is used to get authoriglobusCredentialsation Token describing the parameters of the user in XML string 
    149237     *@param String proxyCertificateInString proxyCertificate of the user in String 
     
    163251    } 
    164252     
     253    /** This method is used to get an Authorisation Token describing the user attributes as a w3c DOM object. 
     254     * It is called when the user does not have a relevant token to pass to the data centre. 
     255     *@param String proxyCertString proxy certificate of the user as a String 
     256     *@exception java.lang.Exception 
     257     *@return org.w3c.dom.Element the signed authorisation token expressed as a DOM Element 
     258     */     
    165259    public org.w3c.dom.Element getAuthorisationTokenInDOM(String proxyCertString ) throws Exception 
    166260    { 
     
    169263    } 
    170264     
    171     /** This method is used to get authorisation Token describing the parameters of the user as w3c DOM object 
    172      *@param String proxyCertificateInString proxyCertificate of the user in String 
     265    /** This method is used to get an Authorisation Token describing the user attributes as a w3c DOM object. 
     266     * It is called directly when the user has a relevant token to pass in and indirectly when they don't 
     267     * with extAuthToken set to null. 
     268     *@param String proxyCertString proxy certificate of the user as a String 
     269     *@param org.w3c.dom.Element extAuthToken user's authorisation token 
    173270     *@exception java.lang.Exception 
    174      *@return String w3c DOM representation of the Authorizatino token for the user 
     271     *@return org.w3c.dom.Element the signed authorisation token expressed as a DOM Element 
    175272     */ 
    176273    public org.w3c.dom.Element getAuthorisationTokenInDOM(String proxyCertString, org.w3c.dom.Element extAuthToken) throws Exception{ 
    177274         
    178         // Convert to XML String and Return 
    179         //XMLOutputter outputter = new XMLOutputter(); 
    180         //return outputter.outputString(doc); 
    181          
    182         String userDn = this.getUserDn(proxyCertString); 
    183          
    184         sf.setNewString( userDn ); 
    185         sf.setDNConfig( dbDNstartValue, dbDNequalityString, dbDNdelimString ); 
    186         userDn = sf.formatDN(); 
    187          
    188         boolean userFound = searchDBForUser( userDn ); 
     275        boolean userFound = searchDBForUser( proxyCertString ); 
    189276        Document doc = null; 
    190277         
    191         try { 
    192             if( userFound ) 
     278        if( userFound ) 
     279        { 
     280            // NDB - demo-code 
     281            System.out.println("**********************************************"); 
     282            System.out.println("User found in local database so original authorisation token will be generated"); 
     283            System.out.println("//////////////////////////////////////////////"); 
     284            System.out.println(""); 
     285            System.out.println(""); 
     286 
     287            doc = createAuthorisationToken(proxyCertString); 
     288        } 
     289        else 
     290        { 
     291            // NDB - demo-code 
     292            System.out.println("**********************************************"); 
     293            System.out.println("User NOT found in local database so will now see if mapped authorisation token can be generated"); 
     294            System.out.println("//////////////////////////////////////////////"); 
     295            System.out.println(""); 
     296            System.out.println(""); 
     297 
     298 
     299            TokenReader reader = new TokenReader(); 
     300 
     301            if( extAuthToken != null ) 
    193302            { 
    194                 doc = createAuthorisationToken(proxyCertString); 
    195             } 
    196             else 
    197             { 
    198                 TokenReader reader = new TokenReader(); 
    199                 uk.ac.cclrc.authorisation.AttributeList list =  reader.getAttributes( extAuthToken ); 
     303                list =  reader.getACInfo( extAuthToken ); 
    200304                String authTokenProvenance = list.getProvenance(); 
    201                  
    202                 if( extAuthToken != null ) 
     305 
     306                System.out.println("**********************************************"); 
     307                System.out.println("Check provenance of current token"); 
     308                System.out.println("//////////////////////////////////////////////"); 
     309                System.out.println( authTokenProvenance ); 
     310                System.out.println(""); 
     311 
     312                if( authTokenProvenance.equals("mapped") ) 
    203313                { 
    204                     if( authTokenProvenance.equals("mapped") ) 
    205                     { 
    206                         throw new InvalidAuthorisationTokenException( "Mapped Authorisation Tokens can not be used to generate further Authorisation Tokens - only Original Authorisation Tokens for affiliated institutions can be." ); 
    207                     } 
    208                     else 
    209                     { 
    210                         doc = createMappedAuthorisationToken( proxyCertString, extAuthToken ); 
    211                     } 
     314                    throw new InvalidAuthorisationTokenException( "Mapped Authorisation Tokens can not be used to generate further Authorisation Tokens - only Original Authorisation Tokens for affiliated institutions can be." ); 
    212315                } 
    213316                else 
    214317                { 
    215                     throw new Exception( "An Original Authorisation Token from an affiliated institution must be passed in to generate further Authorisation Tokens." ); 
     318                    doc = createMappedAuthorisationToken( proxyCertString, extAuthToken ); 
    216319                } 
    217320            } 
     321            else 
     322            { 
     323                throw new GeneralSecurityException( "To generate a mapped token, an original Authorisation Token from an affiliated institution must be passed in.  " + 
     324                "To generate an original token, the user must be listed in the data centre's database" ); 
     325            } 
     326        } 
     327        if( doc != null ) 
     328        { 
    218329            org.w3c.dom.Document w3cDoc = Converter.JDOMtoDOM(doc); 
    219330            org.w3c.dom.Element el = w3cDoc.getDocumentElement(); 
    220331            return el; 
    221         } catch (Exception e) { 
    222  
    223             throw e; 
    224         } 
    225     } 
    226  
     332        } 
     333        else 
     334        { 
     335            return null; 
     336        } 
     337    } 
     338 
     339     
     340    // NOT CURRENTLY USED 
    227341    private PublicKey getPublicKey( String extOrg ) throws Exception 
    228342    { 
     
    251365            if( !keyFile.exists() ) 
    252366            { 
    253                 throw new FileNotFoundException( keyFile.getAbsolutePath()+" not found on the system" );             
     367                throw new FileNotFoundException( "Key file: " + keyFile.getAbsolutePath()+" not found on the system" );             
    254368            } 
    255369            InputStream inStream = new FileInputStream( keyFile ); 
     
    261375            // NDB - demo-code 
    262376            System.out.println("**********************************************"); 
    263             System.out.println("Extracted path of " + extOrg + "_public key from mapping file: " + keyFile.getAbsolutePath()); 
     377            System.out.println("Extracted path of " + extOrg + " public key from mapping file: " + keyFile.getAbsolutePath()); 
    264378            System.out.println("//////////////////////////////////////////////"); 
    265379            System.out.println( pubKey ); 
     
    286400            // NDB - demo-code 
    287401            System.out.println("**********************************************"); 
    288             System.out.println("Extracted " + extOrg + "_public key from appropriate database table"); 
     402            System.out.println("Extracted " + extOrg + " public key from mapping table in " + facility + " database"); 
    289403            System.out.println("//////////////////////////////////////////////"); 
    290404            System.out.println( pubKey ); 
     
    295409        else 
    296410        { 
    297             throw new Exception( "Invalid mapping preference in configuration file" ); 
     411            throw new GeneralSecurityException( "Invalid mapping preference in configuration file" ); 
    298412        } 
    299413        return pubKey; 
    300414    } 
    301415     
     416    /** This method is used to create a new mapped authorisation token for a user.  The token contains 
     417     * the user's attributes and is digitally signed. 
     418     *@param String proxyCertString Proxy certificate of the user.  The user's DN is extracted from this. 
     419     *@param String extToken Original authorisation token from which a mapped one will be created. 
     420     *@exception java.lang.Exception 
     421     *@return org.jdom.Document the token is returned as a JDOM Document. 
     422     */     
    302423    private Document createMappedAuthorisationToken( String proxyCertString, org.w3c.dom.Element extToken ) throws Exception 
    303424    { 
    304         try { 
    305             String version = this.version; 
    306             String userDn = this.getUserDn(proxyCertString); 
    307             String provenance = "mapped"; 
    308  
    309             TokenReader reader = new TokenReader(); 
    310             uk.ac.cclrc.authorisation.AttributeList list =  reader.getAttributes( extToken ); 
    311             //String acInfoString = list.getAcInfoAsXMLString(); 
    312             org.w3c.dom.Element acInfoElement = list.getAcInfoAsW3CElement(); 
    313              
    314             org.w3c.dom.Node sigNode = extToken.getLastChild(); 
    315             String sigString = ((org.w3c.dom.Element)sigNode).getFirstChild().getNodeValue(); 
    316              
    317             String extOrg = this.getOrgFromExtToken( extToken ); 
    318              
    319             PublicKey extPK = getPublicKey( extOrg ); 
    320             byte[] decodedSigString = org.globus.util.Base64.decode(sigString.getBytes()); 
    321             Signature sigVerifier = Signature.getInstance( signatureAlgorithm ); 
    322             sigVerifier.initVerify( extPK ); 
    323             sigVerifier.update(acInfoElement.toString().getBytes()); 
    324              
    325             boolean trueSignature = sigVerifier.verify(decodedSigString); 
    326  
    327             if( !trueSignature ) 
    328             { 
    329                 throw new Exception( "Signature on authorisation token is not valid." + 
    330                 "  It has not been produced from the private key of the trusted host." ); 
    331             } 
    332             
    333             String extFacility = list.getIssuerName(); 
    334  
    335             String extdbDNstartValue = prop.getProperty(extFacility+"_db_DN_start_value"); 
    336              
    337             String quotedExtDBDNequalityString = prop.getProperty(extFacility+"_db_DN_equality_string"); 
    338             sf.setNewString( quotedExtDBDNequalityString ); 
    339             String extdbDNequalityString = sf.removeQuotes();             
    340  
    341             String quotedExtDBDNdelimString = prop.getProperty(extFacility+"_db_DN_delim_string");             
    342             sf.setNewString( quotedExtDBDNdelimString ); 
    343             String extdbDNdelimString = sf.removeQuotes();      
    344                          
    345              
    346             // NDB - demo-code 
    347             System.out.println("**********************************************"); 
    348             System.out.println("Extracted user DN from user's proxy certificate"); 
    349             System.out.println("//////////////////////////////////////////////"); 
    350             System.out.println( userDn ); 
    351             System.out.println(""); 
    352             System.out.println(""); 
    353  
    354             sf.setNewString( userDn ); 
    355             sf.setDNConfig( extdbDNstartValue, extdbDNequalityString, extdbDNdelimString ); 
    356             String extFormatProxyDn = sf.formatDN(); 
    357  
    358             // NDB - demo-code 
    359             System.out.println("**********************************************"); 
    360             System.out.println("Generated a user DN in the external organisation's format"); 
    361             System.out.println("//////////////////////////////////////////////"); 
    362             System.out.println( extFormatProxyDn ); 
    363             System.out.println(""); 
    364             System.out.println(""); 
    365  
    366              
    367             String extTokenDN = list.getHolder(); 
    368             
    369             // NDB - demo-code 
    370             System.out.println("**********************************************"); 
    371             System.out.println("Extracted user DN from authorisation token"); 
    372             System.out.println("//////////////////////////////////////////////"); 
    373             System.out.println( extTokenDN ); 
    374             System.out.println(""); 
    375             System.out.println(""); 
    376  
    377             boolean dnsSame = extFormatProxyDn.equals( extTokenDN ); 
    378             if( !dnsSame ) 
    379             { 
    380                 throw new InvalidAuthorisationTokenException( "proxy certificate DN and authorisation token DN do not match"); 
    381             } 
    382  
    383             // NDB - demo-code 
    384             System.out.println("**********************************************"); 
    385             System.out.println("Compare the user DN from the proxy certificate with" + 
    386                 " that from the authorisation token"); 
    387             System.out.println("//////////////////////////////////////////////"); 
    388             System.out.println( dnsSame ); 
    389             System.out.println(""); 
    390              
    391              
    392             sf.setDNConfig( dbDNstartValue, dbDNequalityString, dbDNdelimString ); 
    393             userDn = sf.formatDN(); 
    394  
    395             // NDB - demo-code 
    396             System.out.println("**********************************************"); 
    397             System.out.println("Formatted the user DN so compliant with local database holding user and permission details"); 
    398             System.out.println("//////////////////////////////////////////////"); 
    399             System.out.println( userDn ); 
    400             System.out.println(""); 
    401             System.out.println(""); 
    402  
    403              
    404             String issuerDn = this.getIssuerDn(); 
    405              
    406             // NDB - demo-code 
    407             System.out.println("**********************************************"); 
    408             System.out.println("Extracted issuer's DN from authorisation server's X509 certificate"); 
    409             System.out.println("//////////////////////////////////////////////"); 
    410             System.out.println( issuerDn ); 
    411             System.out.println(""); 
    412             System.out.println("");             
    413              
    414             String issuerName = this.facility; 
    415             String signatureAlgorithm=this.signatureAlgorithm; 
    416             String issuerSerialNumber=this.issuerSerialNumber; 
    417             // Certificate Limitation is currently done with current time and maximum proxy validity. In future the request of 
    418             // maximum time to be made via the web service and the Server check if the request does not exceed the proxy certificate validity 
    419              
    420             int[] notBefore=  this.getCurrentTime(); 
    421  
    422             // NDB - demo-code 
    423             System.out.println("**********************************************"); 
    424             System.out.println("Get current time to determine when user's authorisation token is valid from"); 
    425             System.out.println("//////////////////////////////////////////////"); 
    426             for( int i = 0; i < notBefore.length; i++ ) 
    427             { 
    428                 System.out.println( notBefore[ i ] ); 
    429             } 
    430             System.out.println(""); 
    431             System.out.println("");           
    432              
    433             int[] notAfter = this.getNotAfter(proxyCertString,notBefore); 
    434  
    435             // NDB - demo-code 
    436             System.out.println("**********************************************"); 
    437             System.out.println("Determine remaining time from user's proxy certificate and add to current time to determine expiry time"); 
    438             System.out.println("//////////////////////////////////////////////"); 
    439             for( int i = 0; i < notAfter.length; i++ ) 
    440             { 
    441                 System.out.println( notAfter[ i ] ); 
    442             } 
    443             System.out.println(""); 
    444             System.out.println("");             
    445              
    446  
    447             String unquotedRoles = this.getRolesFromExtToken( extToken ); 
    448             
    449             sf.setNewString( unquotedRoles ); 
    450             String roles = sf.addQuotesToList(); 
    451              
    452             ResultSet rs = null; 
    453             HashSet mappedRoles = new HashSet(); 
    454             StringBuffer dataAccessRoles = new StringBuffer(); 
    455  
    456             // NDB - demo-code 
    457             System.out.println("**********************************************"); 
    458             System.out.println("Get mapping preference from config file"); 
    459             System.out.println("//////////////////////////////////////////////"); 
    460             System.out.println( mappingPreference ); 
    461             System.out.println(""); 
    462             System.out.println(""); 
    463              
    464             if( mappingPreference.equals("database") ) 
    465             { 
    466                 rs = this.getMappedRolesFromDB( roles, extOrg ); 
    467                  
    468                 dataAccessRoles = dataAccessRoles.append( rs.getString(1) ); 
    469  
    470                 while( rs.next() ) 
    471                 { 
    472                     dataAccessRoles = dataAccessRoles.append( "," ); 
    473                     dataAccessRoles = dataAccessRoles.append( rs.getString(1) ); 
    474                 } 
    475  
    476                 try{ 
    477  
    478                     rs.close(); 
    479                     rs = null;                 
    480                     stat.close(); 
    481                     stat = null;                 
    482                     conn.close(); 
    483                     conn = null; 
    484                 } 
    485                 finally { 
    486                     // Always make sure result sets and statements are closed, 
    487  
    488                     if (rs != null) { 
    489                         try { rs.close(); } catch (SQLException e) { ; } 
    490                         rs = null; 
    491                     } 
    492                     if (stat != null) { 
    493                         try { stat.close(); } catch (SQLException e) { ; } 
    494                         stat = null; 
    495                     } 
    496                     if (conn != null) { 
    497                         try { conn.close(); } catch (SQLException e) { 
    498                             log.warn("Connection unable to be closed",e);  } 
    499                         conn = null; 
    500                     } 
    501                 } 
    502                 // NDB - demo-code 
    503                 System.out.println("**********************************************"); 
    504                 System.out.println("Get mapped user roles from database"); 
    505                 System.out.println("//////////////////////////////////////////////"); 
    506                 System.out.println( dataAccessRoles ); 
    507                 System.out.println(""); 
    508                 System.out.println("");                
    509                 
    510             } 
    511             else if( mappingPreference.equals( "file" ) ) 
    512             { 
    513                 mappedRoles = this.getMappedRolesFromMapFile( unquotedRoles, extOrg ); 
    514                 Iterator mappedRolesIt = mappedRoles.iterator(); 
    515                 String firstMappedRole = (String)mappedRolesIt.next(); 
    516                 dataAccessRoles = dataAccessRoles.append( firstMappedRole ); 
    517                  
    518                 while( mappedRolesIt.hasNext() ) 
    519                 { 
    520                     dataAccessRoles = dataAccessRoles.append( "," ); 
    521                     String mappedRole = (String)mappedRolesIt.next(); 
    522                     dataAccessRoles = dataAccessRoles.append( mappedRole ); 
    523                 } 
    524  
    525                 // NDB - demo-code 
    526                 System.out.println("**********************************************"); 
    527                 System.out.println("Get mapped user roles from file"); 
    528                 System.out.println("//////////////////////////////////////////////"); 
    529                 System.out.println( dataAccessRoles ); 
    530                 System.out.println(""); 
    531                 System.out.println("");                
    532  
    533             } 
    534             else 
    535             { 
    536                 throw new Exception( "mapping preference in properties file must be given value 'file' or 'database'" ); 
    537             } 
    538             
    539             String dataAccess = dataAccessRoles.toString(); 
    540             AttributeList acInfo = new AttributeList(version, userDn, issuerDn,issuerName, signatureAlgorithm,issuerSerialNumber,notBefore,notAfter,dataAccess, provenance); 
    541              
    542             // NDB - demo-code 
    543             System.out.println("**********************************************"); 
    544             System.out.println("Create attribute list for user.  This comprises all information that will go into the user's authorisation token"); 
    545             System.out.println("//////////////////////////////////////////////"); 
    546             System.out.println(""); 
    547             System.out.println("");               
    548  
    549             Document ACDocument = signAttributeListToGetToken( acInfo ); 
    550             return ACDocument; 
    551         } catch (Exception e) { 
    552             log.error("Unable to create mapped authorisation token",e); 
    553             throw e; 
    554         } 
    555        
    556     } 
    557      
    558     private Document signAttributeListToGetToken( AttributeList attList ) throws Exception 
    559     { 
    560         // get User Access privileges from Database 
    561         org.jdom.Document doc = attList.getJDOMDocument(); 
    562         org.jdom.Element acInfoElement = doc.getRootElement(); 
    563  
    564         //Send for signing 
    565  
    566         XMLOutputter outputter = new XMLOutputter(); 
    567         String acInfoString = outputter.outputString(acInfoElement); 
    568  
    569         // NDB - demo-code 
    570         System.out.println("**********************************************"); 
    571         System.out.println("Get user's access control info from attribute list"); 
    572         System.out.println("//////////////////////////////////////////////"); 
    573         System.out.println( acInfoString ); 
    574         System.out.println(""); 
    575         System.out.println("");               
    576  
    577         String signatureString = ""; 
    578          
    579         try 
    580         { 
    581             ACGen acGen = new ACGen(); 
    582             signatureString = acGen.getSignatureString(acInfoString); 
    583         } 
    584         catch( Exception e ) 
    585         { 
    586             log.error("Unable to sign attribute list",e); 
    587             throw e;             
    588         } 
    589         //create XML document out of it 
    590  
    591         // NDB - demo-code 
    592         System.out.println("**********************************************"); 
    593         System.out.println("Generate digital signature from user's access control info using authorisation server's private key"); 
    594         System.out.println("//////////////////////////////////////////////"); 
    595         System.out.println( signatureString ); 
    596         System.out.println(""); 
    597         System.out.println("");                 
    598  
    599         Document ACDocument = new Document(); 
    600         Element root = new Element("attributeCertificate"); 
    601  
    602         ACDocument.setRootElement(root); 
    603         root.addContent(acInfoElement); 
    604  
    605         Element signatureElement = new Element("signature"); 
    606         signatureElement.setText(signatureString); 
    607  
    608         root.addContent(signatureElement); 
    609  
    610         // NDB - demo-code 
    611         System.out.println("**********************************************"); 
    612         System.out.println("Put digital signature and user's access control info together to form the user's authorisation token"); 
    613         System.out.println("//////////////////////////////////////////////"); 
    614         System.out.println( outputter.outputString(root) ); 
    615         System.out.println(""); 
    616         System.out.println("");                 
    617              
    618         return ACDocument; 
    619     } 
    620      
    621     private ResultSet getMappedRolesFromDB( String roles, String extOrg ) throws Exception 
    622     { 
    623         try { 
     425 
     426        String version = this.version; 
     427        String provenance = "mapped"; 
     428 
     429        userDn = this.getUserDn(proxyCertString); 
     430 
     431        //TokenReader reader = new TokenReader(); 
     432        //uk.ac.cclrc.authorisation.AttributeList list =  reader.getAttributes( extToken ); 
     433        //uk.ac.cclrc.authorisation.AttributeList list =  reader.getACInfo( extToken ); 
     434        //String acInfoString = list.getAcInfoAsXMLString(); 
     435        /* 
     436        org.w3c.dom.Element acInfoElement = list.getAcInfoAsW3CElement(); 
     437 
     438        org.w3c.dom.Node sigNode = extToken.getLastChild(); 
     439 
     440        String sigString = ((org.w3c.dom.Element)sigNode).getLastChild().getFirstChild().getNodeValue(); 
     441        */ 
     442        //String extOrg = this.getOrgFromExtToken( extToken ); 
     443        /* 
     444        PublicKey extPK = getPublicKey( extOrg ); 
     445        byte[] decodedSigString = org.globus.util.Base64.decode(sigString.getBytes()); 
     446        Signature sigVerifier = Signature.getInstance( digestAlgorithm + "with" + signatureAlgorithm ); 
     447        sigVerifier.initVerify( extPK ); 
     448        sigVerifier.update(acInfoElement.toString().getBytes()); 
     449 
     450        boolean trueSignature = sigVerifier.verify(decodedSigString); 
     451 
     452        if( !trueSignature ) 
     453        { 
     454            throw new Exception( "Signature on authorisation token is not valid." + 
     455            "  It has not been produced from the private key of the trusted host." ); 
     456        } 
     457       */ 
     458 
     459        // Put user DN from proxy certificate into same format as external database / external token 
     460        // to allow comparison with the user DN from the external token 
     461        String extOrg = list.getIssuerName(); 
     462 
     463        System.out.println("**********************************************"); 
     464        System.out.println("Extracted organisation from external token"); 
     465        System.out.println("//////////////////////////////////////////////"); 
     466        System.out.println( extOrg ); 
     467        System.out.println(""); 
     468        System.out.println(""); 
     469 
     470        String extdbDNstartValue = prop.getProperty(extOrg+"_db_DN_start_value"); 
     471 
     472        String quotedExtDBDNequalityString = prop.getProperty(extOrg+"_db_DN_equality_string"); 
     473        sf.setNewString( quotedExtDBDNequalityString ); 
     474        String extdbDNequalityString = sf.removeQuotes();             
     475 
     476        String quotedExtDBDNdelimString = prop.getProperty(extOrg+"_db_DN_delim_string");             
     477        sf.setNewString( quotedExtDBDNdelimString ); 
     478        String extdbDNdelimString = sf.removeQuotes();      
     479 
     480        sf.setNewString( userDn ); 
     481        sf.setDNConfig( extdbDNstartValue, extdbDNequalityString, extdbDNdelimString ); 
     482        String extFormatProxyDn = sf.formatDN(); 
     483 
     484        // NDB - demo-code 
     485        System.out.println("**********************************************"); 
     486        System.out.println("Taken the proxy certificate user DN and generated a user DN in the external organisation's (" + extOrg + ") format"); 
     487        System.out.println("//////////////////////////////////////////////"); 
     488        System.out.println( extFormatProxyDn ); 
     489        System.out.println(""); 
     490        System.out.println(""); 
     491 
     492        // Gets the user DN from the authorisation token 
     493        String extTokenDN = list.getHolder(); 
     494 
     495        // NDB - demo-code 
     496        System.out.println("**********************************************"); 
     497        System.out.println("Extracted user DN from authorisation token."); 
     498        System.out.println( "If the authorisation token and proxy certificate are from the same person, the DNs should be the same." ); 
     499        System.out.println("//////////////////////////////////////////////"); 
     500        System.out.println( extTokenDN ); 
     501        System.out.println(""); 
     502        System.out.println(""); 
     503 
     504        boolean dnsSame = extFormatProxyDn.equals( extTokenDN ); 
     505        if( !dnsSame ) 
     506        { 
     507            throw new InvalidAuthorisationTokenException( "proxy certificate DN and authorisation token DN do not match"); 
     508        } 
     509 
     510        // NDB - demo-code 
     511        System.out.println("**********************************************"); 
     512        System.out.println("Compare the user DN from the proxy certificate with" + 
     513            " that from the authorisation token"); 
     514        System.out.println("//////////////////////////////////////////////"); 
     515        System.out.println( dnsSame ); 
     516        System.out.println(""); 
     517 
     518        String issuerDn = this.getIssuerDn(); 
     519 
     520        // NDB - demo-code 
     521        System.out.println("**********************************************"); 
     522        System.out.println("Extracted issuer's DN from authorisation server's X509 certificate."); 
     523        System.out.println("This will be included in the new authorisation token generated."); 
     524        System.out.println("//////////////////////////////////////////////"); 
     525        System.out.println( issuerDn ); 
     526        System.out.println(""); 
     527        System.out.println("");             
     528 
     529        String issuerName = this.facility; 
     530        String signatureAlgorithm=this.signatureAlgorithm; 
     531        String issuerSerialNumber=this.issuerSerialNumber; 
     532        // Certificate Limitation is currently done with current time and maximum proxy validity. In future the request of 
     533        // maximum time to be made via the web service and the Server check if the request does not exceed the proxy certificate validity 
     534 
     535        int[] notBefore=  this.getCurrentTime(); 
     536 
     537        // NDB - demo-code 
     538        System.out.println("**********************************************"); 
     539        System.out.println("Get current time to determine when user's new authorisation token is valid from"); 
     540        System.out.println("//////////////////////////////////////////////"); 
     541        for( int i = 0; i < notBefore.length; i++ ) 
     542        { 
     543            System.out.println( notBefore[ i ] ); 
     544        } 
     545        System.out.println(""); 
     546        System.out.println("");           
     547 
     548        int[] notAfter = this.getNotAfter(proxyCertString,tokenLifetime,notBefore); 
     549 
     550        // NDB - demo-code 
     551        System.out.println("**********************************************"); 
     552        System.out.println("Get token lifetime from config file and add to current time to determine expiry time of new token"); 
     553        System.out.println("//////////////////////////////////////////////"); 
     554 
     555        for( int i = 0; i < notAfter.length; i++ ) 
     556        { 
     557            System.out.println( notAfter[ i ] ); 
     558        } 
     559        System.out.println(""); 
     560        System.out.println("");             
     561 
     562        // Get Roles from external token and add quotes to all items in the list to allow 
     563        // an SQL query to be constructed from them. 
     564        HashSet unquotedRoles = list.getRoleSet();             
     565 
     566        // NDB - demo-code 
     567        System.out.println("**********************************************"); 
     568        System.out.println("Extracted roles from external token"); 
     569        System.out.println("//////////////////////////////////////////////"); 
     570        System.out.println( unquotedRoles ); 
     571        System.out.println(""); 
     572        System.out.println("");             
     573 
     574        Iterator unquotedRolesIt = unquotedRoles.iterator(); 
     575        String firstRole = (String) unquotedRolesIt.next(); 
     576        StringBuffer roleString = new StringBuffer( firstRole ); 
     577        while( unquotedRolesIt.hasNext() ) 
     578        { 
     579            String nextRole = (String) unquotedRolesIt.next(); 
     580            roleString.append( ", " ); 
     581            roleString.append( nextRole ); 
     582        } 
     583        sf.setNewString( roleString.toString() ); 
     584        String roles = sf.addQuotesToList(); 
     585 
     586        HashSet roleHashSet = new HashSet(); 
     587 
     588        // NDB - demo-code 
     589        System.out.println("**********************************************"); 
     590        System.out.println("Get mapping preference from config file"); 
     591        System.out.println("//////////////////////////////////////////////"); 
     592        System.out.println( mappingPreference ); 
     593        System.out.println(""); 
     594        System.out.println(""); 
     595 
     596        if( mappingPreference.equals("database") ) 
     597        { 
    624598            ResultSet rs = query(mappedRolesQuery1 + extOrg + mappedRolesQuery2 + roles + ");" ); // Nov 04 
    625             rs.next(); 
    626             return rs;         
    627         } 
    628         catch (Exception e) { 
    629             log.error(e); 
    630             throw e; // need to modify it 
    631         } 
    632     } 
    633  
    634     private HashSet getMappedRolesFromMapFile( String roles, String extOrg ) throws Exception 
    635     { 
    636         
    637         String[] roleArray = roles.split( ","); 
    638         HashSet localRoles = new HashSet(); 
    639          
    640         SAXBuilder saxb = new SAXBuilder(); 
    641         org.jdom.Document mapFileDoc = saxb.build( mapFilePath ); 
    642         Element root = mapFileDoc.getRootElement(); 
    643         List trustedElements = root.getChildren("trusted"); 
    644         Element trustedElement = null; 
    645         for( int i = 0; i < trustedElements.size(); i++ ) 
    646         { 
    647             trustedElement = (Element)trustedElements.get( i ); 
    648             String trustedAttValue = trustedElement.getAttributeValue("name"); 
    649             if( trustedAttValue.equals( extOrg ) ) 
    650             { 
    651                 List roleElements = trustedElement.getChildren("role"); 
    652                 Element roleElement = null; 
    653                 for( int k = 0; k < roleArray.length; k++ ) 
    654                 { 
    655                     for( int j = 0; j < roleElements.size(); j++ ) 
    656                     { 
    657                         roleElement = (Element)roleElements.get( j ); 
    658                         String roleAttValue = roleElement.getAttributeValue("remote"); 
    659                         if( roleArray[ k ].equals( roleAttValue ) ) 
    660                         { 
    661                             String localRole = roleElement.getAttributeValue("local"); 
    662                             localRoles.add( localRole ); 
    663                         } 
    664                     } 
    665                 } 
    666             } 
    667         } 
    668          
    669         return localRoles; 
    670     } 
    671      
    672      
    673     private String getRolesFromExtToken( org.w3c.dom.Element extToken ) throws Exception 
    674     { 
    675         String roleString = ""; 
    676          
    677         try 
    678         { 
    679             TokenReader reader = new TokenReader(); 
    680             uk.ac.cclrc.authorisation.AttributeList list =  reader.getAttributes( extToken );         
    681             roleString = list.getDataAccessGroup(); 
    682         } 
    683         catch( Exception e ) 
    684         { 
    685             throw e; 
    686         } 
    687  
    688         // NDB - demo-code 
    689         System.out.println("**********************************************"); 
    690         System.out.println("Extracted roles from external token"); 
    691         System.out.println("//////////////////////////////////////////////"); 
    692         System.out.println( roleString ); 
    693         System.out.println(""); 
    694         System.out.println(""); 
    695          
    696         return roleString; 
    697     } 
    698  
    699     private String getOrgFromExtToken( org.w3c.dom.Element extToken ) throws Exception 
    700     { 
    701         String extOrg = ""; 
    702          
    703         try 
    704         { 
    705             TokenReader reader = new TokenReader(); 
    706             uk.ac.cclrc.authorisation.AttributeList list =  reader.getAttributes( extToken );         
    707             extOrg = list.getIssuerName(); 
    708         } 
    709         catch( Exception e ) 
    710         { 
    711             throw e; 
    712         } 
    713  
    714         // NDB - demo-code 
    715         System.out.println("**********************************************"); 
    716         System.out.println("Extracted organisation from external token"); 
    717         System.out.println("//////////////////////////////////////////////"); 
    718         System.out.println( extOrg ); 
    719         System.out.println(""); 
    720         System.out.println(""); 
    721          
    722         return extOrg; 
    723     } 
    724      
    725      
    726     /** Private method to generate Attribute List of user. 
    727      */ 
    728     private Document createAuthorisationToken(String proxyCertString) throws Exception{ 
    729         //Create authorisation Token 
    730          
    731         try { 
    732             String version = this.version; 
    733             String userDn = this.getUserDn(proxyCertString); 
    734             String provenance = "original"; 
    735              
    736              
    737             // NDB - demo-code 
    738             System.out.println("**********************************************"); 
    739             System.out.println("Extracted user DN from user's proxy certificate"); 
    740             System.out.println("//////////////////////////////////////////////"); 
    741             System.out.println( userDn ); 
    742             System.out.println(""); 
    743             System.out.println(""); 
    744              
    745             sf.setNewString( userDn ); 
    746             sf.setDNConfig( dbDNstartValue, dbDNequalityString, dbDNdelimString ); 
    747             
    748             userDn = sf.formatDN(); 
    749  
    750             // NDB - demo-code 
    751             System.out.println("**********************************************"); 
    752             System.out.println("Formatted the user DN so compliant with database holding user and permission details"); 
    753             System.out.println("//////////////////////////////////////////////"); 
    754             System.out.println( userDn ); 
    755             System.out.println(""); 
    756             System.out.println(""); 
    757                   
    758              
    759             String issuerDn = this.getIssuerDn(); 
    760              
    761             // NDB - demo-code 
    762             System.out.println("**********************************************"); 
    763             System.out.println("Extracted issuer's DN from authorisation server's X509 certificate"); 
    764             System.out.println("//////////////////////////////////////////////"); 
    765             System.out.println( issuerDn ); 
    766             System.out.println(""); 
    767             System.out.println("");             
    768              
    769             String issuerName = this.facility; 
    770             String signatureAlgorithm=this.signatureAlgorithm; 
    771             String issuerSerialNumber=this.issuerSerialNumber; 
    772             // Certificate Limitation is currently done with current time and maximum proxy validity. In future the request of 
    773             // maximum time to be made via the web service and the Server check if the request does not exceed the proxy certificate validity 
    774              
    775             int[] notBefore=  this.getCurrentTime(); 
    776  
    777             // NDB - demo-code 
    778             System.out.println("**********************************************"); 
    779             System.out.println("Get current time to determine when user's authorisation token is valid from"); 
    780             System.out.println("//////////////////////////////////////////////"); 
    781             for( int i = 0; i < notBefore.length; i++ ) 
    782             { 
    783                 System.out.println( notBefore[ i ] ); 
    784             } 
    785             System.out.println(""); 
    786             System.out.println("");           
    787              
    788             int[] notAfter = this.getNotAfter(proxyCertString,notBefore); 
    789  
    790             // NDB - demo-code 
    791             System.out.println("**********************************************"); 
    792             System.out.println("Determine remaining time from user's proxy certificate and add to current time to determine expiry time"); 
    793             System.out.println("//////////////////////////////////////////////"); 
    794             for( int i = 0; i < notAfter.length; i++ ) 
    795             { 
    796                 System.out.println( notAfter[ i ] ); 
    797             } 
    798             System.out.println(""); 
    799             System.out.println("");             
    800              
    801             ResultSet rs = this.getUserPrivilegesFromDB(userDn); 
    802             StringBuffer dataAccessRoles = new StringBuffer(); 
    803              
    804             dataAccessRoles = dataAccessRoles.append( rs.getString(1) ); 
    805599             
    806600            while( rs.next() ) 
    807601            { 
    808                 dataAccessRoles = dataAccessRoles.append( ", " ); 
    809                 dataAccessRoles = dataAccessRoles.append( rs.getString(1) ); 
    810             } 
    811              
    812             String dataAccess = dataAccessRoles.toString(); 
    813              
    814             // NDB - demo-code 
    815             System.out.println("**********************************************"); 
    816             System.out.println("Get data access permissions from database for the user with the above DN"); 
    817             System.out.println("//////////////////////////////////////////////"); 
    818             System.out.println( dataAccess ); 
    819             System.out.println(""); 
    820             System.out.println("");                
    821              
     602                roleHashSet.add( rs.getString(1) ); 
     603            } 
     604 
    822605            try{ 
    823                  
     606 
    824607                rs.close(); 
    825608                rs = null;                 
     
    831614            finally { 
    832615                // Always make sure result sets and statements are closed, 
    833                 
     616 
    834617                if (rs != null) { 
    835618                    try { rs.close(); } catch (SQLException e) { ; } 
     
    846629                } 
    847630            } 
    848              
    849             AttributeList acInfo = new AttributeList(version, userDn, issuerDn,issuerName, signatureAlgorithm,issuerSerialNumber,notBefore,notAfter,dataAccess,provenance); 
    850  
    851631            // NDB - demo-code 
    852632            System.out.println("**********************************************"); 
    853             System.out.println("Create attribute list for user.  This comprises all information that will go into the user's authorisation token"); 
     633            System.out.println("Get mapped user roles from database"); 
    854634            System.out.println("//////////////////////////////////////////////"); 
     635            System.out.println( roleHashSet ); 
    855636            System.out.println(""); 
    856             System.out.println("");               
    857  
    858             Document ACDocument = signAttributeListToGetToken( acInfo ); 
    859             
    860             return ACDocument; 
    861         } catch (Exception e) { 
    862             log.error("Unable to create authorisation token",e); 
    863             throw e; 
    864         } 
    865     } 
    866      
    867     private boolean searchDBForUser( String dn ) throws ClassNotFoundException, SQLException, Exception 
     637            System.out.println("");                
     638 
     639            if( roleHashSet.isEmpty() ) 
     640            { 
     641                System.out.println("**********************************************"); 
     642                System.out.println("There are no mapped user roles in the database so a " + 
     643                    "mapped attribute certificate can not be created."); 
     644                System.out.println("//////////////////////////////////////////////"); 
     645                System.out.println(""); 
     646                System.out.println("");                
     647 
     648                return null; 
     649            } 
     650 
     651        } 
     652        //else if( mappingPreference.equals( "file" ) ) 
     653        else 
     654        { 
     655/* 
     656            mappedRoles = this.getMappedRolesFromMapFile( unquotedRoles, extOrg ); 
     657            Iterator mappedRolesIt = mappedRoles.iterator(); 
     658            while( mappedRolesIt.hasNext() ) 
     659            { 
     660                roleHashSet.add( (String) mappedRolesIt.next() ); 
     661            } 
     662*/ 
     663            roleHashSet = this.getMappedRolesFromMapFile( unquotedRoles, extOrg ); 
     664 
     665            // NDB - demo-code 
     666            System.out.println("**********************************************"); 
     667            System.out.println("Get mapped user roles from file"); 
     668            System.out.println("//////////////////////////////////////////////"); 
     669            System.out.println( roleHashSet ); 
     670            System.out.println(  ); 
     671            System.out.println(""); 
     672            System.out.println("");                
     673 
     674            if( roleHashSet.isEmpty() ) 
     675            { 
     676                System.out.println("**********************************************"); 
     677                System.out.println("There are no mapped user roles in the mapping file so a " + 
     678                    "mapped attribute certificate can not be created."); 
     679                System.out.println("//////////////////////////////////////////////"); 
     680                System.out.println(""); 
     681                System.out.println("");                                    
     682 
     683                return null; 
     684            }                 
     685        } 
     686        /* 
     687        else 
     688        { 
     689            throw new GeneralSecurityException( "mapping preference in properties file must be given value 'file' or 'database'" ); 
     690        } 
     691       */ 
     692        AttributeList acInfo = new AttributeList(version, userDn, issuerDn,issuerName, issuerSerialNumber,notBefore,notAfter,roleHashSet, provenance); 
     693 
     694        // NDB - demo-code 
     695        System.out.println("**********************************************"); 
     696        System.out.println("Create attribute list for user.  This comprises all non-signature information that will go into the user's authorisation token"); 
     697        System.out.println("//////////////////////////////////////////////"); 
     698        System.out.println(""); 
     699        System.out.println("");               
     700 
     701        ACGen acGen = new ACGen(); 
     702        Document acDocument = acGen.sign( acInfo ); 
     703        //Document ACDocument = signAttributeListToGetToken( acInfo ); 
     704        return acDocument; 
     705    } 
     706     
     707    // NOT CURRENTLY USED 
     708    /* 
     709    private Document signAttributeListToGetToken( AttributeList attList ) throws Exception 
     710    { 
     711        ACGen acGen = new ACGen(); 
     712         
     713        Document signedAttList = acGen.sign( attList ); 
     714         
     715        return signedAttList; 
     716      */   
     717        //Send for signing 
     718/* 
     719        XMLOutputter outputter = new XMLOutputter(); 
     720        String acInfoString = outputter.outputString(acInfoElement); 
     721 
     722        // NDB - demo-code 
     723        System.out.println("**********************************************"); 
     724        System.out.println("Get user's access control info from attribute list"); 
     725        System.out.println("//////////////////////////////////////////////"); 
     726        System.out.println( acInfoString ); 
     727        System.out.println(""); 
     728        System.out.println("");               
     729 
     730        String signatureString = ""; 
     731        String digestString = ""; 
     732         
     733        try 
     734        { 
     735            ACGen acGen = new ACGen(); 
     736            digestString = acGen.getDigestString(acInfoString); 
     737             
     738            signatureString = acGen.getSignatureString(acInfoString); 
     739        } 
     740        catch( Exception e ) 
     741        { 
     742            log.error("Unable to generate digest/signature from attribute list",e); 
     743            throw e;             
     744        } 
     745         
     746        //create XML document out of it 
     747 
     748        // NDB - demo-code 
     749        System.out.println("**********************************************"); 
     750        System.out.println("Generate digest from user's access control info"); 
     751        System.out.println("//////////////////////////////////////////////"); 
     752        System.out.println( digestString ); 
     753        System.out.println(""); 
     754        System.out.println("");                 
     755         
     756         
     757        // NDB - demo-code 
     758        System.out.println("**********************************************"); 
     759        System.out.println("Generate digital signature from user's access control info using authorisation server's private key"); 
     760        System.out.println("//////////////////////////////////////////////"); 
     761        System.out.println( signatureString ); 
     762        System.out.println(""); 
     763        System.out.println("");                 
     764 
     765        Document ACDocument = new Document(); 
     766        Element root = new Element("attributeCertificate"); 
     767 
     768        ACDocument.setRootElement(root); 
     769        root.addContent(acInfoElement); 
     770 
     771        Element signatureElement = new Element("Signature",signatureURL); 
     772        root.addContent(signatureElement); 
     773        Namespace sigNS = signatureElement.getNamespace(); 
     774         
     775        Element signedInfoElement = new Element("SignedInfo",sigNS); 
     776        Element signatureValueElement = new Element("SignatureValue",sigNS); 
     777        signatureElement.addContent(signedInfoElement); 
     778        signatureElement.addContent(signatureValueElement); 
     779         
     780        Element canonElement = new Element("CanonicalizationMethod",sigNS); 
     781        Element signatureMethodElement = new Element("SignatureMethod",sigNS); 
     782        Element referenceElement = new Element("Reference",sigNS); 
     783        signedInfoElement.addContent(canonElement); 
     784        signedInfoElement.addContent(signatureMethodElement); 
     785        signedInfoElement.addContent(referenceElement); 
     786         
     787        Attribute canonAtt = new Attribute( "Algorithm", canonURL, Attribute.IDREF_ATTRIBUTE ); 
     788        canonElement.setAttribute( canonAtt ); 
     789        canonElement.setText( canonicalization ); 
     790         
     791        Attribute sigMethodAtt = new Attribute( "Algorithm", sigMethodURL, Attribute.IDREF_ATTRIBUTE ); 
     792        signatureMethodElement.setAttribute( sigMethodAtt ); 
     793        signatureMethodElement.setText( signatureAlgorithm ); 
     794         
     795        Attribute referenceAtt = new Attribute( "URI", referenceURL, Attribute.IDREF_ATTRIBUTE ); 
     796        referenceElement.setAttribute( referenceAtt ); 
     797         
     798        Element digestMethodElement = new Element("DigestMethod",sigNS); 
     799        Element digestValueElement = new Element("DigestValue",sigNS); 
     800        referenceElement.addContent(digestMethodElement); 
     801        referenceElement.addContent(digestValueElement); 
     802 
     803        Attribute digMethodAtt = new Attribute( "Algorithm", digestURL, Attribute.IDREF_ATTRIBUTE ); 
     804        digestMethodElement.setAttribute( digMethodAtt ); 
     805        digestMethodElement.setText( digestAlgorithm ); 
     806         
     807        digestValueElement.setText(digestString); 
     808        signatureValueElement.setText(signatureString); 
     809         
     810         
     811        // NDB - demo-code 
     812        System.out.println("**********************************************"); 
     813        System.out.println("Put digital signature and user's access control info together to form the user's new authorisation token"); 
     814        System.out.println("//////////////////////////////////////////////"); 
     815        System.out.println( outputter.outputString(root) ); 
     816        System.out.println(""); 
     817        System.out.println("");  
     818  
     819        return ACDocument;                
     820  */           
     821         
     822//    } 
     823     
     824    // NO LONGER USED 
     825    /* 
     826    private ResultSet getMappedRolesFromDB( String roles, String extOrg ) throws Exception 
     827    { 
     828        ResultSet rs = query(mappedRolesQuery1 + extOrg + mappedRolesQuery2 + roles + ");" ); // Nov 04 
     829        return rs;         
     830    } 
     831     */ 
     832     
     833    /** This takes an external set of roles that the user holds with another data centre and checks the mapping file to see 
     834     * which internal role(s) these map to (if any). 
     835     *@param java.util.HashSet roleHashSet the set of external roles 
     836     *@param String extOrg The name of the external data centre that the user currently hols roles with 
     837     *@exception java.lang.Exception 
     838     *@return java.util.HashSet the local roles that the user is given via the trust agreement 
     839     */     
     840    private HashSet getMappedRolesFromMapFile( HashSet roleHashSet, String extOrg ) throws Exception 
     841    { 
     842        HashSet localRoles = new HashSet(); 
     843        Iterator roleHashSetIt = roleHashSet.iterator(); 
     844         
     845        // Look at each trusted element of the map file.  Where the name matches that of the ext org 
     846        // iterate through the roles array above and for each element, compare it against each of the 
     847        // 'remote' attributes to see whether there is a match.  Where there is a match, get the name 
     848        // of the corresponding local attribute. 
     849        SAXBuilder saxb = new SAXBuilder(); 
     850        org.jdom.Document mapFileDoc = saxb.build( mapFilePath ); 
     851        Element root = mapFileDoc.getRootElement(); 
     852        List trustedElements = root.getChildren("trusted"); 
     853        Element trustedElement = null; 
     854        for( int i = 0; i < trustedElements.size(); i++ ) 
     855        { 
     856            trustedElement = (Element)trustedElements.get( i ); 
     857            String trustedAttValue = trustedElement.getAttributeValue("name"); 
     858            if( trustedAttValue.equals( extOrg ) ) 
     859            { 
     860                List roleElements = trustedElement.getChildren("role"); 
     861                Element roleElement = null; 
     862                //for( int k = 0; k < roleArray.length; k++ ) 
     863                while( roleHashSetIt.hasNext() ) 
     864                { 
     865                    String role = (String) roleHashSetIt.next(); 
     866                    for( int j = 0; j < roleElements.size(); j++ ) 
     867                    { 
     868                        roleElement = (Element)roleElements.get( j ); 
     869                        String roleAttValue = roleElement.getAttributeValue("remote"); 
     870                        if( role.equals( roleAttValue ) ) 
     871                        { 
     872                            String localRole = roleElement.getAttributeValue("local"); 
     873                            localRoles.add( localRole ); 
     874                        } 
     875                    } 
     876                } 
     877            } 
     878        } 
     879 
     880        return localRoles; 
     881    } 
     882     
     883    // NOT CURRENTLY USED 
     884    private HashSet getRolesFromExtToken( org.w3c.dom.Element extToken ) throws Exception 
     885    { 
     886        HashSet roleHashSet = list.getRoleSet();             
     887 
     888        // NDB - demo-code 
     889        System.out.println("**********************************************"); 
     890        System.out.println("Extracted roles from external token"); 
     891        System.out.println("//////////////////////////////////////////////"); 
     892        System.out.println( roleHashSet ); 
     893        System.out.println(""); 
     894        System.out.println(""); 
     895         
     896        return roleHashSet; 
     897    } 
     898 
     899    // NOT CURRENTLY USED 
     900    private String getOrgFromExtToken( org.w3c.dom.Element extToken ) throws Exception 
     901    { 
     902        String extOrg = ""; 
     903         
     904        //TokenReader reader = new TokenReader(); 
     905        //uk.ac.cclrc.authorisation.AttributeList list =  reader.getAttributes( extToken );         
     906        //uk.ac.cclrc.authorisation.AttributeList list =  reader.getACInfo( extToken );         
     907        extOrg = list.getIssuerName(); 
     908 
     909        // NDB - demo-code 
     910        System.out.println("**********************************************"); 
     911        System.out.println("Extracted organisation from external token"); 
     912        System.out.println("//////////////////////////////////////////////"); 
     913        System.out.println( extOrg ); 
     914        System.out.println(""); 
     915        System.out.println(""); 
     916         
     917        return extOrg; 
     918    } 
     919     
     920     
     921    /** This method is used to create a new original authorisation token for a user.  The token contains 
     922     * the user's attributes and is digitally signed. 
     923     *@param String proxyCertString Proxy certificate of the user.  The user's DN is extracted from this. 
     924     * The DN is used to search for the user's role(s) in the database - these are included in the token. 
     925     *@exception java.lang.Exception 
     926     *@return org.jdom.Document the token is returned as a JDOM Document. 
     927     */ 
     928    private Document createAuthorisationToken(String proxyCertString) throws Exception{ 
     929        //Create authorisation Token 
     930         
     931        String version = this.version; 
     932        String provenance = "original"; 
     933 
     934        // Format user DN to allow for searching of permissions from database later 
     935        /* 
     936        String userDn = this.getUserDn(proxyCertString);             
     937        sf.setNewString( userDn ); 
     938        sf.setDNConfig( dbDNstartValue, dbDNequalityString, dbDNdelimString ); 
     939        userDn = sf.formatDN(); 
     940*/ 
     941        String issuerDn = this.getIssuerDn(); 
     942 
     943        // NDB - demo-code 
     944        System.out.println("**********************************************"); 
     945        System.out.println("Extracted issuer's DN from authorisation server's X509 certificate"); 
     946        System.out.println("This will be included in the new authorisation token generated."); 
     947        System.out.println("//////////////////////////////////////////////"); 
     948        System.out.println( issuerDn ); 
     949        System.out.println(""); 
     950        System.out.println("");             
     951 
     952        String issuerName = this.facility; 
     953        String signatureAlgorithm=this.signatureAlgorithm; 
     954        String issuerSerialNumber=this.issuerSerialNumber; 
     955        // Certificate Limitation is currently done with current time and maximum proxy validity. In future the request of 
     956        // maximum time to be made via the web service and the Server check if the request does not exceed the proxy certificate validity 
     957 
     958        int[] notBefore=  this.getCurrentTime(); 
     959 
     960        // NDB - demo-code 
     961        System.out.println("**********************************************"); 
     962        System.out.println("Get current time to determine when user's authorisation token is valid from"); 
     963        System.out.println("//////////////////////////////////////////////"); 
     964        for( int i = 0; i < notBefore.length; i++ ) 
     965        { 
     966            System.out.println( notBefore[ i ] ); 
     967        } 
     968        System.out.println(""); 
     969        System.out.println("");           
     970 
     971        int[] notAfter = this.getNotAfter(proxyCertString,tokenLifetime,notBefore); 
     972 
     973        // NDB - demo-code 
     974        System.out.println("**********************************************"); 
     975        System.out.println("Get token lifetime from config file and add to current time to determine expiry time of new token"); 
     976        System.out.println("//////////////////////////////////////////////"); 
     977        for( int i = 0; i < notAfter.length; i++ ) 
     978        { 
     979            System.out.println( notAfter[ i ] ); 
     980        } 
     981        System.out.println(""); 
     982        System.out.println("");             
     983 
     984        ResultSet rs = query(stdRolesQuery + userDn + "'"); // Nov 04 
     985         
     986        HashSet roleHashSet = new HashSet();             
     987        while( rs.next() ) 
     988        { 
     989            roleHashSet.add( rs.getString(1) ); 
     990        } 
     991 
     992        // NDB - demo-code 
     993        System.out.println("**********************************************"); 
     994        System.out.println("Get roles from database for the user with the above DN"); 
     995        System.out.println("//////////////////////////////////////////////"); 
     996        System.out.println( roleHashSet ); 
     997        System.out.println(""); 
     998        System.out.println("");                
     999 
     1000        if( roleHashSet.isEmpty() ) 
     1001        { 
     1002            return null; 
     1003        } 
     1004         
     1005        try{ 
     1006 
     1007            rs.close(); 
     1008            rs = null;                 
     1009            stat.close(); 
     1010            stat = null;                 
     1011            conn.close(); 
     1012            conn = null; 
     1013        } 
     1014        finally { 
     1015            // Always make sure result sets and statements are closed, 
     1016 
     1017            if (rs != null) { 
     1018                try { rs.close(); } catch (SQLException e) { ; } 
     1019                rs = null; 
     1020            } 
     1021            if (stat != null) { 
     1022                try { stat.close(); } catch (SQLException e) { ; } 
     1023                stat = null; 
     1024            } 
     1025            if (conn != null) { 
     1026                try { conn.close(); } catch (SQLException e) { 
     1027                    log.warn("Connection unable to be closed",e);  } 
     1028                conn = null; 
     1029            } 
     1030        } 
     1031 
     1032        AttributeList acInfo = new AttributeList(version, userDn, issuerDn,issuerName,issuerSerialNumber,notBefore,notAfter,roleHashSet,provenance); 
     1033 
     1034        // NDB - demo-code 
     1035        System.out.println("**********************************************"); 
     1036        System.out.println("Create attribute list for user.  This comprises all non-signature information that will go into the user's authorisation token"); 
     1037        System.out.println("//////////////////////////////////////////////"); 
     1038        System.out.println(""); 
     1039        System.out.println("");               
     1040 
     1041        ACGen acGen = new ACGen(); 
     1042        Document acDocument = acGen.sign( acInfo ); 
     1043        //Document ACDocument = signAttributeListToGetToken( acInfo ); 
     1044 
     1045        return acDocument; 
     1046    } 
     1047     
     1048    /** This method is used to search the database for the user.  This search is done by user DN. 
     1049     *@param String proxyCert Proxy certificate of the user.  The user's DN is extracted from this. 
     1050     *@exception java.lang.Exception 
     1051     *@exception java.lang.ClassNotFoundException 
     1052     *@exception java.sql.SQLException 
     1053     *@return boolean true/false indicates whether user was found in database or not. 
     1054     */ 
     1055    public boolean searchDBForUser( String proxyCert ) throws ClassNotFoundException, SQLException, Exception 
    8681056    { 
    8691057        boolean userPresent = false; 
    8701058     
    871         try 
    872         { 
    873             ResultSet rs = query(userQuery + dn + "'"); // Nov 04 
    874             userPresent = rs.next(); 
    875         } 
    876         catch (Exception e) 
    877         { 
    878             log.error(e); 
    879             throw e; // need to modify it 
    880         } 
     1059        userDn = this.getUserDn( proxyCert ); 
     1060         
     1061        System.out.println("**********************************************"); 
     1062        System.out.println("User DN extracted from user's proxy certificate"); 
     1063        System.out.println("//////////////////////////////////////////////"); 
     1064        System.out.println( userDn ); 
     1065        System.out.println(""); 
     1066 
     1067        sf.setNewString( userDn ); 
     1068        sf.setDNConfig( dbDNstartValue, dbDNequalityString, dbDNdelimString ); 
     1069        userDn = sf.formatDN(); 
     1070         
     1071        System.out.println("**********************************************"); 
     1072        System.out.println("Formatted the user DN to allow searching for the user in the database"); 
     1073        System.out.println("//////////////////////////////////////////////"); 
     1074        System.out.println( userDn ); 
     1075        System.out.println(""); 
     1076        System.out.println("");         
     1077         
     1078        ResultSet rs = query(userQuery + userDn + "'"); // Nov 04 
     1079        userPresent = rs.next(); 
     1080 
    8811081        return userPresent; 
    8821082    } 
    8831083     
     1084    // NOT CURRENTLY USED 
     1085    /* 
    8841086    private ResultSet getUserPrivilegesFromDB(String userDn) throws ClassNotFoundException,SQLException ,Exception{ 
    885         try { 
    886             ResultSet rs = query(stdRolesQuery + userDn + "'"); // Nov 04 
     1087         
     1088        ResultSet rs = query(stdRolesQuery + userDn + "'"); // Nov 04 
     1089     */ 
     1090/* 
     1091        if(rs.next()){ 
     1092*/ 
     1093    /*      rs.next(); 
     1094            return rs; 
     1095     */ 
     1096            /* 
     1097        } 
     1098        else 
     1099        { 
     1100            //log.warn("DN "+userDn +" not in database."); 
     1101            //return rs; 
     1102            throw new GeneralSecurityException( "User " + userDn + " has no roles in the database" ); 
     1103        } 
     1104             */ 
    8871105             
    888             if(rs.next()){ 
    889                  
    890                 return rs; 
    891             } 
    892             else 
    893             { 
    894                 log.warn("DN "+userDn +" not in database."); 
    895                 return rs; 
    896             } 
    897              
    898         } 
    899         catch (Exception e) { 
    900             log.error(e); 
    901             throw e; // need to modify it 
    902         } 
    903     } 
     1106 //   } 
    9041107    
     1108    /** This method is used to submit queries to the database. 
     1109     *@param String expression The SQL statement to be executed 
     1110     *@exception java.lang.Exception 
     1111     *@return java.sql.ResultSet this is the result of the SQL query 
     1112     */         
    9051113    public synchronized ResultSet query(String expression) throws Exception 
    9061114    { 
     
    9081116        { 
    9091117            Class.forName(dbDriverClass); // Nov 04 
    910             conn = DriverManager.getConnection(dbDriverString+"//"+server+":"+ port+"/"+dbName); // Nov 04 
     1118            if( userName == null || password == null ) 
     1119            { 
     1120                conn = DriverManager.getConnection(dbDriverString+"//"+server+":"+ port+"/"+dbName); // Nov 04 
     1121            } 
     1122            else 
     1123            { 
     1124                conn = DriverManager.getConnection(dbDriverString+"//"+server+":"+ port+"/"+dbName, userName, password ); // Nov 04 
     1125            } 
    9111126            stat = conn.createStatement(); 
    9121127            ResultSet rs = stat.executeQuery(expression);       // run the query 
     
    9271142    public void saveToDb(){ 
    9281143    } 
    929     /** Method to get UserDn from user's Proxy Certificate */ 
    930     private String getUserDn(String proxyCertString)throws Exception{ 
    931         try { 
    932             GlobusCredential globusCredential = new GlobusCredential(new ByteArrayInputStream(proxyCertString.getBytes())); 
    933             //return globusCredential.getSubject(); 
    934             //System.out.println(globusCredential.getIdentityCertificate().getSubjectDN().toString()); 
     1144     
     1145    /** Method to get UserDn from user's Proxy Certificate 
     1146     *@param String roles a comma-separated list of local roles that are needed to access a given dataset at this data centre 
     1147     *@exception java.lang.Exception 
     1148     *@return java.util.HashSet the list of trusted hosts 
     1149     */         
     1150    private String getUserDn(String proxyCertString) throws Exception{ 
     1151         
     1152        GlobusCredential globusCredential = new GlobusCredential(new ByteArrayInputStream(proxyCertString.getBytes())); 
     1153        //return globusCredential.getSubject(); 
     1154        //System.out.println(globusCredential.getIdentityCertificate().getSubjectDN().toString()); 
     1155 
     1156        GSSCredential userCredential = new GlobusGSSCredentialImpl(globusCredential,GSSCredential.INITIATE_AND_ACCEPT); 
     1157        //user globus dns for User dn 
     1158        //X509Certificate cert = globusCredential.getIdentityCertificate(); 
     1159        // System.out.println(cert.getSubjectDN().toString()); 
     1160        //return cert.getSubjectDN().toString(); 
     1161 
     1162        return userCredential.getName().toString(); 
     1163        //return userCredential.getName().toString(); 
     1164        /* for test 
     1165                    FileReader fileReader = new FileReader("/home/asm67/project/authorisation/certificates/test.cred"); 
     1166        BufferedReader in = new BufferedReader(fileReader); 
     1167        String inputLine; 
     1168        StringBuffer cert= new StringBuffer(); 
     1169        while ((inputLine = in.readLine()) !=null) { 
     1170            cert.append(inputLine); 
     1171            cert.append("\n"); 
     1172        } 
     1173        in.close(); 
     1174        String certificate=cert.toString(); 
     1175         uk.ac.cclrc.authorisation. 
     1176        GlobusCredential globusCredential = new GlobusCredential(new ByteArrayInputStream(certificate.getBytes())); 
     1177        //return globusCredential.getSubject(); 
     1178        System.out.println(globusCredential.getIdentityCertificate().getSubjectDN().toString()); 
     1179 
     1180        GSSCredential userCredential = new GlobusGSSCredentialImpl(globusCredential,GSSCredential.INITIATE_AND_ACCEPT); 
     1181        return userCredential.getName().toString(); 
     1182         */ 
    9351183             
    936             GSSCredential userCredential = new GlobusGSSCredentialImpl(globusCredential,GSSCredential.INITIATE_AND_ACCEPT); 
    937             //user globus dns for User dn 
    938             //X509Certificate cert = globusCredential.getIdentityCertificate(); 
    939             // System.out.println(cert.getSubjectDN().toString()); 
    940             //return cert.getSubjectDN().toString(); 
    941              
    942             return userCredential.getName().toString(); 
    943             //return userCredential.getName().toString(); 
    944             /* for test 
    945                         FileReader fileReader = new FileReader("/home/asm67/project/authorisation/certificates/test.cred"); 
    946             BufferedReader in = new BufferedReader(fileReader); 
    947             String inputLine; 
    948             StringBuffer cert= new StringBuffer(); 
    949             while ((inputLine = in.readLine()) !=null) { 
    950                 cert.append(inputLine); 
    951                 cert.append("\n"); 
    952             } 
    953             in.close(); 
    954             String certificate=cert.toString(); 
    955              uk.ac.cclrc.authorisation. 
    956             GlobusCredential globusCredential = new GlobusCredential(new ByteArrayInputStream(certificate.getBytes())); 
    957             //return globusCredential.getSubject(); 
    958             System.out.println(globusCredential.getIdentityCertificate().getSubjectDN().toString()); 
    959               
    960             GSSCredential userCredential = new GlobusGSSCredentialImpl(globusCredential,GSSCredential.INITIATE_AND_ACCEPT); 
    961             return userCredential.getName().toString(); 
    962              */ 
    963              
    964         } catch(Exception e) { 
    965             e.printStackTrace(); 
    966             throw e; 
    967         } 
    968     } 
    969      
    970     /** Method to get authorisation Server's DN */ 
     1184    } 
     1185     
     1186    /** This method is the authorisation Server's DN. 
     1187     *@exception java.io.IOException 
     1188     *@exception java.security.InvalidKeyException 
     1189     *@exception java.security.GeneralSecurityException 
     1190     *@return String the DN is returned as a String 
     1191     */         
    9711192    private String getIssuerDn() throws IOException, GeneralSecurityException, InvalidKeyException{ 
    9721193        //Load Host's Certificate. 
     
    9791200        String keyStorePasswd = prop.getProperty("keystore_passwd"); 
    9801201        String keyStoreAlias = prop.getProperty("keystore_alias"); 
     1202        String keyStoreType = prop.getProperty("keystore_type");         
     1203        if( keyStoreType == null ) 
     1204        { 
     1205            throw new GeneralSecurityException( "The type of keystore is not specified in the config file" ); 
     1206        }                 
     1207         
     1208        if( keyStoreAlias == null ) 
     1209        { 
     1210            throw new GeneralSecurityException( "The keystore alias is not specified in the config file" ); 
     1211        }         
    9811212         
    9821213        // System.out.println(keyStoreFileName); 
     
    9841215        if(keyStorePasswd == null || keyStorePasswd.equals("")) keyStorePasswd = "changeit"; 
    9851216         
    986         KeyStore keystore = KeyStore.getInstance("JKS"); 
     1217        //KeyStore keystore = KeyStore.getInstance( "JKS" ); 
     1218        KeyStore keystore = KeyStore.getInstance( keyStoreType ); 
    9871219        keystore.load(new FileInputStream(keyStoreFileName), keyStorePasswd.toCharArray()); 
    9881220         
    9891221        java.security.cert.X509Certificate cert = (X509Certificate)keystore.getCertificate(keyStoreAlias); 
    9901222         
    991         // NDB - demo-code 
    992         System.out.println("**********************************************"); 
    993         System.out.println("Retrieved authorisation server's X509 certificate from its keystore"); 
    994         System.out.println("//////////////////////////////////////////////"); 
    995         System.out.println( cert ); 
    996         System.out.println(""); 
    997         System.out.println("");         
     1223        if( cert == null ) 
     1224        { 
     1225            throw new GeneralSecurityException( "The key store alias specified in the config file is not valid" ); 
     1226        } 
    9981227         
    9991228        return cert.getIssuerDN().toString(); 
    10001229    } 
    10011230     
     1231     
     1232    /** This method is used to find out who this data centre's trusted hosts are from the database. 
     1233     * It does not take into account which individual role mappings a user may need to access a given dataset 
     1234     *@exception java.lang.Exception 
     1235     *@return java.util.HashSet the list of trusted hosts 
     1236     */     
    10021237    public HashSet getTrustedHostsFromDB() throws Exception 
    10031238    { 
    1004         try { 
    1005             ResultSet rs = query( affilOrgsQuery ); // Nov 04 
    1006             HashSet affilOrgs = new HashSet(); 
    1007             while( rs.next() ) 
    1008             { 
    1009                 String nextOrg = rs.getString( 1 ); 
    1010                 affilOrgs.add( nextOrg ); 
    1011             } 
    1012              
    1013             // NDB - demo-code 
    1014             System.out.println("**********************************************"); 
    1015             System.out.println("Get a list of organisations from DB who have a bilateral trust agreement with this one."); 
    1016             System.out.println("If the user's current authorisation token is not accepted," + 
    1017                 " they should use an original token from an organisation in this list if possible."); 
    1018             System.out.println("//////////////////////////////////////////////");            
    1019  
    1020             return affilOrgs;         
    1021         } 
    1022         catch (Exception e) { 
    1023             log.error(e); 
    1024             throw e; // need to modify it 
    1025         } 
    1026          
    1027     } 
    1028  
     1239 
     1240        ResultSet rs = query( affilOrgsQuery ); // Nov 04 
     1241        HashSet affilOrgs = new HashSet(); 
     1242        while( rs.next() ) 
     1243        { 
     1244            String nextOrg = rs.getString( 1 ); 
     1245            affilOrgs.add( nextOrg ); 
     1246        } 
     1247 
     1248        // NDB - demo-code 
     1249        System.out.println("**********************************************"); 
     1250        System.out.println("Get a list of organisations from DB who have a bilateral trust agreement with this one."); 
     1251        System.out.println("If the user's current authorisation token is not accepted," + 
     1252            " they should use an original token from an organisation in this list if possible."); 
     1253        System.out.println("//////////////////////////////////////////////");            
     1254 
     1255        return affilOrgs;         
     1256         
     1257    } 
     1258 
     1259    /** This method is used to find out who this data centre's trusted hosts are from the mapping file. 
     1260     * It takes into account which individual role mappings a user needs to access a given dataset 
     1261     *@param String roles a comma-separated list of local roles that are needed to access a given dataset at this data centre 
     1262     *@exception java.lang.Exception 
     1263     *@return java.util.HashSet the list of trusted hosts 
     1264     */         
    10291265    public HashSet getTrustedHostsFromMapFile( String roles ) throws Exception 
    10301266    { 
     
    10711307    } 
    10721308 
     1309    /** This method is used to find out who this data centre's trusted hosts are from the mapping file. 
     1310     * It does not take into account which individual role mappings a user may need to access a given dataset 
     1311     *@exception java.lang.Exception 
     1312     *@return java.util.HashSet the list of trusted hosts 
     1313     */         
    10731314    public HashSet getTrustedHostsFromMapFile() throws Exception 
    10741315    { 
     
    10981339    } 
    10991340     
    1100      
     1341    /** This method is used to find out who this data centre's trusted hosts are from the database. 
     1342     * It takes into account which individual role mappings a user needs to access a given dataset 
     1343     *@param String roles a comma-separated list of local roles that are needed to access a given dataset at this data centre 
     1344     *@exception java.lang.Exception 
     1345     *@return java.util.HashSet the list of trusted hosts 
     1346     */     
    11011347    public HashSet getTrustedHostsFromDB( String roles ) throws Exception 
    11021348    { 
    1103         try { 
    1104             ResultSet rs = query( affilOrgsQuery2 + roles + ");" ); // Nov 04 
    1105             HashSet affilOrgs = new HashSet(); 
    1106             while( rs.next() ) 
    1107             { 
    1108                 String nextOrg = rs.getString( 1 ); 
    1109                 affilOrgs.add( nextOrg ); 
    1110             } 
    1111              
    1112             // NDB - demo-code 
    1113             System.out.println("**********************************************"); 
    1114             System.out.println("Got trusted hosts from DB based on local roles required"); 
    1115             System.out.println("//////////////////////////////////////////////"); 
    1116             System.out.println( affilOrgs ); 
    1117             System.out.println(""); 
    1118             System.out.println(""); 
    1119              
    1120             return affilOrgs;         
    1121         } 
    1122         catch (Exception e) { 
    1123             log.error(e); 
    1124             throw e; // need to modify it 
    1125         } 
    1126          
     1349        ResultSet rs = query( affilOrgsQuery2 + roles + ");" ); // Nov 04 
     1350        HashSet affilOrgs = new HashSet(); 
     1351        while( rs.next() ) 
     1352        { 
     1353            String nextOrg = rs.getString( 1 ); 
     1354            affilOrgs.add( nextOrg ); 
     1355        } 
     1356 
     1357        // NDB - demo-code 
     1358        System.out.println("**********************************************"); 
     1359        System.out.println("Got trusted hosts from DB based on local roles required"); 
     1360        System.out.println("//////////////////////////////////////////////"); 
     1361        System.out.println( affilOrgs ); 
     1362        System.out.println(""); 
     1363        System.out.println(""); 
     1364 
     1365        return affilOrgs;         
    11271366    } 
    11281367     
    11291368    
    11301369     
    1131     /** Method to get the current time. Used in the Attribute Certificate not before 
    1132      * The milli seconds denote the difference between 1st Jan 1970 00:00 GMT 
    1133      */ 
     1370    /** Method to get the current time expressed as an array of int's 
     1371     *@return int[] The time is returned as an array of int's in the following order:  
     1372     * year, month, date, hour of day, minute, second 
     1373     */     
    11341374    private int[] getCurrentTime() { 
    11351375        GregorianCalendar calendar = new GregorianCalendar(); 
     
    11441384         
    11451385    } 
    1146     /** Method to get maximum validity of the proxy certificate. Used in the Attribute Certificate not after 
    1147      * The milli seconds denote the difference between 1st Jan 1970 00:00 GMT 
    1148      */ 
    1149     private int[] getNotAfter(String proxyCertString,int[] time) throws Exception { 
     1386 
     1387    /** Method to get expiry time of the Attribute Certificate based on the current time plus the lesser of the lifetime of the proxy certificate 
     1388     ** and the lifetime specified in the config file. 
     1389     *@param String proxyCertString Proxy certificate of the user. 
     1390     *@param String tokenLifetime The maximum lifetime of the token specified in the config file. 
     1391     *@param int[] time The current time expressed as an array of int's in the following order: 
     1392     * year, month, date, hour_of_day, minute, second 
     1393     *@exception java.lang.Exception 
     1394     *@return int[] the expiry time of the token 
     1395     */         
     1396    private int[] getNotAfter(String proxyCertString,String tokenLifetime,int[] time) throws Exception { 
    11501397        GlobusCredential globusCredential = new GlobusCredential(new ByteArrayInputStream(proxyCertString.getBytes())); 
    11511398        GSSCredential userCredential = new GlobusGSSCredentialImpl(globusCredential,GSSCredential.INITIATE_AND_ACCEPT); 
    11521399        int remainingTime = userCredential.getRemainingLifetime(); //time is seconds left 
    11531400         
    1154         if(remainingTime == 0) throw new Exception("Certificate has timed out"); 
     1401        if(remainingTime == 0) throw new GeneralSecurityException("Proxy certificate has timed out"); 
    11551402        GregorianCalendar notAfterCal = new GregorianCalendar(time[0],time[1],time[2],time[3],time[4],time[5]);         
    1156         notAfterCal.add( Calendar.SECOND, remainingTime ); 
     1403         
     1404        int lifetime = remainingTime; 
     1405         
     1406        if( tokenLifetime.length() == 8 ) 
     1407        { 
     1408            int days = 0; 
     1409            int hours = 0; 
     1410            int minutes = 0; 
     1411 
     1412            try 
     1413            { 
     1414                String dayString = tokenLifetime.substring( 0, 2 ); 
     1415                days = Integer.parseInt( dayString ); 
     1416 
     1417                String hourString = tokenLifetime.substring( 3, 5 ); 
     1418                hours = Integer.parseInt( hourString ); 
     1419 
     1420                String minuteString = tokenLifetime.substring( 6, 8 ); 
     1421                minutes = Integer.parseInt( minuteString ); 
     1422                 
     1423                if( days >= 0 && hours >= 0 && hours < 24 && minutes > 0 && minutes < 60 ) 
     1424                { 
     1425                    lifetime = ( minutes * 60 ) + ( hours * 60 * 60 ) + ( days * 60 * 60 * 24 ); // in seconds 
     1426 
     1427                    if( remainingTime < lifetime ) 
     1428                    { 
     1429                        lifetime = remainingTime; 
     1430                    }             
     1431                } 
     1432            } 
     1433            catch( Exception e ) 
     1434            { 
     1435                log.error("Lifetime of authorisation token not specified in config file correctly",e); 
     1436                //throw e; 
     1437            } 
     1438        } 
     1439 
     1440        notAfterCal.add( Calendar.SECOND, lifetime ); 
    11571441        int[] notAfter = new int[6]; 
    11581442        notAfter[0]= notAfterCal.get(Calendar.YEAR); 
  • dataportal/trunk/acmnerc/src/uk/ac/cclrc/authorisation/unittest/TestACClient.java

    r78 r91  
    3333 
    3434 
    35             System.out.println("Data access "+list.getDataAccessGroup()); 
     35            //System.out.println("Data access "+list.getDataAccessGroup()); 
     36            System.out.println("Data access "+list.getRoleSet()); 
    3637            // System.out.println("Wrapper access "+list.getWrapperGroup()); NDB 
    3738            // System.out.println("Facility access "+list.getDPView()); NDB 
  • dataportal/trunk/acmnerc/src/uk/ac/cclrc/authorisation/unittest/TestACServer.java

    r78 r91  
    100100            System.out.println("Read user's authorisation token file back in and get data access permissions from it"); 
    101101            System.out.println("//////////////////////////////////////////////"); 
    102             System.out.println( list.getDataAccessGroup() ); 
     102            //System.out.println( list.getDataAccessGroup() ); 
     103            System.out.println( list.getRoleSet() ); 
    103104            System.out.println(""); 
    104105            System.out.println("");    
  • dataportal/trunk/acmnerc/src/uk/ac/cclrc/authorisation/unittest/TestACServer_1.java

    r89 r91  
    1212import org.jdom.*; 
    1313import org.jdom.input.*; 
     14import org.jdom.output.*; 
    1415import ac.dl.xml.*; 
    1516import org.globus.util.Base64; 
    1617import java.util.*; 
    17 //import org.w3c.dom.*; 
    1818 
    19  
    20 /*import org.globus.gsi.*; 
    21 import org.globus.gsi.gssapi.*; 
    22 import java.net.*; 
    23 import org.ietf.jgss.*; 
    24 import java.io.*;*/ 
    2519/** 
    2620 * 
     
    3630            ACServer acs= new ACServer(); 
    3731             
    38             HashSet trustedHosts = acs.getTrustedHostsFromDB(); 
     32            HashSet trustedHosts = null; 
     33            /* 
     34            trustedHosts = acs.getTrustedHostsFromDB(); 
    3935            Iterator it = trustedHosts.iterator(); 
    4036            while( it.hasNext() ) 
     
    4945                System.out.println( (String)it.next() ); 
    5046            } 
    51              
     47            */ 
    5248             
    5349            //load in cert 
    54             // URL url1 = new URL("file:///c:/cred.au3"); NDB 
    5550            //URL url1 = new URL("file:///D:/Neil/X509up_u_sas27"); 
    56             URL url1 = new URL("file:///D:/Neil/X509up_u_ndb23"); 
    57             //http://dmgdev1.esc.rl.ac.uk:9080/sessionmanager/services/SessionManager      // System.out.println(url); 
    58             URLConnection con = url1.openConnection(); 
    59             InputStream in2 = con.getInputStream(); 
    60             BufferedReader in = new BufferedReader(new InputStreamReader(in2)); 
    61             String inputLine; 
    62             // String certt; 
    63             StringBuffer cert = new StringBuffer(); 
    64             while ((inputLine = in.readLine()) != null){ 
    65                 //  System.out.println(inputLine); 
    66                 cert.append(inputLine); 
    67                 cert.append("\n"); 
    68                 // if(!inputLine.equals("-----END CERTIFICATE-----"))  cert.append("\n"); 
    69                  
    70             } 
    71             in.close(); 
    72             String cert3 = cert.toString(); 
    73              
    74             //System.out.println(acs.getUserDn("aa")); 
    75             //System.out.println(acs.getUserDn(cert3)); 
    76             //System.out.println(acs.getAuthorisationTokenInXML(cert3)); 
    77              
    7851            // NDB - demo-code 
    7952            System.out.println("**********************************************"); 
    80             System.out.println("Loaded in user's proxy certificate file and extracted as string"); 
     53            System.out.println("Loaded in user's proxy certificate file"); 
    8154            System.out.println("//////////////////////////////////////////////"); 
    82             System.out.println( cert3 ); 
    8355            System.out.println(""); 
    8456            System.out.println(""); 
     
    8860            org.jdom.Document authTokenDoc = saxb.build("file:///C:/bodcAuthToken.cred"); 
    8961            org.w3c.dom.Document domDoc = Converter.JDOMtoDOM( authTokenDoc ); 
    90             org.w3c.dom.Element foreignToken = domDoc.getDocumentElement(); 
    91             org.w3c.dom.Element xml  = acs.getAuthorisationTokenInDOM(cert3, foreignToken ); 
    92  
    93 //            org.w3c.dom.Element xml  = acs.getAuthorisationTokenInDOM( cert3 ); 
    94              
    95              
    96             org.jdom.input.DOMBuilder buildert = new org.jdom.input.DOMBuilder(); 
    97             org.jdom.Element el = buildert.build(xml); 
    98             Document d = new Document(el); 
    99             Saver.save(d,new File("c:/ws.cred")); 
    100             // System.out.println("Saved file to c:/xml.xml"); 
    101              
    102             // NDB - demo-code 
    103             System.out.println("**********************************************"); 
    104             System.out.println("Save user's new authorisation token in file 'ws.cred'"); 
    105             System.out.println("//////////////////////////////////////////////"); 
    106             System.out.println(""); 
    107             System.out.println("");                 
    108              
    10962             
    11063            TokenReader reader = new TokenReader(); 
    111             org.w3c.dom.Document doc = Converter.JDOMtoDOM(d); 
    112             org.w3c.dom.Element element = doc.getDocumentElement(); 
     64            org.w3c.dom.Element element = domDoc.getDocumentElement(); 
    11365             
    114              
    115             //   org.w3c.dom.Document doc =XML_DOMBuilder.parse(new File("c:/xml.xml")); 
    116             //   org.w3c.dom.Element element  = doc.getDocumentElement(); 
    117              
    118              
    119             //TokenReader reader = new TokenReader(); 
    120              
    121             uk.ac.cclrc.authorisation.AttributeList list =  reader.getAttributes(element); 
     66            uk.ac.cclrc.authorisation.AttributeList list =  reader.getACInfo( element ); 
    12267             
    12368            // cred = GlobusProxy.load(data,caCertLocation); 
     
    12570            // NDB - demo-code 
    12671            System.out.println("**********************************************"); 
    127             System.out.println("Read user's authorisation token file back in and get data access permissions from it"); 
     72            System.out.println("Read user's authorisation token file back in and get roles from it"); 
    12873            System.out.println("//////////////////////////////////////////////"); 
    129             System.out.println( list.getDataAccessGroup() ); 
     74            System.out.println( list.getRoleSet() ); 
    13075            System.out.println(""); 
    13176            System.out.println("");    
    13277 
     78/*             
    13379            trustedHosts = acs.getTrustedHostsFromMapFile( "postdoc"); 
    134              
    13580            trustedHosts = acs.getTrustedHostsFromDB( "'postdoc'"); 
    136              
    137             // System.out.println("Data access: "+list.getDataAccessGroup()); NDB 
    138             // System.out.println("Wrapper access "+list.getWrapperGroup()); NDB 
    139             // System.out.println("Meta access "+list.getDPView()); NDB 
    140              
    141             //getUserPrivilegesFromDB(); 
     81*/             
     82 
    14283        } catch (Exception e){ 
    143             System.out.println(e); 
     84            e.printStackTrace(); 
    14485        } 
    14586    } 
  • dataportal/trunk/acmnerc/src/uk/ac/cclrc/authorisation/util/StringFormatter.java

    r78 r91  
    1313public class StringFormatter { 
    1414     
    15     private String firstString;    
    16     private int stringLength; 
     15    private String firstString;   // string to be formatted 
     16    private int stringLength;     // length of string to be formatted 
    1717     
    18     private String Cvalue, Ovalue, OUvalue, Lvalue, CNvalue, formattedString, dnDelim, dnStart, dnEquals; 
     18    private String Cvalue, Ovalue, OUvalue, Lvalue, CNvalue; // values of the different components of the DN 
     19    private String formattedString; // complete formatted string 
     20    private String dnDelim; // string that delimits components of the new DN 
     21    private String dnStart; // string signifying which is the first element of the new DN 
     22    private String dnEquals; // string signifying how equality is represented in each component of the DN 
    1923 
    20      
     24 
    2125    public StringFormatter(String initString) 
    2226    { 
     
    2428        stringLength = firstString.length(); 
    2529    } 
    26      
     30 
     31    /** This method specifies the next string to be formatted. 
     32     *@param String newString The new string 
     33     */         
    2734    public void setNewString( String newString ) 
    2835    { 
     
    3037        stringLength = firstString.length(); 
    3138    } 
    32      
     39 
     40    /** Used to set the config for formatting DNs 
     41     *@param String start The element of the DN that will start the formatted DN (this can only ever be CN or C) 
     42     *@param String equality The string used to represent equality in the formatted DN 
     43     *@param String delim The string used to delimit elements in the formatted DN 
     44     */         
    3345    public void setDNConfig( String start, String equality, String delim ) 
    3446    { 
     
    3850    } 
    3951   
     52    // formats DN strings 
     53    /** Used to obtain a formatted DN once the configuration and new string have been set 
     54     *@return String the formatted DN 
     55     */             
    4056    public String formatDN() 
    4157    { 
    42        
    4358        Cvalue = getDNFieldValue( "C" );     
    4459        Ovalue = getDNFieldValue( "O" ); 
     
    6378    } 
    6479     
     80    /** Extracts the value of the specified element within the DN 
     81     *@param String fieldName The name of the element whose value is required 
     82     *@return String The value of the DN element 
     83     */             
    6584    public String getDNFieldValue( String fieldName ) 
    6685    { 
     
    7089         
    7190        int fieldNameLength = fieldNameStr.length(); 
     91         
     92        // the index at which the field value starts 
    7293        int fieldValueIndex = firstString.indexOf( fieldNameStr ) + fieldNameLength; 
     94         
     95        // the index of the first delimiter after the current field value 
    7396        int nextDelimIndex = firstString.indexOf( "/", fieldValueIndex ); 
    74         if( nextDelimIndex == -1 ) 
     97         
     98        if( nextDelimIndex == -1 ) // when the current field is the last field of the DN 
    7599        { 
    76100            dnFieldValue = firstString.substring( fieldValueIndex, firstString.length() ); 
    77101        } 
    78         else 
     102        else // when the current field is not the last field 
    79103        { 
    80104            dnFieldValue = firstString.substring( fieldValueIndex, nextDelimIndex ); 
     
    84108    } 
    85109 
    86     public String removeQuotes() 
     110    /** Removes quotes from a quoted string 
     111     *@exception Exception 
     112     *@return String The unquoted string 
     113     */             
     114    public String removeQuotes() throws Exception 
    87115    { 
    88         
     116        if( firstString.charAt( 0 ) != '"' || firstString.charAt( stringLength - 1 ) != '"' ) 
     117        { 
     118            throw new Exception( "SQL query strings in the config file must be start and end with quotation marks" ); 
     119        } 
    89120        String unquotedString = firstString.substring(1,stringLength-1);                 
    90121        return unquotedString; 
    91122    } 
    92123 
     124    /** Adds quotes to each element of a list of unquoted strings 
     125     *@return String The quoted list 
     126     */             
    93127    public String addQuotesToList() 
    94128    { 
    95         String[] unquotedArray = firstString.split( ", " );     
     129         
     130        String[] unquotedArray = firstString.split( ", " ); // obtains an array from the unquoted list 
    96131        int numOfElements = unquotedArray.length; 
    97132        StringBuffer quotedList = new StringBuffer(); 
Note: See TracChangeset for help on using the changeset viewer.