Reverse Engineering Using PHP

A good documentation of source code is necessary as it helps others to

evaluate your application, to make it error free. But with so much code being

written it becomes difficult to document each and every program. PHP 5 has an

in-built feature called 'Reflection,' which allows you to reverse engineer

different classes, functions or extensions. It also gives information on

objects, starting and ending line numbers of a class or function, parameters and

creates documents. It is an object oriented extension to the existing PHP core

engine. Using this feature, you no longer need to go through hundreds of pages

of documentation to find out about any class or function. A common scenario

where you can use 'Reflection' is, when you have an encoded script to work on

and you don't want to go through its manual. It also helps in understanding how

a particular code is working. Now let's define a class 'first' with a function

called 'display' and second function called 'second' which inherits the parent

class.

class first {



public function display($text) {


// Display the argument passed


echo $text;


} }


class second extends first {


private function bar(first &$baz) {


// do something


} }


$child = new second('hello world');


$child->display('test');


?>

Save this code with '.php' extension and run the script by issuing the

command “php .php”. The output of the above script will be “test”.

Now, let's do reverse engineering of our code. Add the following lines at the

end of the program:

$sec_refl = new ReflectionClass('second'); echo "\n",

"Reflection of Second Class: ", "\n"; echo "This class is abstract: ", (int)$sec_refl->isAbstract(),

"\n";



echo "This class is final: ", (int)$sec_refl->isFinal(), "\n";


echo "This class is actually an interface: ", (int)$sec_refl->isInterface(),
"\n"; echo "\$second is an object of this class: ", (int)$sec_refl->isInstance($sec),

"\n"; $first_refl = new ReflectionClass('first');



echo "\n", "Reflection of First Class: ", "\n" ; echo "This class inherits from
First : ", (int)$sec_refl-> isSubclassOf ($first_refl), "\n";



$reflect = new ReflectionClass('second'); foreach($reflect->getMethods() as $reflectmethod)
{



echo " {$reflectmethod->getName()}()\n"; echo " ", str_repeat("-",
strlen($reflectmethod->getName()) + 2), "\n"; foreach($reflectmethod->getParameters()

as $num => $param) {



echo "Param $num: \$", $param->getName(), "\n"; echo "Passed by


reference: ", (int)$param->isPassedByReference(), "\n"; echo "Can be null: ", (int)$param->allowsNull(),
"\n";



echo "Class type: ";


if ($param->getClass()) {


echo $param->getClass()->getName();


} else { echo "N/A"; } echo "\n\n"; }}

In these lines we have created two new instances of Reflection class for each

class and passed both the classes as a parameter. Then we formatted the output

using some inbuilt function along with the Reflection Class. There is another

way of doing this, ie by simply giving a single line “echo $sec_refl” (for

second class), however, the output will be a bit confusing. The output after

adding the above code is:



Output of the first display function:


Sample Text Argument


Reflection of Second Class:


This class is abstract: 0


This class is final: 0


This class is actually an interface: 0


$second is an object of this class: 1









...

In the output you can clearly see whether a class is an abstract class or

not, or whether there's any object, etc. Further you can also see the

description of each method for the 'second' class: like the number of arguments,

class type, name of the arguments passed, etc.