source: fedd/abac-src/ttg/process/FrontierManager.java @ b770aa0

package com.nailabs.abac.process;

import com.nailabs.abac.test.Debug;
import com.nailabs.abac.credential.RtmlFrontier;
import edu.stanford.peer.rbtm.credential.*;
import edu.stanford.peer.rbtm.engine.*;
import edu.stanford.peer.rbtm.test.*;
import edu.stanford.peer.rbtm.util.*;

import java.util.*;

/** 
 * A manager class for frontier functions. Each set of functions should
 * be unique to a principal. The manager is a singleton object with a method
 * for obtaining a set of specific frontiers.
 */
public class FrontierManager  extends com.nailabs.abac.test.TestEngine 
    implements java.io.Serializable {

    /** Singleton reference table for sharing frontiers. */
    static Hashtable frontiers = new Hashtable(5);
    
    /** The principal identifier, which is an Entity name */
    protected Entity self;

    /**
     * The configuration hashmap. Section name is key and stringified 
     * line vectors are the values
     */
    protected HashMap conf;

    /** The set of issuer traceable credentials */
    protected HashSet cSuperI = new HashSet();

    /** The set of subject traceable credentials */
    protected HashSet cSuperS = new HashSet();

    /** The set of subject traceable <emp>roles</emp> */
    protected HashSet subjectTraces = new HashSet();

    protected HashSet issuerTracesDef = new HashSet();

    protected HashSet issuerTracesAll = new HashSet();

    /** a search engine which uses the <code>oppo()</code> predicate */
    protected GraphEngine oppoLocal;

    /** a search engine which uses the <code>oppo()</code> predicate */
    protected GraphEngine oppoFrontier;
    
    /** a search engine which uses the <code>sens()</code> predicate */
    protected GraphEngine sensFrontier;
    
    /** a search engine which uses the <code>simp()</code> predicate */
    protected GraphEngine simpFrontier;
    
    /** the acknowledgement policy for this principal entity */
    protected AckPolicy ackPolicy;

    /** the access control policy for this principal entity */
    protected ACPolicy acPolicy;

    /** constructor for subclasses */
    protected FrontierManager() { }
    
    /** default constructor, only used internally */
    protected FrontierManager(HashMap config) {
        init(config);
    }
    
    /**
     * initialization is no longer in constructor, so subclasses can
     * manipulate the configuration hash map.
     */
    protected void init(HashMap config) {
        //int track = TRACK_ALL;

        // (0) get the configurations entity identifier
        this.self =(Entity) config.get("EntityID");

        // (1) load acknowledgement(ACK) policy
        ackPolicy = (AckPolicy)config.get("AckPolicy");

        // (2) load access control (AC) policy 
        acPolicy = (ACPolicy)config.get("AccessControl");

        // (3) load issuer traceable roles
        issuerTracesAll = (HashSet)config.get("IssuerTracesAll");
        issuerTracesDef = (HashSet)config.get("IssuerTracesDef");

        // (4) load subject traceale roles
        subjectTraces = (HashSet)config.get("SubjectTraceable");

        // (5) construct sensitive roles predicate from the ack policy
        Sens sens = new Sens(ackPolicy.getSensitiveRoles());

        // (6) construct opponent predicate from the issuer traceable roles
        Oppo oppo = new Oppo(new Vector(issuerTracesDef));
        oppo.addSubjects(new Vector(issuerTracesAll));

        // (7) construct the frontier functions with their predicates
        oppoLocal = new GraphEngine();
        //System.out.println("------> Sensitive Graph");
        sensFrontier = new GraphEngine(sens);
        //System.out.println("------> Opponent Graph");
        oppoFrontier = new GraphEngine(oppo);
        //System.out.println("------> Simple Graph");
        simpFrontier = new GraphEngine(new Simp());

        // TBD: Does this really need to be separated into two mutually exclusive
        //      credential sets?
        // (8) add policy reachable credentials
        System.out.println("------> Policy Reachable");
        HashSet policyReachable = (HashSet)config.get("PolicyReachable");
        Iterator ci = policyReachable.iterator();
        while(ci.hasNext()) {
            addPolicyReachable((StaticCredential)ci.next());
        }
         
        // (9) add self reachable credentials
        System.out.println("------> Self Traceable");
        HashSet selfReachable = (HashSet)config.get("SelfReachable");
        Iterator cs = selfReachable.iterator();
        while(cs.hasNext()) {
            addSelfReachable((StaticCredential)cs.next());
        }

    }
    public static void addFrontier(HashMap config) {
        Entity key = (Entity)config.get("EntityID");
        boolean hasRTML = config.containsKey("RTML");
        System.out.println("Begin Configuration for " + key);
         if(frontiers.contains(key.toString()))
             System.out.println("WARNING overwriting frontier manager for " +
                               key);    
         FrontierManager frontier = hasRTML? new RtmlFrontier(config): 
            new FrontierManager(config);
         frontiers.put(key.toString(), frontier);
         System.out.println("End Configuration for " + key);
    } 

    /** public instance accessor method for a specific frontier set */
    public static FrontierManager getFrontier(Entity self) {
        System.out.println("self = " + self);
        FrontierManager instance = 
            (FrontierManager)frontiers.get(self.toString());
        return instance;
    }

    /** public accessor for a list of instance keys */
    public static Set getFrontiers() { return frontiers.keySet(); }

    /** the unique identifier for this set of frontier functions */
    public Entity getSelf() { return self; }

    /** Extract the role name from a role expression (e.g. r from <A.r<--S>) */
    protected RoleName getRoleName(StaticCredential cred) {
        return getRoleName(cred.getDefinedRole());
    }

    /** Extract the role name from a role expression (e.g. r from A.r) */
    protected RoleName getRoleName(EntityExpression expr) {
        if(expr != null && (expr instanceof Role)) {
            return ((Role)expr).getName();
        }
        return null;
    }

    /** adds an issuer traceable credential to the frontier set */
    public void addSelfReachable(StaticCredential cred) {
        if(isSubjectTraceable(getRoleName(cred))) {
            sensFrontier.addCredential(cred);
            simpFrontier.addCredential(cred);
            cSuperS.add(cred);
        }
    }
    
    /** extracts issuer traceable roles from the credntial */
    public void addPolicyReachable(StaticCredential cred) {
        if(isIssuerTraceable(getRoleName(cred))) {
            oppoFrontier.addCredential(cred);
            oppoLocal.addCredential(cred);
            cSuperI.add(cred);
        }
    }


    /** adds an issuer-traces-all role to this frontier set */
    public void addIssuerTracesAll(RoleName role) {
        issuerTracesAll.add(role);
    }

    /** adds an issuer-traces-def role to this frontier set */
    public void addIssuerTracesDef(RoleName role) {
        issuerTracesDef.add(role);
    }

    /** adds an subject traceable credential to the frontier set */
    public void addSubjectTraceable(RoleName role) {
        subjectTraces.add(role);
    }

    public ResultEvidenceMap getOppoLocal(EntityExpression expr) {
        //a specialized backward search for the LinkTTNode
        Debug.rbtmStart();
        System.out.println("-------BEGIN-LOCAL-SEARCH------------");
        ResultEvidenceMap map =  oppoLocal.backwardSearch(expr);
        System.out.println("-------END-LOCAL-SEARCH--------------");
        Debug.rbtmStop();
        return map;
    }

    /** gets the frontier of policy traceable roles */
    public ResultEvidenceMap getOppoFrontier(EntityExpression expr) {
        // retrieve solutions AND evidence here
        Debug.rbtmStart();
        System.out.println("-------BEGIN-OPPO-SEARCH------------");
        ResultEvidenceMap map =  oppoFrontier.backwardSearch(expr);
        System.out.println("-------END-OPPO-SEARCH--------------");
        Debug.rbtmStop();
        return map;
    }
    
    /** gets the frontier of sensitive roles */
    public ResultEvidenceMap getSensFrontier(EntityExpression expr) {
        Debug.rbtmStart();
        System.out.println("-------BEGIN-SENS-SEARCH------------");
        System.out.println("searching for " + expr);
        ResultEvidenceMap map = sensFrontier.backwardSearch(expr);
        System.out.println("map = " + map);
        System.out.println("--------END-SENS-SEARCH-------------");
        System.out.flush();
        Debug.rbtmStop();
        return map;
    }
    
    /** get the frontier of non-role entity expressions */
    public ResultEvidenceMap getSimpFrontier(EntityExpression expr) {
        Debug.rbtmStart();
        System.out.println("-------BEGIN-SIMP-SEARCH------------");
        ResultEvidenceMap map = simpFrontier.backwardSearch(expr);
        System.out.println("--------END-SIMP-SEARCH------------");
        Debug.rbtmStop();
        return map;
    }

    public HashSet getOppoChain(EntityExpression root, EntityExpression leaf) {
        HashSet results = new HashSet();
        try {
            getOppoFrontier(root);
            Debug.rbtmStart();
            System.out.println("Getting oppo chain from " + root + " to " + 
                               leaf);
            results = oppoFrontier.getChain(root, leaf);
            Debug.rbtmStop();
        } catch(Exception ex) {
            ex.printStackTrace();
        }
        Debug.rbtmStop();
        return results;
    }

    public HashSet getSensChain(EntityExpression root, EntityExpression leaf) {
        //if(!getSensFrontier(root).containsResult(leaf)) {
        //return null; 
        //}
        try {
            getSensFrontier(root);
            Debug.rbtmStart();
            System.out.println("---------BEGIN-SENS-CHAIN----------");
            System.out.println("Getting sens chain from " + root + " to " + 
                               leaf);
            HashSet results = sensFrontier.getChain(root, leaf);
            System.out.println("results = " + results);
            System.out.println("-----------END-SENS-CHAIN----------\n");
            Debug.rbtmStop();
            return results;
        } catch(Exception ex) {
            ex.printStackTrace();
        } 
        System.out.println("-----------END-SENS-CHAIN----------\n");
        Debug.rbtmStop();
        return new HashSet();
    }

    public HashSet getSimpChain(EntityExpression root, EntityExpression leaf) {
        System.out.println("Getting simp chain from " + root + " to " + leaf);
        getSimpFrontier(root);
        Debug.rbtmStart();
        HashSet results = simpFrontier.getChain(root, leaf);
        Debug.rbtmStop();
        return results;
    }

    public Iterator getCredentialsDefiningRole(RoleName name) {
        Iterator i;
        int count = 0;
        HashSet results = new HashSet();
    
        Debug.rbtmStart();
        System.out.println("Finding credential defining the role name: "+name);
        i = oppoFrontier.findCredentialsDefiningRole(name);
        while(i.hasNext()) {
            results.add(i.next());
            System.out.println("count = " + ++count);
        }
        i = sensFrontier.findCredentialsDefiningRole(name);
        while(i.hasNext()) {
            results.add(i.next());
            System.out.println("count = " + ++count);
        }
        Debug.rbtmStop();
        Debug.debug("process", "\nDefining creds = " + results);
        return results.iterator();
    }

    /** accessor for finding credentials which define a specified role */
    public Iterator getCredentialsDefiningRole(Role role) {
        Iterator i;
        int count = 0;
        HashSet results = new HashSet();
    
        Debug.rbtmStart();
        System.out.println("Finding credential defining the role: <" + 
                           role.getBase() + "." +  role.getName() + ">" );
        
        i = oppoFrontier.findCredentialsDefiningRole(role);
        while(i.hasNext()) {
            results.add(i.next());
            System.out.println("count = " + ++count);
        }
        System.out.println("oppoFrontier = " + oppoFrontier);
        i = sensFrontier.findCredentialsDefiningRole(role);
        while(i.hasNext()) {
            results.add(i.next());
            System.out.println("count = " + ++count);
        }
        Debug.debug("process", "\nDefining creds = " + results);

        Debug.rbtmStop();
        return results.iterator();
    }

    /** Is the specified credential policy traceable? */
    public boolean isPolicyTraceable(StaticCredential cred) {
        return cSuperI.contains(cred);
    }

    /** Can the specified credential be traced back to this negotiator? */
    public boolean isSelfReachable(StaticCredential cred) {
        return cSuperS.contains(cred);
    }

    public boolean isSubjectTraceable(RoleName role) {
        return subjectTraces.contains(role);
    }

    public boolean isIssuerTracesDef(RoleName name) {
        return (issuerTracesDef.contains(name));
    }

    public boolean isIssuerTracesAll(RoleName name) {
        return (issuerTracesAll.contains(name));
    }

    public boolean isIssuerTraceable(RoleName role) {
    return (issuerTracesAll.contains(role) || issuerTracesDef.contains(role));
    }

    public boolean isSensitive(EntityExpression expr) {
        return sensFrontier.getPredicate().test(expr);
    }
    
    public boolean subjectTracesAll(RoleName name) {
        return subjectTraces.contains(name);
    }

    public AckPolicy getAckPolicy() { return ackPolicy; }

    public EntityExpression getAck(EntityExpression expr) {
        return ackPolicy.requires(expr);
    }
    
    public ACPolicy getACPolicy() { return acPolicy; }

    public EntityExpression getAC(Credential cred) {
        if(acPolicy == null)return null;
        return acPolicy.requires(cred);
    }

    protected void addSensitiveRole(Role name) {
        Sens sens = (Sens)sensFrontier.getPredicate();
        sens.addSensCred(name);
    }

    public String toString() {
        StringBuffer buff = new StringBuffer("[FrontierManager self = ");
        buff.append(self);
        buff.append("\n sens = ").append(sensFrontier);
        buff.append("\n\n oppo = ").append(oppoFrontier);
        buff.append("\n\n simp = ").append(simpFrontier);
        return buff.append("]").toString();
    }

}