Abstraction (soot-infoflow 2.10.4 API)

java.lang.Object
- soot.jimple.infoflow.data.Abstraction

所有已实现的接口:

Cloneable, FastSolverLinkedNode<Abstraction,soot.Unit>
```
public class Abstraction
extends Object
implements Cloneable, FastSolverLinkedNode<Abstraction,soot.Unit>
```
The abstraction class contains all information that is necessary to track the taint.

作者:

Steven Arzt, Christian Fritz

嵌套类概要

嵌套类
限定符和类型类和说明

static class Abstraction.NeighborHashingStrategy

嵌套类
限定符和类型	类和说明
`static class`	`Abstraction.NeighborHashingStrategy`

字段概要

字段
限定符和类型	字段和说明
`protected AccessPath`	`accessPath` the access path contains the currently tainted variable or field
`protected soot.Unit`	`activationUnit` Unit/Stmt which activates the taint when the abstraction passes it
`protected soot.jimple.Stmt`	`correspondingCallSite`
`protected soot.jimple.Stmt`	`currentStmt`
`protected boolean`	`dependsOnCutAP` Only valid for inactive abstractions.
`protected boolean`	`exceptionThrown` taint is thrown by an exception (is set to false when it reaches the catch-Stmt)
`protected static boolean`	`flowSensitiveAliasing`
`protected int`	`hashCode`
`protected boolean`	`isImplicit`
`protected int`	`neighborHashCode`
`protected Set<Abstraction>`	`neighbors`
`protected AtomicBitSet`	`pathFlags`
`protected List<IInfoflowCFG.UnitContainer>`	`postdominators` The postdominators we need to pass in order to leave the current conditional branch.
`protected Abstraction`	`predecessor`
`protected int`	`propagationPathLength`
`protected SourceContext`	`sourceContext`

构造器概要

构造器
限定符	构造器和说明
`protected`	`Abstraction(AccessPath p, Abstraction original)` Creates an abstraction as a copy of an existing abstraction, only exchanging the access path. -> only used by AbstractionWithPath
	`Abstraction(ISourceSinkDefinition definition, AccessPath sourceVal, soot.jimple.Stmt sourceStmt, Object userData, boolean exceptionThrown, boolean isImplicit)`

方法概要

所有方法静态方法实例方法具体方法
限定符和类型	方法和说明
`boolean`	`addNeighbor(Abstraction originalAbstraction)` Links this node to a neighbor node, i.e., to an abstraction that would have been merged with this one of paths were not being tracked.
`Abstraction`	`clone()` Clones this data flow abstraction
`boolean`	`dependsOnCutAP()`
`Abstraction`	`deriveConditionalAbstractionCall(soot.Unit conditionalCallSite)`
`Abstraction`	`deriveConditionalAbstractionEnter(IInfoflowCFG.UnitContainer postdom, soot.jimple.Stmt conditionalUnit)`
`Abstraction`	`deriveInactiveAbstraction(soot.jimple.Stmt activationUnit)`
`Abstraction`	`deriveNewAbstraction(AccessPath p, soot.jimple.Stmt currentStmt)`
`Abstraction`	`deriveNewAbstraction(AccessPath p, soot.jimple.Stmt currentStmt, boolean isImplicit)`
`protected Abstraction`	`deriveNewAbstractionMutable(AccessPath p, soot.jimple.Stmt currentStmt)`
`Abstraction`	`deriveNewAbstractionOnCatch(AccessPath ap)` Derives a new abstraction that models the current local being caught as an exception
`Abstraction`	`deriveNewAbstractionOnThrow(soot.jimple.Stmt throwStmt)` Derives a new abstraction that models the current local being thrown as an exception
`Abstraction`	`dropTopPostdominator()`
`boolean`	`entails(Abstraction other)` Checks whether this abstraction entails the given abstraction, i.e. this taint also taints everything that is tainted by the given taint.
`boolean`	`equals(Object obj)`
`AccessPath`	`getAccessPath()`
`soot.Unit`	`getActivationUnit()`
`Abstraction`	`getActiveCopy()` If this abstraction supports alias analysis, this returns the active copy of the current abstraction.
`soot.jimple.Stmt`	`getCorrespondingCallSite()`
`soot.jimple.Stmt`	`getCurrentStmt()`
`boolean`	`getExceptionThrown()` Gets whether this value has been thrown as an exception
`int`	`getNeighborCount()` Gets the number of neighbors already registered with this abstraction
`Set<Abstraction>`	`getNeighbors()`
`int`	`getPathLength()` Gets the length of the path over which this node was propagated
`Abstraction`	`getPredecessor()` Gets the predecessor of this node
`SourceContext`	`getSourceContext()` Gets the context of the taint, i.e. the statement and value of the source
`IInfoflowCFG.UnitContainer`	`getTopPostdominator()`
`static Abstraction`	`getZeroAbstraction(boolean flowSensitiveAliasing)`
`int`	`hashCode()`
`static void`	`initialize(InfoflowConfiguration config)` Initializes the configuration for building new abstractions
`Abstraction`	`injectSourceContext(SourceContext sourceContext)`
`boolean`	`isAbstractionActive()`
`boolean`	`isImplicit()`
`boolean`	`isTopPostdominator(soot.SootMethod sm)`
`boolean`	`isTopPostdominator(soot.Unit u)`
`boolean`	`registerPathFlag(int id, int maxSize)` Registers that a worker thread with the given ID has already processed this abstraction
`void`	`setCorrespondingCallSite(soot.jimple.Stmt callSite)`
`void`	`setPredecessor(Abstraction predecessor)` Explicitly sets the predecessor of this node.
`void`	`setSourceContext(SourceContext sourceContext)` Only use this method if you really need to fake a source context and know what you are doing.
`String`	`toString()`

从类继承的方法 java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

- 字段详细资料
  - flowSensitiveAliasing
```
protected static boolean flowSensitiveAliasing
```
  - accessPath
```
protected AccessPath accessPath
```
    the access path contains the currently tainted variable or field
  - predecessor
```
protected Abstraction predecessor
```
  - neighbors
```
protected volatile Set<Abstraction> neighbors
```
  - currentStmt
```
protected soot.jimple.Stmt currentStmt
```
  - correspondingCallSite
```
protected soot.jimple.Stmt correspondingCallSite
```
  - sourceContext
```
protected SourceContext sourceContext
```
  - activationUnit
```
protected soot.Unit activationUnit
```
    Unit/Stmt which activates the taint when the abstraction passes it
  - exceptionThrown
```
protected boolean exceptionThrown
```
    taint is thrown by an exception (is set to false when it reaches the catch-Stmt)
  - hashCode
```
protected int hashCode
```
  - neighborHashCode
```
protected int neighborHashCode
```
  - postdominators
```
protected List<IInfoflowCFG.UnitContainer> postdominators
```
    The postdominators we need to pass in order to leave the current conditional branch. Do not use the synchronized Stack class here to avoid deadlocks.
  - isImplicit
```
protected boolean isImplicit
```
  - dependsOnCutAP
```
protected boolean dependsOnCutAP
```
    Only valid for inactive abstractions. Specifies whether an access paths has been cut during alias analysis.
  - pathFlags
```
protected AtomicBitSet pathFlags
```
  - propagationPathLength
```
protected int propagationPathLength
```
- 构造器详细资料
  - Abstraction
```
public Abstraction(ISourceSinkDefinition definition,
                   AccessPath sourceVal,
                   soot.jimple.Stmt sourceStmt,
                   Object userData,
                   boolean exceptionThrown,
                   boolean isImplicit)
```
  - Abstraction
```
protected Abstraction(AccessPath p,
                      Abstraction original)
```
    Creates an abstraction as a copy of an existing abstraction, only exchanging the access path. -> only used by AbstractionWithPath
    
    参数:
    
    p - The access path for the new abstraction
    
    original - The original abstraction to copy
- 方法详细资料
  - initialize
```
public static void initialize(InfoflowConfiguration config)
```
    Initializes the configuration for building new abstractions
    
    参数:
    
    config - The configuration of the data flow solver
  - deriveInactiveAbstraction
```
public Abstraction deriveInactiveAbstraction(soot.jimple.Stmt activationUnit)
```
  - deriveNewAbstraction
```
public Abstraction deriveNewAbstraction(AccessPath p,
                                        soot.jimple.Stmt currentStmt)
```
  - deriveNewAbstraction
```
public Abstraction deriveNewAbstraction(AccessPath p,
                                        soot.jimple.Stmt currentStmt,
                                        boolean isImplicit)
```
  - deriveNewAbstractionMutable
```
protected Abstraction deriveNewAbstractionMutable(AccessPath p,
                                                  soot.jimple.Stmt currentStmt)
```
  - deriveNewAbstractionOnThrow
```
public Abstraction deriveNewAbstractionOnThrow(soot.jimple.Stmt throwStmt)
```
    Derives a new abstraction that models the current local being thrown as an exception
    
    参数:
    
    throwStmt - The statement at which the exception was thrown
    
    返回:
    
    The newly derived abstraction
  - deriveNewAbstractionOnCatch
```
public Abstraction deriveNewAbstractionOnCatch(AccessPath ap)
```
    Derives a new abstraction that models the current local being caught as an exception
    
    参数:
    
    ap - The access path in which the tainted exception is stored
    
    返回:
    
    The newly derived abstraction
  - isAbstractionActive
```
public boolean isAbstractionActive()
```
  - isImplicit
```
public boolean isImplicit()
```
  - toString
```
public String toString()
```
    覆盖:
    
    toString 在类中 Object
  - getAccessPath
```
public AccessPath getAccessPath()
```
  - getActivationUnit
```
public soot.Unit getActivationUnit()
```
  - getActiveCopy
```
public Abstraction getActiveCopy()
```
    从接口复制的说明: FastSolverLinkedNode
    
    If this abstraction supports alias analysis, this returns the active copy of the current abstraction. Otherwise, "this" is returned.
    
    指定者:
    
    getActiveCopy 在接口中 FastSolverLinkedNode<Abstraction,soot.Unit>
    
    返回:
    
    The active copy if supported, otherwise the "this" reference
  - getExceptionThrown
```
public boolean getExceptionThrown()
```
    Gets whether this value has been thrown as an exception
    
    返回:
    
    True if this value has been thrown as an exception, otherwise false
  - deriveConditionalAbstractionEnter
```
public Abstraction deriveConditionalAbstractionEnter(IInfoflowCFG.UnitContainer postdom,
                                                     soot.jimple.Stmt conditionalUnit)
```
  - deriveConditionalAbstractionCall
```
public Abstraction deriveConditionalAbstractionCall(soot.Unit conditionalCallSite)
```
  - dropTopPostdominator
```
public Abstraction dropTopPostdominator()
```
  - getTopPostdominator
```
public IInfoflowCFG.UnitContainer getTopPostdominator()
```
  - isTopPostdominator
```
public boolean isTopPostdominator(soot.Unit u)
```
  - isTopPostdominator
```
public boolean isTopPostdominator(soot.SootMethod sm)
```
  - clone
```
public Abstraction clone()
```
    从接口复制的说明: FastSolverLinkedNode
    
    Clones this data flow abstraction
    
    指定者:
    
    clone 在接口中 FastSolverLinkedNode<Abstraction,soot.Unit>
    
    覆盖:
    
    clone 在类中 Object
    
    返回:
    
    A clone of the current data flow abstraction
  - equals
```
public boolean equals(Object obj)
```
    覆盖:
    
    equals 在类中 Object
  - hashCode
```
public int hashCode()
```
    覆盖:
    
    hashCode 在类中 Object
  - entails
```
public boolean entails(Abstraction other)
```
    Checks whether this abstraction entails the given abstraction, i.e. this taint also taints everything that is tainted by the given taint.
    
    参数:
    
    other - The other taint abstraction
    
    返回:
    
    True if this object at least taints everything that is also tainted by the given object
  - getSourceContext
```
public SourceContext getSourceContext()
```
    Gets the context of the taint, i.e. the statement and value of the source
    
    返回:
    
    The statement and value of the source
  - dependsOnCutAP
```
public boolean dependsOnCutAP()
```
  - getPredecessor
```
public Abstraction getPredecessor()
```
    从接口复制的说明: FastSolverLinkedNode
    
    Gets the predecessor of this node
    
    指定者:
    
    getPredecessor 在接口中 FastSolverLinkedNode<Abstraction,soot.Unit>
    
    返回:
    
    The predecessor of this node is applicable, null for source nodes
  - getNeighbors
```
public Set<Abstraction> getNeighbors()
```
  - getCurrentStmt
```
public soot.jimple.Stmt getCurrentStmt()
```
  - addNeighbor
```
public boolean addNeighbor(Abstraction originalAbstraction)
```
    从接口复制的说明: FastSolverLinkedNode
    
    Links this node to a neighbor node, i.e., to an abstraction that would have been merged with this one of paths were not being tracked.
    
    指定者:
    
    addNeighbor 在接口中 FastSolverLinkedNode<Abstraction,soot.Unit>
    
    返回:
    
    True if the neighbor was added, false if it was rejected
  - setCorrespondingCallSite
```
public void setCorrespondingCallSite(soot.jimple.Stmt callSite)
```
  - getCorrespondingCallSite
```
public soot.jimple.Stmt getCorrespondingCallSite()
```
  - getZeroAbstraction
```
public static Abstraction getZeroAbstraction(boolean flowSensitiveAliasing)
```
  - setPredecessor
```
public void setPredecessor(Abstraction predecessor)
```
    从接口复制的说明: FastSolverLinkedNode
    
    Explicitly sets the predecessor of this node.
    
    指定者:
    
    setPredecessor 在接口中 FastSolverLinkedNode<Abstraction,soot.Unit>
    
    参数:
    
    predecessor - The predecessor node to set
  - setSourceContext
```
public void setSourceContext(SourceContext sourceContext)
```
    Only use this method if you really need to fake a source context and know what you are doing.
    
    参数:
    
    sourceContext - The new source context
  - registerPathFlag
```
public boolean registerPathFlag(int id,
                                int maxSize)
```
    Registers that a worker thread with the given ID has already processed this abstraction
    
    参数:
    
    id - The ID of the worker thread
    
    返回:
    
    True if the worker thread with the given ID has not been registered before, otherwise false
  - injectSourceContext
```
public Abstraction injectSourceContext(SourceContext sourceContext)
```
  - getNeighborCount
```
public int getNeighborCount()
```
    从接口复制的说明: FastSolverLinkedNode
    
    Gets the number of neighbors already registered with this abstraction
    
    指定者:
    
    getNeighborCount 在接口中 FastSolverLinkedNode<Abstraction,soot.Unit>
    
    返回:
    
    The number of neighbors already registered with this abstraction
  - getPathLength
```
public int getPathLength()
```
    从接口复制的说明: FastSolverLinkedNode
    
    Gets the length of the path over which this node was propagated
    
    指定者:
    
    getPathLength 在接口中 FastSolverLinkedNode<Abstraction,soot.Unit>
    
    返回:
    
    The length of the path over which this node was propagated

类 Abstraction

嵌套类概要

字段概要

构造器概要

方法概要

从类继承的方法 java.lang.Object

字段详细资料

flowSensitiveAliasing

accessPath

predecessor

neighbors

currentStmt

correspondingCallSite

sourceContext

activationUnit

exceptionThrown

hashCode

neighborHashCode

postdominators

isImplicit

dependsOnCutAP

pathFlags

propagationPathLength

构造器详细资料

Abstraction

Abstraction

方法详细资料

initialize

deriveInactiveAbstraction

deriveNewAbstraction

deriveNewAbstraction

deriveNewAbstractionMutable

deriveNewAbstractionOnThrow

deriveNewAbstractionOnCatch

isAbstractionActive

isImplicit

toString

getAccessPath

getActivationUnit

getActiveCopy

getExceptionThrown

deriveConditionalAbstractionEnter

deriveConditionalAbstractionCall

dropTopPostdominator

getTopPostdominator

isTopPostdominator

isTopPostdominator

clone

equals

hashCode

entails

getSourceContext

dependsOnCutAP

getPredecessor

getNeighbors

getCurrentStmt

addNeighbor

setCorrespondingCallSite

getCorrespondingCallSite

getZeroAbstraction

setPredecessor

setSourceContext

registerPathFlag

injectSourceContext

getNeighborCount

getPathLength