Changeset 84f0e7a


Ignore:
Timestamp:
Mar 24, 2011 7:30:38 PM (8 years ago)
Author:
Ted Faber <faber@…>
Branches:
abac0-leak, abac0-mei, compt_changes, gec13, master, mei-id, mei-rt0-n, mei_rt0, mei_rt2, mei_rt2_fix_1, meiyap-rt1, meiyap1, rt2, tvf-new-xml
Children:
418b586
Parents:
e9360e2
Message:

Initial run at unifying the interface.

Location:
java
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • java/GraphTest.java

    re9360e2 r84f0e7a  
    55
    66import net.deterlab.abac.Credential;
    7 import net.deterlab.abac.CredentialGraph;
     7import net.deterlab.abac.Context;
    88import net.deterlab.abac.Query;
    99import net.deterlab.abac.Role;
     
    2525        }
    2626
    27         CredentialGraph graph = new CredentialGraph();
     27        Context ctxt = new Context();
    2828        Map<String, Exception> errs = new HashMap<String, Exception>();
    2929
     
    3333            try {
    3434                if (f.isDirectory())
    35                     for (Credential c :Credential.readDirectory(f, errs))
    36                         graph.add_credential(c);
     35                    ctxt.readDirectory(f, errs);
    3736                else if (f.getPath().endsWith(".pem"))
    38                     Credential.addIdentity(new Identity(f));
     37                    ctxt.loadIDFile(f);
    3938                else if (f.getPath().endsWith(".der"))
    40                     graph.add_credential(new Credential(f));
     39                    ctxt.loadAttributeFile(f);
    4140                else if (f.getPath().endsWith(".zip"))
    42                     for (Credential c :Credential.readZipFile(f, errs))
    43                         graph.add_credential(c);
     41                    ctxt.readZipFile(f, errs);
    4442                else
    4543                    System.out.println(f + " of unknown type");
     
    5654        //
    5755
    58         Role role = new Role(args[args.length-2], true);
    59         Role prin = new Role(args[args.length-1], true);
    60         Query q = graph.querier();
    61         Graph<Role, Credential> ret = q.run(role.toString(), prin.toString());
     56        Role role = new Role(args[args.length-2], ctxt);
     57        Role prin = new Role(args[args.length-1], ctxt);
     58        Collection<Credential> ret = ctxt.query(role.toString(), prin.toString());
     59        Set<Identity> ids = new TreeSet<Identity>();
     60
    6261        String fn = "attr";
    6362        int n = 0;
    6463        String suf = ".der";
    65         for (Credential c : ret.getEdges()) {
    66             System.out.println(c.simpleString());
    67             if ( c.hasCertificate()) c.write(fn + n++ + suf);
     64        for (Credential c : ret) {
     65            System.out.println(c.simpleString(ctxt));
     66            if ( c.hasCertificate()) {
     67                c.write(fn + n++ + suf);
     68                ids.add(c.getID());
     69            }
    6870        }
    6971
     
    7173        n = 0;
    7274        suf = ".pem";
    73         for (Identity i: Credential.identities()) {
     75        for (Identity i: ids) {
    7476            System.out.println("ID: " + i);
    7577            i.write(fn + n++ + suf);
    7678        }
    77         Credential.writeZipFile(graph.credentials(),
    78                 new File("./testout.zip"), true, true);
     79        ctxt.writeZipFile(new File("./testout.zip"), true, true);
    7980    }
    8081}
  • java/net/deterlab/abac/Credential.java

    re9360e2 r84f0e7a  
    4949     * Do the credential initialization from a filename.
    5050     */
    51     protected void init(InputStream stream) throws Exception {
     51    protected void read_certificate(InputStream stream)
     52            throws Exception {
    5253        X509AttrCertParser parser = new X509AttrCertParser();
    5354        parser.engineInit(stream);
    5455        m_ac = (X509V2AttributeCertificate)parser.engineRead();
    55         m_id = null;
    56 
    57         if ( m_ac == null ) throw new IOException("Invalid Credential Format");
    58 
    59         for (Identity id: s_ids) {
     56    }
     57
     58
     59    protected void init(InputStream stream, Collection<Identity> ids)
     60            throws Exception {
     61        read_certificate(stream);
     62        if (m_ac == null) throw new IOException("Unknown Format");
     63        init(ids);
     64    }
     65
     66    protected void init(Collection<Identity> ids)
     67            throws CertificateException, InvalidKeyException, NoSuchAlgorithmException, NoSuchProviderException,SignatureException {
     68        for (Identity id: ids) {
    6069            try {
    6170                m_ac.verify(id.getCertificate().getPublicKey(), "BC");
     
    7281            throw new InvalidKeyException("Unknown identity");
    7382    }
    74 
    7583    /**
    7684     * Create a credential from an attribute cert. Throws an exception if the
    7785     * cert file can't be opened or if there's a format problem with the cert.
    7886     */
    79     public Credential(String filename) throws Exception {
    80         init(new FileInputStream(filename));
    81     }
     87    public Credential(String filename, Collection<Identity> ids)
     88        throws Exception { init(new FileInputStream(filename), ids); }
    8289
    8390    /**
     
    8592     * cert file can't be opened or if there's a format problem with the cert.
    8693     */
    87     public Credential(File file) throws Exception {
    88         init(new FileInputStream(file));
    89     }
     94    public Credential(File file, Collection<Identity> ids)
     95        throws Exception { init(new FileInputStream(file), ids); }
    9096
    9197    /**
    9298     * Create a credential from an InputStream.
    9399     */
    94     public Credential(InputStream s) throws Exception {
    95         init(s);
    96     }
     100    public Credential(InputStream s, Collection<Identity> ids)
     101        throws Exception { init(s, ids); }
     102
     103    public Credential(X509V2AttributeCertificate c, Collection<Identity> ids)
     104        throws Exception {
     105        m_ac = c;
     106        init(ids);
     107    }
     108
    97109
    98110    /**
     
    213225    }
    214226
    215     public String simpleString() {
    216         return m_head.simpleString() + " <- " + m_tail.simpleString();
     227    public String simpleString(Context c) {
     228        return m_head.simpleString(c) + " <- " + m_tail.simpleString(c);
    217229    }
    218230
     
    230242    public Identity getID() { return m_id; }
    231243
    232     /**
    233      * Import a zip file.  First import all the identities
    234      * (pem), then the credentials (der) into the credential graph then any
    235      * alias files into the two maps.  If keys is not null, any key pairs in
    236      * PEM files are put in there.  If errors is not null, errors reading files
    237      * are added indexed by filename.
    238      */
    239     static public Collection<Credential> readZipFile(File zf,
    240             Collection<KeyPair> keys, Map<String, Exception> errors)
    241                 throws IOException {
    242         Vector<Credential> creds = new Vector<Credential>();
    243         Vector<ZipEntry> derEntries = new Vector<ZipEntry>();
    244         Map<String, Identity> ids = new TreeMap<String, Identity>();
    245         Map<String, KeyPair> kps = new TreeMap<String, KeyPair>();
    246 
    247         ZipFile z = new ZipFile(zf);
    248 
    249         for (Enumeration<? extends ZipEntry> ze = z.entries();
    250                 ze.hasMoreElements();) {
    251             ZipEntry  f = ze.nextElement();
    252             try {
    253                 PEMReader r = new PEMReader(
    254                         new InputStreamReader(z.getInputStream(f)));
    255                 Object o = readPEM(r);
    256 
    257                 if ( o != null ) {
    258                     if (o instanceof Identity) {
    259                         Identity i = (Identity) o;
    260                         String kid = i.getKeyID();
    261 
    262                         if (kps.containsKey(kid) ) {
    263                             i.setKeyPair(kps.get(kid));
    264                             kps.remove(kid);
    265                         }
    266                         else if (i.getKeyPair() == null )
    267                             ids.put(i.getKeyID(), i);
    268 
    269                         Credential.addIdentity(i);
    270                     }
    271                     else if (o instanceof KeyPair ) {
    272                         KeyPair kp = (KeyPair) o;
    273                         String kid = Identity.extractKeyID(kp.getPublic());
    274 
    275                         if (ids.containsKey(kid)) {
    276                             Identity i = ids.get(kid);
    277 
    278                             i.setKeyPair(kp);
    279                             ids.remove(kid);
    280                         }
    281                         else {
    282                             kps.put(kid, kp);
    283                         }
    284                     }
    285                 }
    286                 else {
    287                     // Not a PEM file
    288                     derEntries.add(f);
    289                     continue;
    290                 }
    291             }
    292             catch (Exception e ) {
    293                 if (errors != null ) errors.put(f.getName(), e);
    294             }
    295         }
    296 
    297         for ( ZipEntry f : derEntries ) {
    298             try {
    299                 creds.add(new Credential(z.getInputStream(f)));
    300             }
    301             catch (Exception e ) {
    302                 if (errors != null ) errors.put(f.getName(), e);
    303             }
    304         }
    305         return creds;
    306     }
    307 
    308     static public Collection<Credential> readZipFile(File d)
    309             throws IOException {
    310         return readZipFile(d, null, null);
    311     }
    312     static public Collection<Credential> readZipFile(File d,
    313             Map<String, Exception> errors) throws IOException {
    314         return readZipFile(d, null, errors);
    315     }
    316     static public Collection<Credential> readZipFile(File d,
    317             Collection<KeyPair> keys) throws IOException {
    318         return readZipFile(d, keys, null);
    319     }
    320 
    321     protected static Object readPEM(PEMReader r) throws IOException {
    322         Identity i = null;
    323         KeyPair keys = null;
    324         Object o = null;
    325 
    326         while ( (o = r.readObject()) != null ) {
    327             if (o instanceof X509CertificateObject) {
    328                 if ( i == null ) {
    329                     try {
    330                         i = new Identity((X509CertificateObject)o);
    331                     }
    332                     catch (Exception e) {
    333                         // Translate Idenitiy exceptions to IOException
    334                         throw new IOException(e);
    335                     }
    336                     if (keys != null ) {
    337                         i.setKeyPair(keys);
    338                         keys = null;
    339                     }
    340                 }
    341                 else throw new IOException("Two certificates");
    342             }
    343             else if (o instanceof KeyPair ) {
    344                 if ( i != null ) i.setKeyPair((KeyPair) o);
    345                 else keys = (KeyPair) o;
    346             }
    347             else {
    348                 throw new IOException("Unexpected PEM object: " +
    349                         o.getClass().getName());
    350             }
    351         }
    352 
    353         if ( i != null ) return i;
    354         else if ( keys != null) return keys;
    355         else return null;
    356     }
    357 
    358     /**
    359      * Import a directory full of files.  First import all the identities
    360      * (pem), then the credentials (der) into the credential graph then any
    361      * alias files into the two maps.  If keys is not null, any key pairs in
    362      * PEM files are put in there.  If errors is not null, errors reading files
    363      * are added indexed by filename.
    364      */
    365     static public Collection<Credential> readDirectory(File d,
    366             Collection<KeyPair> keys, Map<String, Exception> errors) {
    367         Vector<Credential> creds = new Vector<Credential>();
    368         Vector<File> derFiles = new Vector<File>();
    369         Collection<File> files = new Vector<File>();
    370         Map<String, Identity> ids = new TreeMap<String, Identity>();
    371         Map<String, KeyPair> kps = new TreeMap<String, KeyPair>();
    372 
    373         if (d.isDirectory() )
    374             for (File f : d.listFiles())
    375                 files.add(f);
    376         else files.add(d);
    377 
    378         for (File f: files ) {
    379             try {
    380                 PEMReader r = new PEMReader(new FileReader(f));
    381                 Object o = readPEM(r);
    382 
    383                 if ( o != null ) {
    384                     if (o instanceof Identity) {
    385                         Identity i = (Identity) o;
    386                         String kid = i.getKeyID();
    387 
    388                         if (kps.containsKey(kid) ) {
    389                             i.setKeyPair(kps.get(kid));
    390                             kps.remove(kid);
    391                         }
    392                         else if (i.getKeyPair() == null )
    393                             ids.put(i.getKeyID(), i);
    394 
    395                         Credential.addIdentity(i);
    396                     }
    397                     else if (o instanceof KeyPair ) {
    398                         KeyPair kp = (KeyPair) o;
    399                         String kid = Identity.extractKeyID(kp.getPublic());
    400 
    401                         if (ids.containsKey(kid)) {
    402                             Identity i = ids.get(kid);
    403 
    404                             i.setKeyPair(kp);
    405                             ids.remove(kid);
    406                         }
    407                         else {
    408                             kps.put(kid, kp);
    409                         }
    410                     }
    411                 }
    412                 else {
    413                     // Not a PEM file
    414                     derFiles.add(f);
    415                     continue;
    416                 }
    417             }
    418             catch (Exception e ) {
    419                 if (errors != null ) errors.put(f.getName(), e);
    420             }
    421         }
    422 
    423         for ( File f : derFiles ) {
    424             try {
    425                 creds.add(new Credential(f));
    426             }
    427             catch (Exception e ) {
    428                 if (errors != null ) errors.put(f.getName(), e);
    429             }
    430         }
    431         return creds;
    432     }
    433 
    434     static public Collection<Credential> readDirectory(File d) {
    435         return readDirectory(d, null, null);
    436     }
    437     static public Collection<Credential> readDirectory(File d,
    438             Map<String, Exception> errors) {
    439         return readDirectory(d, null, errors);
    440     }
    441     static public Collection<Credential> readDirectory(File d,
    442             Collection<KeyPair> keys) {
    443         return readDirectory(d, keys, null);
    444     }
    445 
    446     static public void writeZipFile(Collection<Credential> creds, File f,
    447             boolean allIDs, boolean withPrivateKeys)
    448             throws IOException {
    449         ZipOutputStream z = new ZipOutputStream(new FileOutputStream(f));
    450         Set<Identity> ids = allIDs ?
    451             new TreeSet<Identity>(s_ids) : new TreeSet<Identity>();
    452 
    453         int n = 0;
    454         for (Credential c: creds) {
    455             z.putNextEntry(new ZipEntry("attr" + n++  + ".der"));
    456             c.write(z);
    457             z.closeEntry();
    458             if ( c.getID() != null && !allIDs) ids.add(c.getID());
    459         }
    460         for (Identity i: ids) {
    461             z.putNextEntry(new ZipEntry(i.getName() + ".pem"));
    462             i.write(z);
    463             if (withPrivateKeys)
    464                 i.writePrivateKey(z);
    465             z.closeEntry();
    466         }
    467         z.close();
    468     }
    469 
    470 
    471244private Role m_head, m_tail;
    472245
     
    474247private Identity m_id;
    475248
    476     /**
    477      * Put the Identity into the set of ids used to validate certificates.
    478      * Also put the keyID and name into the translation mappings used by Roles
    479      * to pretty print.  In the role mapping, if multiple ids use the same
    480      * common name they are disambiguated.  Only one entry for keyid is
    481      * allowed.
    482      */
    483     public static void addIdentity(Identity id) {
    484         s_ids.add(id);
    485         if (id.getName() != null && id.getKeyID() != null) {
    486             if ( !Role.key_in_mapping(id.getKeyID()) ) {
    487                 String name = id.getName();
    488                 int n= 1;
    489 
    490                 while (Role.name_in_mapping(name)) {
    491                     name = id.getName() + n++;
    492                 }
    493                 Role.add_mapping(name, id.getKeyID());
    494             }
    495         }
    496     }
    497     public static Collection<Identity> identities() { return s_ids; }
    498     public static void clearIdentities() {
    499         s_ids.clear(); Role.clear_mapping();
    500     }
    501249}
  • java/net/deterlab/abac/Identity.java

    re9360e2 r84f0e7a  
    1515import org.bouncycastle.x509.*;
    1616import org.bouncycastle.jce.provider.X509AttrCertParser;
    17 import org.bouncycastle.jce.provider.X509CertificateObject;
     17// import org.bouncycastle.jce.provider.X509CertificateObject;
    1818import org.bouncycastle.openssl.PEMReader;
    1919import org.bouncycastle.openssl.PEMWriter;
    2020
    2121public class Identity implements Comparable {
    22     private X509CertificateObject m_cert;
     22    private X509Certificate m_cert;
    2323    private String m_keyid;
    2424    private String m_cn;
     
    3737        while ( ( c= pr.readObject()) != null ){
    3838
    39             if (c instanceof X509CertificateObject) {
     39            if (c instanceof X509Certificate) {
    4040                if ( m_cn == null )
    41                     init((X509CertificateObject)c);
     41                    init((X509Certificate)c);
    4242                else
    4343                    throw new CertificateException("Two certs in one file");
     
    5656     *  data.  Looks more complex than it is.
    5757     */
    58     protected void init(X509CertificateObject c) throws
     58    protected void init(X509Certificate c) throws
    5959        CertificateException, NoSuchAlgorithmException,InvalidKeyException,
    6060        NoSuchProviderException, SignatureException, IOException {
    61             m_cert = (X509CertificateObject) c;
     61            m_cert = (X509Certificate) c;
    6262            m_cert.verify(m_cert.getPublicKey());
    6363            // Cert is valid, fill in the CN and keyid
     
    8585        gen.setPublicKey(kp.getPublic());
    8686        gen.setSignatureAlgorithm("SHA256WithRSAEncryption");
    87         X509CertificateObject a =
    88             (X509CertificateObject) gen.generate(kp.getPrivate());
     87        X509Certificate a = (X509Certificate) gen.generate(kp.getPrivate());
    8988        init(a);
    9089    }
     
    124123
    125124    /**
    126      * Construct from an X509CertificateObject, if you parsed one somewhere
     125     * Construct from an X509Certificate, if you parsed one somewhere
    127126     * else.
    128127     */
    129     public Identity(X509CertificateObject cert) throws
     128    public Identity(X509Certificate cert) throws
    130129        CertificateException, NoSuchAlgorithmException,InvalidKeyException,
    131130        NoSuchProviderException, SignatureException, FileNotFoundException,
     
    276275        else return getKeyID().compareTo(((Identity)o).getKeyID());
    277276    }
    278     public X509CertificateObject getCertificate() { return m_cert; }
     277    public X509Certificate getCertificate() { return m_cert; }
    279278
    280279};
  • java/net/deterlab/abac/Query.java

    rac39e39 r84f0e7a  
    3636                    new DirectedSparseGraph<Role,Credential>());
    3737
    38         /* empty attribute, non-empty principal: find everywhere the principal can go */
     38        /* empty attribute, non-empty principal: find everywhere the principal
     39         * can go */
    3940        if (attr.isEmpty() && !prin.isEmpty()) {
    4041            if (g.containsVertex(principal)) {
     
    5253            else {
    5354                if ( g.containsVertex(principal)) {
    54                     CollectQueryPath  collect = new CollectQueryPath(ret, principal);
     55                    CollectQueryPath  collect = new CollectQueryPath(ret,
     56                            principal);
    5557                    reverse_dfs(attribute, collect);
    5658                }
  • java/net/deterlab/abac/Role.java

    r88e139a r84f0e7a  
    5151    }
    5252
    53     public Role(String s, boolean translate) {
    54         this(translate ? replace(s, nicknames) : s);
     53    public Role(String s, Context c) {
     54        this(c.expandKeyID(s));
    5555    }
    5656
     
    157157    }
    158158
    159     public String simpleString() {
    160         return replace(m_string, keys);
     159    public String simpleString(Context c) {
     160        return c.expandNickname(m_string);
    161161    }
    162162
     
    177177    }
    178178
    179 
    180     /**
    181      * Translate either keys to nicknames or vice versa.  Break the string into
    182      * space separated tokens and then each of them into period separated
    183      * strings.  If any of the smallest strings is in the map, replace it with
    184      * the value.
    185      */
    186     protected static String replace(String is, Map<String, String> m) {
    187         String rv = "";
    188         for (String tok: is.split(" ")) {
    189             String term = "";
    190             for (String s: tok.split("\\.")) {
    191                 String next = m.containsKey(s) ? m.get(s) : s;
    192 
    193                 if (term.isEmpty()) term = next;
    194                 else term += "." + next;
    195             }
    196             if (rv.isEmpty()) rv = term;
    197             else rv += " " + term;
    198         }
    199         return rv;
    200     }
    201     public static void add_mapping(String name, String key) {
    202         nicknames.put(name, key);
    203         keys.put(key,name);
    204     }
    205 
    206     public static boolean key_in_mapping(String key) {
    207         return keys.containsKey(key);
    208     }
    209 
    210     public static boolean name_in_mapping(String name) {
    211         return nicknames.containsKey(name);
    212     }
    213 
    214     public static void clear_mapping() { nicknames.clear(); keys.clear(); }
    215 
    216179}
Note: See TracChangeset for help on using the changeset viewer.