Changeset 0595372


Ignore:
Timestamp:
Mar 24, 2011 9:22:57 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:
53f5c27
Parents:
418b586
Message:

Some cleanup

Location:
java
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • java/GraphTest.java

    r84f0e7a r0595372  
    66import net.deterlab.abac.Credential;
    77import net.deterlab.abac.Context;
    8 import net.deterlab.abac.Query;
    98import net.deterlab.abac.Role;
    109import net.deterlab.abac.Identity;
  • java/net/deterlab/abac/Context.java

    r418b586 r0595372  
    1515import java.security.cert.*;
    1616
     17import org.bouncycastle.asn1.*;
     18import org.bouncycastle.asn1.x509.*;
    1719import org.bouncycastle.x509.*;
    1820import org.bouncycastle.x509.util.*;
     
    415417                    else if (o instanceof KeyPair ) {
    416418                        KeyPair kp = (KeyPair) o;
    417                         String kid = Identity.extractKeyID(kp.getPublic());
     419                        String kid = extractKeyID(kp.getPublic());
    418420
    419421                        if (ids.containsKey(kid)) {
     
    539541                    else if (o instanceof KeyPair ) {
    540542                        KeyPair kp = (KeyPair) o;
    541                         String kid = Identity.extractKeyID(kp.getPublic());
     543                        String kid = extractKeyID(kp.getPublic());
    542544
    543545                        if (ids.containsKey(kid)) {
     
    605607    }
    606608
     609    /**
     610     * Get to the SHA1 hash of the key.
     611     */
     612    public static String extractKeyID(PublicKey k) {
     613        SubjectPublicKeyInfo ki = extractSubjectPublicKeyInfo(k);
     614        SubjectKeyIdentifier id =
     615            SubjectKeyIdentifier.createSHA1KeyIdentifier(ki);
     616
     617        // Now format it into a string for keeps
     618        Formatter fmt = new Formatter(new StringWriter());
     619        for (byte b: id.getKeyIdentifier())
     620            fmt.format("%02x", b);
     621        return fmt.out().toString();
     622    }
     623
     624    /**
     625     * Extratct the SubjectPublicKeyInfo.  Useful for some other encryptions,
     626     * notably Certificate.make_cert().
     627     */
     628    public static SubjectPublicKeyInfo extractSubjectPublicKeyInfo(
     629            PublicKey k) {
     630        ASN1Sequence seq = null;
     631        try {
     632            seq = (ASN1Sequence) new ASN1InputStream(
     633                    k.getEncoded()).readObject();
     634        }
     635        catch (IOException ie) {
     636            // Badly formatted key??
     637            return null;
     638        }
     639        return new SubjectPublicKeyInfo(seq);
     640    }
     641
     642
    607643}
  • java/net/deterlab/abac/Credential.java

    r84f0e7a r0595372  
    2626    protected static String authKeyOID = "2.5.29.35";
    2727
     28    private Role m_head;
     29    private Role m_tail;
     30    private X509V2AttributeCertificate ac;
     31    private Identity id;
     32
    2833    /**
    2934     * A dummy credential.
     
    3136    public Credential() {
    3237        m_head = m_tail = null;
    33         m_ac = null;
    34         m_id = null;
     38        ac = null;
     39        id = null;
    3540    }
    3641    /**
     
    4247        m_head = head;
    4348        m_tail = tail;
    44         m_ac = null;
    45         m_id = null;
     49        ac = null;
     50        id = null;
    4651    }
    4752
     
    5358        X509AttrCertParser parser = new X509AttrCertParser();
    5459        parser.engineInit(stream);
    55         m_ac = (X509V2AttributeCertificate)parser.engineRead();
     60        ac = (X509V2AttributeCertificate)parser.engineRead();
    5661    }
    5762
     
    6065            throws Exception {
    6166        read_certificate(stream);
    62         if (m_ac == null) throw new IOException("Unknown Format");
     67        if (ac == null) throw new IOException("Unknown Format");
    6368        init(ids);
    6469    }
    6570
    6671    protected void init(Collection<Identity> ids)
    67             throws CertificateException, InvalidKeyException, NoSuchAlgorithmException, NoSuchProviderException,SignatureException {
    68         for (Identity id: ids) {
     72            throws CertificateException, InvalidKeyException,
     73                NoSuchAlgorithmException, NoSuchProviderException,
     74                SignatureException {
     75        for (Identity i: ids) {
    6976            try {
    70                 m_ac.verify(id.getCertificate().getPublicKey(), "BC");
    71                 m_id = id;
     77                ac.verify(i.getCertificate().getPublicKey(), "BC");
     78                id = i;
    7279                break;
    7380            }
    7481            catch (InvalidKeyException e) { }
    7582        }
    76         if (m_id == null) throw new InvalidKeyException("Unknown identity");
     83        if (id == null) throw new InvalidKeyException("Unknown identity");
    7784
    7885        load_roles();
    7986
    80         if (!m_id.getKeyID().equals(m_head.issuer_part()))
     87        if (!id.getKeyID().equals(m_head.issuer_part()))
    8188            throw new InvalidKeyException("Unknown identity");
    8289    }
     
    103110    public Credential(X509V2AttributeCertificate c, Collection<Identity> ids)
    104111        throws Exception {
    105         m_ac = c;
     112        ac = c;
    106113        init(ids);
    107114    }
     
    114121    public void make_cert(Identity i) {
    115122        PrivateKey key = i.getKeyPair().getPrivate();
    116         SubjectPublicKeyInfo pki = Identity.extractSubjectPublicKeyInfo(
     123        SubjectPublicKeyInfo pki = Context.extractSubjectPublicKeyInfo(
    117124                i.getKeyPair().getPublic());
    118125        X509V2AttributeCertificateGenerator gen =
     
    138145                    new AuthorityKeyIdentifier(pki));
    139146            // Create the cert.
    140             m_ac = (X509V2AttributeCertificate) gen.generate(key, "BC");
     147            ac = (X509V2AttributeCertificate) gen.generate(key, "BC");
    141148        }
    142149        catch (Exception e) {
     
    152159        String roles = null;
    153160        try {
    154             X509Attribute attr = m_ac.getAttributes()[0];
     161            X509Attribute attr = ac.getAttributes()[0];
    155162
    156163            DERSequence    java     = (DERSequence)attr.getValues()[0];
     
    161168        }
    162169        catch (Exception e) {
    163             throw new RuntimeException("Your attribute certificate is funky and I'm not gonna debug it", e);
     170            throw new RuntimeException("Badly formatted certificate");
    164171        }
    165172
     
    199206     * Get the head role from the credential.
    200207     */
    201     public Role head() {
    202         return m_head;
    203     }
     208    public Role head() { return m_head; }
    204209
    205210    /**
    206211     * Get the tail role from the credential
    207212     */
    208     public Role tail() {
    209         return m_tail;
    210     }
     213    public Role tail() { return m_tail; }
    211214
    212215    /**
    213216     * Gets the cert associated with this credential (if any).
    214217     */
    215     public X509V2AttributeCertificate cert() {
    216         return m_ac;
    217     }
     218    public X509V2AttributeCertificate cert() { return ac; }
    218219
    219220    /**
     
    230231
    231232    public void write(OutputStream s) throws IOException {
    232         s.write(m_ac.getEncoded());
     233        s.write(ac.getEncoded());
    233234        s.flush();
    234235    }
     
    238239    }
    239240
    240     public boolean hasCertificate() { return m_ac != null; }
    241 
    242     public Identity getID() { return m_id; }
    243 
    244 private Role m_head, m_tail;
    245 
    246 private X509V2AttributeCertificate m_ac;
    247 private Identity m_id;
     241    public boolean hasCertificate() { return ac != null; }
     242
     243    public Identity getID() { return id; }
     244
    248245
    249246}
  • java/net/deterlab/abac/Identity.java

    r84f0e7a r0595372  
    2020
    2121public class Identity implements Comparable {
    22     private X509Certificate m_cert;
    23     private String m_keyid;
    24     private String m_cn;
     22    private X509Certificate cert;
     23    private String keyid;
     24    private String cn;
    2525    private KeyPair kp;
    2626
     
    3838
    3939            if (c instanceof X509Certificate) {
    40                 if ( m_cn == null )
     40                if ( cn == null )
    4141                    init((X509Certificate)c);
    4242                else
     
    5959        CertificateException, NoSuchAlgorithmException,InvalidKeyException,
    6060        NoSuchProviderException, SignatureException, IOException {
    61             m_cert = (X509Certificate) c;
    62             m_cert.verify(m_cert.getPublicKey());
     61            cert = (X509Certificate) c;
     62            cert.verify(cert.getPublicKey());
    6363            // Cert is valid, fill in the CN and keyid
    64             m_keyid = extractKeyID(m_cert.getPublicKey());
    65             m_cn = m_cert.getSubjectDN().getName();
     64            keyid = Context.extractKeyID(cert.getPublicKey());
     65            cn = cert.getSubjectDN().getName();
    6666            /// XXX: better parse
    67             if (m_cn.startsWith("CN=")) m_cn = m_cn.substring(3);
     67            if (cn.startsWith("CN=")) cn = cn.substring(3);
    6868    }
    6969
     
    179179        PEMWriter pw = new PEMWriter(w);
    180180
    181         pw.writeObject(m_cert);
     181        pw.writeObject(cert);
    182182        pw.flush();
    183183    }
     
    206206
    207207
    208     /**
    209      * Get to the SHA1 hash of the key.
    210      */
    211     public static String extractKeyID(PublicKey k) {
    212         SubjectPublicKeyInfo ki = extractSubjectPublicKeyInfo(k);
    213         SubjectKeyIdentifier id =
    214             SubjectKeyIdentifier.createSHA1KeyIdentifier(ki);
    215 
    216         // Now format it into a string for keeps
    217         Formatter fmt = new Formatter(new StringWriter());
    218         for (byte b: id.getKeyIdentifier())
    219             fmt.format("%02x", b);
    220         return fmt.out().toString();
    221     }
    222 
    223     /**
    224      * Extratct the SubjectPublicKeyInfo.  Useful for some other encryptions,
    225      * notably Certificate.make_cert().
    226      */
    227     public static SubjectPublicKeyInfo extractSubjectPublicKeyInfo(PublicKey k) {
    228         ASN1Sequence seq = null;
    229         try {
    230             seq = (ASN1Sequence) new ASN1InputStream(
    231                     k.getEncoded()).readObject();
    232         }
    233         catch (IOException ie) {
    234             // Badly formatted key??
    235             return null;
    236         }
    237         return new SubjectPublicKeyInfo(seq);
    238     }
    239 
    240 
    241208    // Accessors
    242     public String getKeyID() { return m_keyid; }
    243     public String getName() { return m_cn; }
     209    public String getKeyID() { return keyid; }
     210    public String getName() { return cn; }
    244211    public String toString() {
    245         String s = m_keyid + " (" + m_cn ;
    246 
    247         if (m_keyid != null ) s += " [keyed]";
     212        String s = keyid + " (" + cn ;
     213
     214        if (keyid != null ) s += " [keyed]";
    248215        s += ")";
    249216        return s;
     
    255222     */
    256223    public void setKeyPair(KeyPair k) {
    257         if (m_keyid != null) {
    258             String kid = extractKeyID(k.getPublic());
    259 
    260             if ( kid != null && kid.equals(m_keyid)) kp = k;
     224        if (keyid != null) {
     225            String kid = Context.extractKeyID(k.getPublic());
     226
     227            if ( kid != null && kid.equals(keyid)) kp = k;
    261228            else
    262229                throw new IllegalArgumentException(
     
    275242        else return getKeyID().compareTo(((Identity)o).getKeyID());
    276243    }
    277     public X509Certificate getCertificate() { return m_cert; }
     244    public X509Certificate getCertificate() { return cert; }
    278245
    279246};
  • java/net/deterlab/abac/Query.java

    r84f0e7a r0595372  
    1212 * well as reachability in either direction. See the run method for details.
    1313 */
    14 public class Query {
     14class Query {
    1515    private Graph<Role,Credential> g;
    1616    private int vertex_count;
  • java/net/deterlab/abac/Role.java

    r84f0e7a r0595372  
    1414    private String m_prefix;
    1515    private Role[] m_prereqs;
    16 
    17     protected static TreeMap<String, String> nicknames =
    18         new TreeMap<String, String>();
    19     protected static TreeMap<String, String> keys =
    20         new TreeMap<String, String>();
    2116
    2217    /**
Note: See TracChangeset for help on using the changeset viewer.