Value Members

1.  final def !=(arg0: Any): Boolean

   Definition Classes

   AnyRef → Any

2.  final def ##: Int

   Definition Classes

   AnyRef → Any

3.  final def ==(arg0: Any): Boolean

   Definition Classes

   AnyRef → Any

4.  def _runAnalyzer(overlayCreators: LayerCreator*): Cpg
5.  def applyDefaultOverlays(cpg: Cpg): Cpg
6.  final def asInstanceOf[T0]: T0

   Definition Classes

   Any

7.  def clone(): AnyRef

   Attributes

   protected[lang]

   Definition Classes

   AnyRef

   Annotations

   @throws(classOf[java.lang.CloneNotSupportedException]) @native()

8.  def close: Option[Project]
9.  def close(name: String): Option[Project]

   Annotations

   @Doc("Close project by name", """|Close project. Resources are freed but the project remains on disk.
   |The project remains active, that is, calling `cpg` now raises an
   |exception. A different project can now be activated using `open`.
   |""".stripMargin, "close(projectName)")

10.  def config: ConsoleConfig
11.  def console: Console[T]
12.  implicit def cpg: Cpg

    Annotations

    @Doc("CPG of the active project", """
    |Upon importing code, a project is created that holds
    |an intermediate representation called `Code Property Graph`. This
    |graph is a composition of low-level program representations such
    |as abstract syntax trees and control flow graphs, but it can be arbitrarily
    |extended to hold any information relevant in your audit, information
    |about HTTP entry points, IO routines, information flows, or locations
    |of vulnerable code. Think of Ocular and Joern as a CPG editors.
    |
    |In practice, `cpg` is the root object of the query language, that is, all
    |query language constructs can be invoked starting from `cpg`. For example,
    |`cpg.method.l` lists all methods, while `cpg.finding.l` lists all findings
    |of potentially vulnerable code.
    |""".stripMargin, "cpg.method.l")

13.  def cpgs: Iterator[Cpg]

    All cpgs loaded in the workspace

14.  def defaultProjectNameIfEmpty(name: String): Option[String]

    Attributes

    protected

15.  def delete: Option[Unit]

    Delete the active project

16.  def delete(name: String): Option[Unit]

    Delete project from disk and remove it from the workspace manager.

    Delete project from disk and remove it from the workspace manager. Returns the (now invalid) project.

    name

    the name of the project

    Annotations

    @Doc("Close and remove project from disk", "", "delete(projectName)")

17.  final def eq(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef

18.  def equals(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef → Any

19.  def finalize(): Unit

    Attributes

    protected[lang]

    Definition Classes

    AnyRef

    Annotations

    @throws(classOf[java.lang.Throwable])

20.  def fixProjectNameAndComplainOnFix(name: String): String
21.  final def getClass(): Class[_ <: AnyRef]

    Definition Classes

    AnyRef → Any

    Annotations

    @native()

22.  def hashCode(): Int

    Definition Classes

    AnyRef → Any

    Annotations

    @native()

23.  def importCode: ImportCode[T]

    Annotations

    @Doc("Create new project from code", """
    |importCode(<inputPath>, [projectName], [namespaces], [language])
    |
    |Type `importCode` alone to get a list of all supported languages
    |
    |Import code at `inputPath`. Creates a new project, generates a CPG,
    |and opens the project. Upon success, the CPG can be queried via the `cpg`
    |object. Default overlays are already applied to the newly created CPG.
    |Returns new CPG and ensures that `cpg` now refers to this new CPG.
    |
    |By default, `importCode` attempts to guess the source language of
    |the code you provide. You can also specify the source language
    |manually, by running `importCode.<language>`. For example, `importCode.c`
    |runs the C/C++ frontend.
    |
    |Type `importCode` alone to get an overview of all available language modules.
    |
    |Parameters:
    |
    |-----------
    |
    |inputPath: location on disk of the code to analyze. e.g., a directory
    |containing source code or a Java archive (JAR).
    |
    |projectName: a unique name used for project management. If this parameter
    |is omitted, the name will be derived from `inputPath`
    |
    |namespaces: the whitelist of namespaces to analyse. Specifying this
    |parameter is only effective if the language frontend supports it.
    |If the list is omitted or empty, namespace selection is performed
    |automatically via heuristics.
    |
    |language: the programming language which the code at `inputPath` is written in.
    |If `language` is empty, the language used is guessed by inspecting
    |the filename found and possibly by looking into the file/directory.
    |
    |""".stripMargin, """importCode("example.jar")""")

24.  def importCpg(inputPath: String, projectName: String = ""): Option[Cpg]

    Annotations

    @Doc("Create new project from existing CPG", """
    |importCpg(<inputPath>, [projectName])
    |
    |Import an existing CPG. The CPG is stored as part
    |of a new project and blanks are filled in by analyzing the CPG.
    |If we find that default overlays have not been applied, these
    |are applied to the CPG after loading it.
    |
    |Parameters:
    |
    |inputPath: path where the existing CPG (in overflowdb format)
    |is stored
    |
    |projectName: name of the new project. If this parameter
    |is omitted, the path is derived from `inputPath`
    |""".stripMargin, """importCpg("cpg.bin.zip")""")

25.  final def isInstanceOf[T0]: Boolean

    Definition Classes

    Any

26.  final def ne(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef

27.  final def notify(): Unit

    Definition Classes

    AnyRef

    Annotations

    @native()

28.  final def notifyAll(): Unit

    Definition Classes

    AnyRef

    Annotations

    @native()

29.  def open: Option[Project]

    Open the active project

30.  def open(name: String): Option[Project]

    Annotations

    @Doc("Open project", """
    |open([projectName])
    |
    |Opens the project named `name` and make it the active project.
    |If `name` is not provided, the active project is opened. If `name`
    |is a path, the project name is derived from and a deprecation
    |warning is printed.
    |
    |Upon completion of this operation, the CPG stored in this project
    |can be queried via `cpg`. Returns an optional reference to the
    |project, which is empty on error.
    |""".stripMargin, """open("projectName")""")

31.  def project: T

    Annotations

    @Doc("Currently active project", "", "project")

32.  def reload(name: String): Option[Project]

    Close the project and open it again.

    Close the project and open it again.

    name

    the name of the project

33.  def report(string: String): Unit
34.  def runCreator(creator: LayerCreator, overlayDirName: Option[String]): Unit

    Attributes

    protected

35.  def runScript(scriptName: String, parameters: Map[String, String], cpg: Cpg): Any

    Definition Classes

    ScriptManager

36.  def runScript(scriptName: String, parameters: Map[String, String], cpgFileName: String): Any

    Definition Classes

    ScriptManager

37.  def save: List[Project]

    Annotations

    @Doc("Write all changes to disk", """
    |Close and reopen all loaded CPGs. This ensures
    |that changes have been flushed to disk.
    |
    |Returns list of affected projects
    |""".stripMargin, "save")

38.  def scripts(): List[ScriptCollections]

    Definition Classes

    ScriptManager

39.  def switchWorkspace(pathName: String): Unit

    Annotations

    @Doc("Close current workspace and open a different one", """ | By default, the workspace in $INSTALL_DIR/workspace is used.
    | This method allows specifying a different workspace directory
    | via the `pathName` parameter.
    | Before changing the workspace, the current workspace will be
    | closed, saving any unsaved changes.
    | If `pathName` points to a non-existing directory, then a new
    | workspace is first created.
    |""".stripMargin, help.this.Doc.<init>$default$3)

40.  final def synchronized[T0](arg0: => T0): T0

    Definition Classes

    AnyRef

41.  def toString(): String

    Definition Classes

    AnyRef → Any

42.  def undo: File

    Annotations

    @Doc("undo effects of analyzer", """|Undo the last change, that is, unapply the last
    |overlay applied to the active project.
    |""".stripMargin, "undo")

43.  final def wait(): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws(classOf[java.lang.InterruptedException])

44.  final def wait(arg0: Long, arg1: Int): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws(classOf[java.lang.InterruptedException])

45.  final def wait(arg0: Long): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws(classOf[java.lang.InterruptedException]) @native()

46.  def withScriptFile[T](scriptName: String)(f: (File) => IO[T]): IO[T]

    Attributes

    protected

    Definition Classes

    ScriptManager

47.  def workspace: WorkspaceManager[T]

    Annotations

    @Doc("Access to the workspace directory", """
    |All auditing projects are stored in a workspace directory, and `workspace`
    |provides programmatic access to this directory. Entering `workspace` provides
    |a list of all projects, indicating which code the project makes accessible,
    |whether the project is open, and which analyzers have been run to produce it.
    |Multiple projects can be open at any given time, however, only one project
    |can be active. Queries and edit-operations are executed on the active project
    |only.
    |
    |Operations
    |
    |----------
    |
    |`workspace` provides low-level access to the workspace directory. In most cases,
    |it is a better idea to use higher-level operations such as `importCode`, `open`,
    |`close`, and `delete`, which make use of workspace operations internally.
    |
    |* workspace.open([name]): open project by name and make it the active project.
    | If `name` is omitted, the last project in the workspace list is opened. If
    | the project is already open, this has the same effect as `workspace.setActiveProject([name])`
    |
    |* workspace.close([name]): close project by name. Does not remove the project.
    |
    |* workspace.remove([name]): close and remove project by name.
    |
    |* workspace.reset: create a fresh workspace directory, deleting the current
    |workspace directory
    |
    |""".stripMargin, "workspace")

48.  var workspaceManager: WorkspaceManager[T]

    Attributes

    protected

49.  def workspacePathName: String

    Attributes

    protected

50.  implicit object ConsoleImageViewer extends ImageViewer