Manual de cómo usar la API de FOCA para poder desarrollar plugins. Ejemplo de un plugin sencillo en .NET

1. FOCA API v0.1
Creación de un plugin básico
Debemos crear un nuevo proyecto de tipo ‘Class Library’ para la generación de una DLL
compilada.
El proyecto debe estar desarrollado sobre el Framework .NET 3.5 o inferior y la plataforma
sobre la que se debe compilar es para ‘Any CPU’. Esto es accesible desde las ‘propiedades del
proyecto / Build / Platform target’.
Una vez el proyecto esté creado será necesario agregar como referencia la DLL de la API de
FOCA (PluginsAPI.dll). Esto se puede realizar desde ‘References / Add reference / Browse’.

2. Para poder llevar a cabo la comunicación entre el plugin y la FOCA mediante la API será
necesaria la creación de una clase publica llamada ‘Plugin’ con las propiedades ‘name’,
‘description’ y ‘exportItems’. Esta clase será instanciada cada vez que la FOCA cargue el plugin.
A continuación se ve una plantilla con esta estructura.
public class Plugin
{
private string _name = "Name";
private string _description = "Description";
private Export export = new Export();
public Plugin()
{
}
public string name
{
get
{
return _name;
}
set
{
_name = value;
}
}
public string description
{
get
{
return _description;
}
set
{
_description = value;
}
}
public Export exportItems
{
get
{
return export;
}
}
}

3. Una vez llegados a este punto podremos compilar la DLL y dispondremos de una librería básica
– pero sin funcionalidad - para ser cargada en FOCA a modo de plugin.
Para realizar el desarrollo de la DLL así como su depuración aconsejamos la creación de un
nuevo proyecto dentro de la solución del plugin.
Este nuevo proyecto deberá ser configurado como ‘StartUp Project’ para que sea ejecutado
como primera instancia a la hora de llevar a cabo la depuración.

4. Será entonces en el ‘handler’ desde donde aconsejamos realizar las llamadas e inicialización de
nuestra DLL. Éste es sin embargo únicamente un consejo para llevar a cabo el desarrollo o
depuración de la librería.
En la siguiente captura se ve el código de uno de los ‘handler’ visualizando un formulario
localizado en el código del plugin.
GUI del plugin
La API permite dos modos de interactuar con la GUI de la FOCA: Por ventanas y por paneles
embebidos.
El desarrollo de GUI por ventanas es el propio plugin el encargado de crear y mostrar los
formularios que desee para visualizar la información. Este modo es muy similar a la forma
habitual en la que se desarrolla una aplicación con Windows Forms.
A continuación se ve una captura de la FOCA junto con el plugin ‘’ utilizando una visualización
mediante este sistema.

5. El sistema de paneles embebidos permite al plugin a integrarse dentro de la interfaz de la
FOCA. Para ello es necesario realizar la creación de un panel e introducir dentro del mismo los
controles que se deseen exportar a la interfaz.
A continuación se ve un ejemplo de un plugin utilizando este sistema.
Para embeber en la FOCA uno de estos paneles es necesario hacer uso del objeto
‘PluginPanel’ (PluginsAPI.Elements.PluginPanel) y añadirlo a la lista de exportación.
Ejemplo

6. public Plugin()
{
Panel panelForm = new Panel();
PluginPanel panelPlugin = new PluginPanel(panelForm, false);
export.Add(panelPlugin);
}
Una vez añadido el panel es necesario implementar la funcionalidad para mostrar el panel.
Esto puede llevarse a cabo añadiendo un nuevo ítem en el menú desplegable de plugins
exportando el objeto ‘PluginToolStripMenuItem’.
Ejemplo
public Plugin()
{
Panel panelForm = new Panel();
PluginPanel panelPlugin = new PluginPanel(panelForm, false);
ToolStripMenuItem toolStripMenu = new ToolStripMenuItem(_name);
toolStripMenu.Image = Properties.Resources.cookie;
toolStripMenu.Click += delegate
{
panelForm.BringToFront();
panelForm.Visible = true;
};
PluginToolStripMenuItem toolStripPlugin = new
PluginToolStripMenuItem(toolStripMenu);
export.Add(toolStripPlugin);
export.Add(panelPlugin);
}
En la siguiente captura de pantalla se ve un plugin con el código mostrado anteriormente,
embebiendo un panel vacio y agregando un ‘ToolStripItem’ en el desplegable de ‘Plugins’.
Capturar eventos

7. Los eventos de FOCA permiten a los plugins capturar determinados mensajes que son enviados
a éstos.
Para ello es necesaria la creación de un método de tipo ‘void’ en la clase ‘Plugin’ con el nombre
del evento a capturar.
Entre los eventos disponibles se encuentran los siguientes:
Evento Argumentos Descripción
(void) OnNewDomain Object[]
{
string domain
}
Envía un dominio.
(void) OnNewURL Object[]
{
string url
}
Envía una URL.
(void) OnNewIP Object[]
{
string ip
}
Envía una dirección IP.
(void) OnNewProject Object[]
{
string domain
}
Envía el dominio principal cuando un
proyecto es creado.
(void) OnNewNetrange Object[]
{
string ipFrom,
string ipTo
}
Envía el rango de inicio y fin de un
netrange.
(void) OnNewRelation Object[]
{
string ip,
string domain
}
Envía una relación de un dominio con una
IP cuando ésta es calculada.
(void) OnNewDocument (No implementado) (No implementado)
A continuación se ve una captura de pantalla donde se ve la plantilla capturando los dominios
agregados mediante el evento ‘OnNewDomain’.

8. Importar elementos desde el plugin a la FOCA
Para que los plugins puedan interactuar con la GUI de FOCA, la API dispone al desarrollador del
método Import.ImportEventCaller((ImportObject) iObject).
El constructor del objeto de tipo ‘ImportObject’ recibe dos parámetros de tipo
‘Import.Operation’ y ‘object’ con la siguiente definición:
ImportObject(Import.Operation operation, object o);
Entre las operaciones disponibles en la API se encuentran las siguientes, con los
correspondientes objetos a importar para cada tipo de operación.
Operación Objecto(s) a importar
AssociationDomainIP ImportElements.AssociationDomainIP
{
string domain,
String ip
}
AddDomain string domain
AddSQLi ImportElements.AddSQLI
{
string url,
String parameter
}
AddBackup ImportElements.AddBackUp
{
string url
}
AddDirectoryListing
(No implementado)
ImportElements.AddDirectoryListing
{
string url
}
AddDsStore
(No implementado)
ImportElements.AddDsStore
{

9. string url
}
AddGHDB ImportElements.AddGHDB
{
string url
}
AddInsecureMethod
(No implementado)
ImportElements.AddInsecureMethod
{
string url,
string method
}
AddLeak
(No implementado)
ImportElements.AddLeak
{
string url,
string description
}
AddListing
(No implementado)
ImportElements.AddListing
{
string url
}
AddMultiplesChoice
(No implementado)
ImportElements.AddMultiplesChoice
{
string url
}
AddProxy
(No implementado)
ImportElements.AddProxy
{
string url,
int port
}
AddSvn
(No implementado)
ImportElements.AddSvn
{
string url
}
AddUser
(No implementado)
ImportElements.AddUser
{
string domain,
string user
}
AddZoneTransfer
(No implementado)
ImportElements.AddZoneTransfer
{
string ip
}
AssignRol ImportElements.AsignRol
{
string ip,
string rol
}
AddIP String ip
AddURL String url
AddContextMenu ContextualMenu.Global
{
ToolStripMenuItem menu
}
Elements.ContextualMenu.ShowDomainsDomainItemMenu
{
ToolStripMenuItem menu
}
Elements.ContextualMenu.ShowDomainsDomainMenu
{
ToolStripMenuItem menu
}
Elements.ContextualMenu.ShowDomainsDomainRelatedDomainsItemMenu
{
ToolStripMenuItem menu

10. }
Elements.ContextualMenu.ShowDomainsDomainRelatedDomainsMenu
{
ToolStripMenuItem menu
}
Elements.ContextualMenu.ShowDomainsMenu
{
ToolStripMenuItem menu
}
Elements.ContextualMenu.ShowMetadataMenu
{
ToolStripMenuItem menu
}
Elements.ContextualMenu.ShowNetworkClientsItemMenu
{
ToolStripMenuItem menu
}
Elements.ContextualMenu.ShowNetworkClientsMenu
{
ToolStripMenuItem menu
}
Elements.ContextualMenu.ShowNetworkIpRangeMenu
{
ToolStripMenuItem menu
}
Elements.ContextualMenu.ShowNetworkMenu
{
ToolStripMenuItem menu
}
Elements.ContextualMenu.ShowNetworkServersItemMenu
{
ToolStripMenuItem menu
}
Elements.ContextualMenu.ShowNetworkServersMenu
{
ToolStripMenuItem menu
}
Elements.ContextualMenu.ShowNetworkUnlocatedItemMenu
{
ToolStripMenuItem menu
}
Elements.ContextualMenu.ShowNetworkUnlocatedMenu
{
ToolStripMenuItem menu
}
Elements.ContextualMenu.ShowProjectMenu
{
ToolStripMenuItem menu
}
Elements.ContextualMenu.ShowRolesMenu
{
ToolStripMenuItem menu
}
Elements.ContextualMenu.ShowRolesRolMenu
{
ToolStripMenuItem menu
}

11. Elements.ContextualMenu.ShowRolesRolMenuItem
{
ToolStripMenuItem menu
}
Elements.ContextualMenu.ShowVulnerabilitiesMenu
{
ToolStripMenuItem menu
}
Elements.ContextualMenu.ShowVulnerabilitiesVulnerabilitieMenu
{
ToolStripMenuItem menu
}
Elements.ContextualMenu.ShowVulnerabilitiesVulnerabilitieMenuItem
{
ToolStripMenuItem menu,
Elements.ContextualMenu.keyType menu
}
Ejemplo: Asigna al dominio ‘www.informática64.com’ una vulnerabilidad de tipo SQL Injection
en la URL http://www.informatica64.com/focaplugin.aspx sobre el parámetro ‘id’.
ImportObject iObject = new ImportObject(
Import.Operation.AddSQLi,
new ImportElements.AddSQLI(
"http://www.informatica64.com/focaplugin.aspx",
"id")
);
Import.ImportEventCaller(iObject);