Olá pessoal!!

Recentemente tive vários problemas ao tentar conectar o ruby com o banco postgres via dbi com a porta diferente da padrão 5432. Era erro atrás de erro, só conseguia conectar com a porta padrão 5432, mas queria utilizar outra, por exemplo, 5433. Até que consegui assim:

require 'dbi'
con=["DBI:Pg:dbname=nome_do_banco;host=localhost;port=porta", "nome_do_usuario", "senha"]
DBI.connect(*con)

É isso ai!
Abraços!

.
Baltic Dry Index – BDI (BALDRY) es un índice de la contratación de fletes marítimos de carga seca de las 26 principales líneas marítimas mundiales, administrado por el Baltic Exchange en Londres, su creación se remonta al año 1744. El índice es una evaluación del precio del transporte por mar de las principales materias primas como son principalmente carbón, mineral de hierro y granos y nos refleja la cantidad de contratos de envío de mercancías que se cierran en las principales rutas marítimas mundiales.

Obviamente, en la medida en que la economía mundial entra en crisis, se reducen los contratos de transporte y en consecuencia el Baltic Dry Index también desciende, por lo tanto es un indicador adelantado al mercado y se revela como un eficaz termómetro de la evolución de la economía mundial.En tiempos de crisis, el PIB (Producto Interior Bruto) desciende, se produce una reducción de consumo y aumenta la pobreza, lo que supone una menor demanda de materias primas y una paralización del comercio mundial que impacta en las empresas navieras, quedándose numerosos buques anclados en los puertos.

A diferencia de los mercados de valores y materias primas, el Baltic Dry Index está totalmente desprovisto de  especulación. El comercio está limitado sólo a las empresas asociadas, y las únicas partes pertinentes para asegurar contratos son los que tienen carga real a circular y los que tienen los barcos para moverlo.

El Baltic Dry Index es considerado como uno de los indicadores libre de especulación. Por lo tanto es importante mantener un ojo en el índice para tener una idea de la dirección en la que se dirige la economía mundial.

Datos mostrados desde 1-1-2009 hasta hoy.

Para refrescar la información en una vista materializada..
ejecutar en sqlplus

 exec dbms_snapshot.refresh('xxam_vista1_mv','C');

después de refrescar en modo completo “C”, se puede usar para el modo fast “F”; ej.

 exec dbms_snapshot.refresh('xxam_vista1_mv','F');

Al querer adecuar un reporte standar (seeded) en DBI, me encontre que este no aparece en la responsabilidad de “Daily Business Intelligence Designer”.Después de investigarle llegue a la responsabilidad “Ak Developer”, tiene una opción de definir regiones, desde esta responsabilidad se pueden agregar nuevos items al reporte o modificar el display flag para hacer visibles ciertos campos, o en su defecto ocultar algunos.

Para crear una vista materializada que hacia falta para DBI, tuve que utilizar la herramienta FNDXDFCMP he aqui lo que encontre ..

Una vez obtenido el archivo xdf que vienen dentro de los patch, use la siguiente sintaxis

adjava -m512m -nojit oracle.apps.fnd.odf2.FndXdfCmp <owner schema> <schema password><apps user><apps password> jdbc_protocol "tns" object_type <full path xdf file> <$FND_TOP/patch/115/xdf/xsl>
donde:

• jdbc_protocol usar thin
• tns usar los datos para la conexion [hostname:db_port:sid]
• object_type usar all opciones mview,synonym,index,table,sequence,queue

Ejemplo:

 adjava -mx512m -nojit oracle.apps.fnd.odf2.FndXdfCmp fnd fnd apps apps thin "192.168.1.27:1521:DESA" all missing_table.xdf $FND_TOP/patch/115/xdf/xsl

Al ejecutar el concurrente “Cargar Clasificación de Mercado de parte” (FII_PARTY_MKT_CLASS_C), leo que hay un error ORA-01400: cannot insert NULL into (“FII”.”FII_PARTY_MKT_CLASS_STG”.”START_DATE”);  esto afecta a los tableros de Receivables.
la solución es configurar la opción Tipo de Clasificación de Mercado de Parte en los parámetros globales

• Ir a la responsabilidad “Administrador de Daily Business Intelligence”
• Después seleccionar Configuración:Globales
• en Tipo de Clasificación de Mercado de Parte seleccionar el valor  ”Categoría Clientes”.

When it comes to celebrity status, Mario — of video game fame — ranks higher than Matt Damon, Ashley Judd, Michael Jordan and Robert Redford.

According to the Davie Brown Celebrity Index (DBI), Mario is recognized by 93 percent of U.S. consumers. But he’s not the top dog in the video world. That honor goes to Pac-Man, who is recognized by 94 percent of U.S. consumers.

The Davie Brown Celebrity Index (DBI) is an independent index that ranks celebrities across eight attributes through a series of more than 1,600 consumer surveys.

Did you know?

• Mario made his first appearance in the video game “Donkey Kong.”
• The four ghosts in Pac-Man are named Blinky, Pinky, Inky and Clyde.
• Billy L. Mitchell was the first person to achieve a perfect Pac-Man score of 3,333,360. In 2007, he set the world record score for Donkey Kong with 1,050,200 points.

Now for a big Thank You! The Design Week 2009 website in association with Bombay Sapphire was created by Ambient Project.  We have worked successfully with them for our last website and current site and with graphics and branding for numerous projects in the last two years. Ambient Project is an experienced and established agency offering not only the skills to create websites but also the skills to make them highly usable, accessible and profitable.

Whether working with an Organisation, SME, start up-business, cafe, salon or restaurant, their work combines rationality, humour, visual clarity and a unique sensitivity to colour, to create memorable and stylish on-line identities for a wide range of clients. They provide a bespoke and highly considered service to large organisations and private individual clients alike.

Offering a personal service to all their clients, offering quotes and designs tailored to suit the needs of any business or organisation.

So Thank You! Ambient Project, and you can check them out on-line at www.ambientproject.com

use DBI;
$dbh = DBI->connect(“dbi:mysql:$database:$url“,$username,$password) or die “Can’t open database: $DBI::errstr”;
$dbh->disconnect();

$database //Name of database
$url //Address of database
$username //username
$password //password

$sth = $dbh->prepare(“SELECT field1 , field2 , field3 FROM table1 WHERE field2 = ? AND field3 = ? “);
$sth->execute($field2,$field3);

$sth=$dbh->prepare(“INSERT INTO table1 (field1 , field2 , timefield) VALUES ( ? , ? , now() ) “);
$sth->execute($field1,$field2);

$sth = $dbh->prepare(“UPDATE table1 SET field1 = field1 + 1 , field2 = ? , field3 = ? WHERE field4 = ? “);
$sth->execute($field2,$field3,$field4);

$sth=$dbh->prepare(“DELETE FROM table1 WHERE field1 = ? “);
$sth->execute($field1);

if($sth->rows == 1){
//do something
}
$inserted_auto_id = $dbh->{mysql_insertid};
($field1,$field2,$field3)=$sth->fetchrow_array();

I’ve been given the task of writing some perl scripts which will run on a Solaris 10 machine and communicate with an Oracle 10g XE database which in turn is living on a RHEL5 box.

While I have some experience installing/patching Oracle, I’ve never written a script which communicates directly with it – so this should be a good learning exercise.

There’s a simple table in the database called “SM_USER_CONFIG” which contains a few rows just for testing.

The first step I feel, is to get the machine communicating with the database via sqlplus.

To do this, we need to install “Instant Client” – We want “Basic” “Sqlplus” and “SDK”

(available from http://www.oracle.com/technology/software/tech/oci/instantclient/htdocs/solx86soft.html)

I extracted all of these to /opt/instantclient:

(TCSUNDEV01:/opt/instantclient) sysmgr > ls
classes12.jar  libclntsh.so.10.1*  libocci.so.10.1*  libsqlplus.so*    sdk/        tnsnames.ora
glogin.sql     libnnz10.so*        libociei.so*      libsqlplusic.so*  sqlnet.log
libclntsh.so@  libocci.so@         libocijdbc10.so*  ojdbc14.jar       sqlplus*

We need to create a /opt/instantclient/tnsnames.ora file like this:

XE.WORLD =
  (DESCRIPTION =
    (ADDRESS_LIST =
        (ADDRESS =
          (COMMUNITY = tcp.world)
          (PROTOCOL = TCP)
          (Host = 10.17.58.22)
          (Port = 1521)
        )
    )
    (CONNECT_DATA = (SID = XE)
    )
  )

Lets try and connect with SQL plus:

(TCSUNDEV01:~) sysmgr > setenv TNS_ADMIN /opt/instantclient/
(TCSUNDEV01:~) sysmgr > /opt/instantclient/sqlplus username/password@XE.WORLD

SQL*Plus: Release 10.2.0.2.0 – Production on Thu Jun 25 19:16:00 2009
Copyright (c) 1982, 2005, Oracle.  All Rights Reserved.
Connected to:
Oracle Database 10g Express Edition Release 10.2.0.1.0 – Production

SQL> SELECT USERNAME
  2  FROM SM_USER_CONFIG
  3  /

USERNAME
——————————
HoustonN
UserTest
TestUser 

SQL>

Cool, it works.

Next up is perl. We will build DBD::Oracle for this. Head over to cpan and download the src. We’re using CSWperl from blastwave.

(TCSUNDEV01:/var/tmp) sysmgr > gzcat /tmp/DBD-Oracle-1.23.tar.gz | gtar -xf -
(TCSUNDEV01:/var/tmp) sysmgr >cd DBD-Oracle-1.23
(TCSUNDEV01:/var/tmp/DBD-Oracle-1.23) sysmgr > setenv TNS_ADMIN /opt/instantclient/
(TCSUNDEV01:/var/tmp/DBD-Oracle-1.23) sysmgr > setenv LD_LIBRARY_PATH /opt/instantclient/
(TCSUNDEV01:/var/tmp/DBD-Oracle-1.23) sysmgr > setenv ORACLE_SID XE
(TCSUNDEV01:/var/tmp/DBD-Oracle-1.23) sysmgr > perl Makefile.PL -V 10.2.0.1

Using DBI 1.604 (for perl 5.008008 on i86pc-solaris-thread-multi) installed in /opt/csw/lib/perl/csw/auto/DBI/

Configuring DBD::Oracle for perl 5.008008 on solaris (i86pc-solaris-thread-multi)

Remember to actually *READ* the README file! Especially if you have any problems.

Trying to find an ORACLE_HOME
Found /opt/instantclient/

WARNING: Setting ORACLE_HOME env var to /opt/instantclient/ for you.
WARNING: If these tests fail you may have to set ORACLE_HOME yourself!
Installing on a solaris, Ver#2.8
Using Oracle in /opt/instantclient/
SP2-1503: Unable to initialize Oracle call interface
SP2-0152: ORACLE may not be functioning properly

            If sqlplus failed due to a linker/symbol/relocation/library error or similar problem
            then it’s likely that you’ve not configured your environment correctly.
            Specifically, your LD_LIBRARY_PATH environment variable
            set to include the directory containing the Oracle libraries.

Forcing Oracle version to be treated as 10.2.0.1
Oracle version 10.2.0.1 (10.2)
Looks like an Instant Client installation, okay
Your LD_LIBRARY_PATH env var is set to ‘/opt/instantclient/’
Oracle sysliblist:
Found header files in /opt/instantclient//sdk/include.

Checking for functioning wait.ph
System: perl5.008008 sunos thor 5.8 generic_117351-51 i86pc i386 i86pc
Compiler:   cc -xO3 -xtarget=generic -xarch=generic -D_REENTRANT -xO3 -xtarget=generic -xarch=generic -I/opt/csw/bdb44/include -I/opt/csw/include -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64
Linker:     /usr/ccs/bin/ld
Sysliblist:
Linking with -lclntsh.

LD_RUN_PATH=/opt/instantclient
Using DBD::Oracle 1.23.
Using DBD::Oracle 1.23.
Using DBI 1.604 (for perl 5.008008 on i86pc-solaris-thread-multi) installed in /opt/csw/lib/perl/csw/auto/DBI/
Writing Makefile for DBD::Oracle

***  If you have problems…
     read all the log printed above, and the README and README.help.txt files.
     (Of course, you have read README by now anyway, haven’t you?)

Notice the warning about sqlplus failing above. As we’re building this on a CLIENT, when sqlplus is invoked it doesn’t specify @XE.WORLD (default is to connect to a local database)- We can just ignore this.

Go ahead and run “make install”

(TCSUNDEV01:/var/tmp/DBD-Oracle-1.23) sysmgr > pfexec gmake install
Skip blib/lib/DBD/Oracle.pm (unchanged)
Skip blib/lib/oraperl.ph (unchanged)
Skip blib/arch/auto/DBD/Oracle/dbdimp.h (unchanged)
Skip blib/arch/auto/DBD/Oracle/ocitrace.h (unchanged)
Skip blib/lib/Oraperl.pm (unchanged)
Skip blib/arch/auto/DBD/Oracle/Oracle.h (unchanged)
Skip blib/lib/DBD/Oracle/Object.pm (unchanged)
Skip blib/arch/auto/DBD/Oracle/mk.pm (unchanged)
Skip blib/lib/DBD/Oracle/GetInfo.pm (unchanged)
cc -c  -I/opt/instantclient//sdk/include -I/opt/csw/lib/perl/csw/auto/DBI -D_REENTRANT -xO3 -xtarget=generic -xarch=generic -I/opt/csw/bdb44/include -I/opt/csw/include -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 -xO3 -xtarget=generic -xarch=generic   -DVERSION=\”1.23\” -DXS_VERSION=\”1.23\” -KPIC “-I/opt/csw/lib/perl/5.8.8/CORE”  -DUTF8_SUPPORT -DNEW_OCI_INIT -DORA_OCI_VERSION=\”10.2.0.1\” Oracle.c
cc -c  -I/opt/instantclient//sdk/include -I/opt/csw/lib/perl/csw/auto/DBI -D_REENTRANT -xO3 -xtarget=generic -xarch=generic -I/opt/csw/bdb44/include -I/opt/csw/include -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 -xO3 -xtarget=generic -xarch=generic   -DVERSION=\”1.23\” -DXS_VERSION=\”1.23\” -KPIC “-I/opt/csw/lib/perl/5.8.8/CORE”  -DUTF8_SUPPORT -DNEW_OCI_INIT -DORA_OCI_VERSION=\”10.2.0.1\” dbdimp.c
cc -c  -I/opt/instantclient//sdk/include -I/opt/csw/lib/perl/csw/auto/DBI -D_REENTRANT -xO3 -xtarget=generic -xarch=generic -I/opt/csw/bdb44/include -I/opt/csw/include -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 -xO3 -xtarget=generic -xarch=generic   -DVERSION=\”1.23\” -DXS_VERSION=\”1.23\” -KPIC “-I/opt/csw/lib/perl/5.8.8/CORE”  -DUTF8_SUPPORT -DNEW_OCI_INIT -DORA_OCI_VERSION=\”10.2.0.1\” oci8.c
Running Mkbootstrap for DBD::Oracle ()
chmod 644 Oracle.bs
rm -f blib/arch/auto/DBD/Oracle/Oracle.so
LD_RUN_PATH=”/opt/instantclient” cc  -G -L/opt/csw/bdb44/lib -L/opt/csw/lib -L/usr/lib -L/usr/ccs/lib -L/opt/SUNWspro/prod/lib -L/lib Oracle.o dbdimp.o oci8.o  -o blib/arch/auto/DBD/Oracle/Oracle.so  \
           -L/opt/instantclient/ -lclntsh       \

chmod 755 blib/arch/auto/DBD/Oracle/Oracle.so
cp Oracle.bs blib/arch/auto/DBD/Oracle/Oracle.bs
chmod 644 blib/arch/auto/DBD/Oracle/Oracle.bs
/opt/csw/bin/perl “-Iblib/arch” “-Iblib/lib” ora_explain.PL ora_explain
Extracted ora_explain from ora_explain.PL with variable substitutions.
cp ora_explain blib/script/ora_explain
/opt/csw/bin/perl “-MExtUtils::MY” -e “MY->fixin(shift)” blib/script/ora_explain
Manifying blib/man1/ora_explain.1
Manifying blib/man3/DBD::Oracle.3perl
Manifying blib/man3/DBD::Oraperl.3perl
Files found in blib/arch: installing files in blib/lib into architecture dependent library tree
Writing /opt/csw/lib/perl/site_perl/auto/DBD/Oracle/.packlist
Appending installation info to /opt/csw/lib/perl/5.8.8/perllocal.pod
(TCSUNDEV01:/var/tmp/DBD-Oracle-1.23) sysmgr >

And test:

(TCSUNDEV01:/var/tmp/DBD-Oracle-1.23) sysmgr > perl -MDBD::Oracle -le ‘print $DBD::Oracle::VERSION;’
1.23

Finally, lets put togeather a little perl script to query our sample table:

use DBI;

$dbh = DBI->connect(‘dbi:Oracle:’, q{USER/PASSWORD@(DESCRIPTION =
    (ADDRESS = (PROTOCOL = TCP)(HOST = 10.17.58.22)(PORT = 1521))
    (CONNECT_DATA =
      (SERVER = DEDICATED)
      (SERVICE_NAME = XE)
    )
  )},”") or die DBI::errstr;

$dbstr = $dbh->prepare(“SELECT id, username, hostname FROM sm_user_config”);
$dbstr->execute;
$~ = TABLEHEADER;
write;

while (($rdbid, $rdbu, $rdbv) = $dbstr->fetchrow_array()) {
        $~ = TABLEENTRY;
        write;
}

$~ = TABLEBOTTOM;
write;
print “\n”;

 

format TABLEHEADER =

+——–+—————–+—————-+
| ID     |   User          |  VMName        |
+——–+—————–+—————-+
.

format TABLEENTRY =
| @<<<<< | @<<<<<<<<<<<<   | @<<<<<<<<<<<<< |
 $rdbid,   $rdbu,            $rdbv
.

format TABLEBOTTOM =
+——–+—————–+—————-+
.

 

Running it, we get:


(TCSUNDEV01:~) sysmgr > perl ora2.pl

+--------+-----------------+---------+
| ID | User | VMName |
+--------+-----------------+---------+
| 1 | HoustonN | VXPTEST39 |
| 3 | UserTest | VXPTEST2 |
| 2 | TestUser | VXPTEST5 |
+--------+-------------+-------------+


 

(Formatting got a bit messed up when I pasted, but you get the idea =)
Party on!

Essa semana precisei criar alguns scripts de migração e estatística de dados em bases MySQL. Esse tipo de problema é bem a area do Perl e Python. Ambos tem uma boa performance em tratamento de dados principalmente arquivos.

Vou tentar explicar como instalar os recursos necessários para fazer uma aplicação em Perl que possa manipular bases de dados em MySQL.

DBI

O DBI é uma interface de acesso e manipulação de dados. Funciona como uma camada entre o script perl e o driver especifico de um SGBD. Com o DBI não é necessário saber a API  de cada SGBD ( Oracle, MySQL, PostgreSQL, etc ). Quando um métido da interface é invocado, a ação é transferida para o driver especifico de forma transparente para o usuário final.

Vamo fazer o troço funcionar.

INGREDIENTES

• Internet
• Perl ou ActivePerl ( Caso seja usuário Windows )
• Teclado

INSTALANDO

Vá até o shell ou prompt de comando e digite:

ppm install DBI

ppm install DBD-mysql

Pronto, agora é só incluir o modulo DBI e já está pronto para usar.

use strict;
use warnings;
use DBI;

my $conexao = DBI->connect('DBI:mysql:database=meu_banco;host=servidor;port=3306','usuario','senha');

É isso ai … a documentação está aqui: http://search.cpan.org/~timb/DBI/DBI.pm
divirtam-se!

I’m currently building a tool that propagates taint information through a program as it executes. Essentially this consists of marking the data read by certain syscalls (e.g. read and recv) as ‘tainted’, or user controllable, followed by tracking the flow of this data through the program. The ‘propagation’ occurs when tainted data is used as a source in an instruction, thus tainting the result. For example, if the data at address 0x100 is tainted and the instruction mov ebx, [0x100] is executed then ebx is now tainted.

To track all possible taint propagation is a fairly involved task. The mov instruction for instance has 4 potential configurations (memory to memory, register to memory etc.) and many instructions (arithmetic ones for instance), do more than simply copying memory. Considering that most binaries from the /bin directory on Linux have between 70-100 unique instructions, and many of these instructions have unique semantics in terms of how they spread the data from source operands into the destination operands, modelling these effects for each instruction would seem to be a fairly involved task.

It’s also a task I’m having to deal with at the moment due to my choice of dynamic binary analysis (DBI) framework. I am using Pin, a free but closed source DBI. One of Pin’s primary goals is speed and thus it can’t afford something like converting each basic block to an intermediary representation (IR) (like Valgrind does). This means we are left with convenience functions to access operators and operands and are required to perform a case by case analysis on each instruction. Luckily, the functions provided by Pin are quite well thought out. Let us consider how to process an instruction like mov dword ptr ds[esi+edx*4+0x2a0], ecx, where ecx is tainted. First of all, we must register a function with Pin to instrument each instruction. This is about as simple as you’d expect.

INS_AddInstrumentFunction(instruction, 0);

This function will then be passed each instruction and will have to decide the correct way to handle it.

VOID
instruction(INS ins, VOID *v)
{
    UINT32 cat = INS_Category(ins);

    switch (cat) {
        case XED_CATEGORY_DATAXFER:
            switch (INS_Opcode(ins)) {
                case XED_ICLASS_XCHG:
                    processXCHG(ins);
                    break;
                case XED_ICLASS_MOV:
                    processMov(ins);
                    break;
etc etc

As you can see, we can work at two levels of granularity. The instruction categories groups together operators with similar emantics e.g there are seperate categories for string operations like rep movsb, arithmetic operations, interrupts etc. The operators in certain categories all have the same taint semantics and we need not go any deeper, but others contain instructions that must be handled on a case by case basis. DATAXFER for instance, contains xchg, mov and bswap, among others, all of which require special attention.

In our example we will end up in the processMov function. The purpose of this function is basically to figure out which of the 4 mov cases we are considering. Pin provides the INS_IsMemoryRead/Write functions, and others, that allow us to figure this out. Quite usefully, it also provides a mechanism to determine the exact address written/read and the number of bytes written/read at run time. This saves us having to calculate the effective address ourselves. For our example we would use these functions to determine that we are writing to memory, from a register, and then use the following call to insert a run time hook to our taint propagation function:

INS_InsertCall(ins, IPOINT_BEFORE, AFUNPTR(simMov_RM),
    IARG_MEMORYWRITE_EA,
    IARG_MEMORYWRITE_SIZE,
    IARG_UINT32, INS_RegR(ins, INS_MaxNumRRegs(ins)-1),
    IARG_END);

You can see here the use of IARG_MEMORYWRITE_EA to get the effective address of the write and the use of INS_RegR to get the last read register (ecx in this case). At runtime this will result in the simMov_RM (simulate mov register to memory) function being called with the specified arguments. It is this function that will finally do the taint propagation.

As you can see there are many cases that must be considered, even for a seemingly trivial operator like mov. Even the above explanation doesn’t deal with the case where a register used in calculating an effective address is itself tainted and requires more code to process correctly. A potential solution, suggested by Silvio might be to do a case split in some cases and then have a default case for instructions not explicitly handled. A solution like this, that over-approximates the tainted data, could lead to extensive false positives though and is not really suitable for the kind of work I’m doing. This leaves one other obvious option for a ‘default case’, and that is to untaint all destination operands in instructions I do not handle. This will lead to an under-approximation of the amount of tainted data, until I encode the semantics of all instructions, but will eliminate false positives and allow me to work on other parts of the algorithm once I have encoded the most common instructions.

Of the DBI frameworks I’ve used, Pin has best support for instrumentation beyond the basic block/instruction level. The designers seem to have recognised that not all instrumentation needs to be done at the basic block or instruction level and thus you are provided with ways to instrument events at the routine level, as groups of basic blocks (traces), on thread creation/deletion and on image loading/unloading and more importantly you are provided with convenience functions to access important data when these events occur. I required this level of instrumentation earlier today when I ran into the following problem:

I have a Pin tool that performs data flow analysis at run time by marking data from certain function calls (e.g. read and recv) as tainted and then tracking this data through the program. We can do this relatively easily in Pin by registering a hook on all system calls as follows:

PIN_AddSyscallEntryFunction(syscallEntry, 0);
PIN_AddSyscallExitFunction(syscallExit, 0);

These functions can then access syscall arguments and return values. I noticed an issue earlier though where the number of tainted bytes was far higher than it should have been. The reason for this is that those syscall hooks also catch syscalls that take place while the executable is being loaded. I considered using a counter to denote a certain number of calls to skip over but then Silvio suggested a much cleaner alternative; to disable syscall hooking until the entry point has been executed. This turns out to be incredibly easy using Pin’s image level instrumentation.

We first register a function to be called when an image is loaded:

IMG_AddInstrumentFunction(image, 0);

Then using some functions provided by Pin we can extract the entry point of the main executable, and store it in a global variable entryPoint, as follows:

VOID
image(IMG img, VOID *v)
{
    if (IMG_IsMainExecutable(img))
        entryPoint = IMG_Entry(img);
}

And finally within our instruction level instrumentation function we can simply check the address of the instruction against this entry point value and set a global flag, passedEntryPoint, when the entry point is executed:

VOID
instruction(INS ins, VOID *v)
{
    if (!passedEntryPoint && INS_Address(ins) == entryPoint)
        passedEntryPoint = true;
...

A check on this flag within the syscallExit function, before we mark any data as tainted then allows us to avoid spurious tainting.

VOID
syscallExit(THREADID tid, CONTEXT *ctx, SYSCALL_STANDARD std, VOID *v)
{
    int bufLen = 0;
    if (readData) {
        bufLen = PIN_GetSyscallReturn(ctx, std);
        if (passedEntryPoint && bufLen > 0) {
            tmgr.createTaintSourceM((unsigned)readBuf, bufLen, readCount++);
            totalBytesRead += bufLen;
        }
    }
}

by Joseph McCafferty for Directorship Boardroom Intelligence,  March 19, 2009.

Directors and officers need protection for their personal assets. The need is especially great now, in the wake of the financial crisis, which has opened the door for government investigators and the plaintiffs’ bar to seek to hold corporate officials responsible for investors’ losses. In this climate, liability insurance tailored narrowly to the needs of directors and officers is an option every corporate board should consider. Protection for individual board members and officers, the original purpose of D&O coverage, becomes critical in financial crises. A type of D&O coverage called “Side A” or “Difference-in-Conditions” coverage fulfills this need. It can be purchased as part of a company’s D&O insurance program, in addition to the now-standard D&O coverage, which insures both directors and officers and the company for its own liability (or reimbursements of directors). A prudent choice is to hire counsel or a sophisticated broker to help navigate the different options that exist as regards D&O coverage…

To continue readilg this article please click here.

Strawberry Perl, by default, does not include many Database Drivers. While it does a great job installing most modules, some CPAN authors simply overlooked Win32 as a target platform, so the build/installation scripts get confused. Among these is the DBD::Pg driver (PostgreSQL database driver), which is really just a thin layer providing access to the C library, libpq.

In terms of working with PostgreSQL databases under Windows, this effectively leaves people with a few options:

1. Try to install the Perl Package Manager (ppm) version of DBD-Pg. This didn’t work for me. I suppose that’s because the installer was expecting an ActivePerl-like environment, and I was using Strawberry Perl’s ppm tool.
2. Compile the DBD::Pg drivers from scratch using Microsoft Visual Studio. This wasn’t a possibility for me because I don’t want to purchase Visual Studio. My school provides licenses via the MSDN Academic Alliance, but I wanted to use something more open-source if possible. Also, the Visual Studio suite is pretty large and takes a significant amount of time to install. It also clutters your machine with an SQL database, among other things.
3. Install DBD::PgPP, a Pure Perl version of the PostgreSQL API. The problem with this is that there are lots of outstanding bugs, and so far it does not behave in exactly the same way as DBD::Pg.
4. Install a specialized Perl package like Camelbox (one of Camelbox’s design goals was to provide DBI and popular DBD support out of the box). I didn’t like the idea of this because I’m so far a pretty big fan of Strawberry Perl and its sister project, Vanilla Perl. Together they seem like the most effective way to solve the Perl-on-Win32 dilemma.

As it turns out, there’s another option. Taking the package stuff meant for Camelbox and dropping it into your Strawberry Perl installation. It works flawlessly, and I’m very grateful to Brian Manning for his work on the project.

Here’s the quick and dirty:

1. Download the postgresql-bin package from the Camelbox downloads area.
2. Download the perl-DBD-Pg package from the same place.
3. Open the lzma files using your favourite archiver program. I love 7-zip and it worked beautifully for extracting those files.
4. Under the perl-DBD-Pg package, there should be a bunch of subdirectories; these correspond to those under C:\Strawberry\perl (or the perl subdirectory of wherever you installed Strawberry Perl). Extract all the files there.
5. In the postgresql-bin package, there is a bin directory that contains a single file, libpq.dll. This one is really important for connecting to the database as it does all of the real work; the Perl stuff just binds to the library functions. Extract this one into C:\Strawberry\perl\site\lib\auto\DBD\Pg (or wherever your Pg.dll is installed)

Alternatively, it might be less stressful to just install Camelbox instead of Strawberry Perl; but this is entirely up to you.

The DBD::mysql isn’t compatible with the 64-bit version of MySQL that comes with the Leopard Server.

When you sudo cpan install DBD::mysql you end up with a lot of compile-errors in dbdimp.c

You actually have to downgrade your MySQL-server-app to a 32-bit version in order to get it working.

You just have to download the 32-bit package from the mysql-site and rerun sudo cpan install DBD::mysql