Dakusan’s Domain > Archive > Posts > Tags

<? //The log data to save is stored here global $GlobalLogArr, $GlobalLogDir; $GlobalLogArr=Array(); $GlobalLogDir='./LOG_DIRECTORY_NAME'; //Override the functions here to instead have them call to GlobalRunFunc, which will in turn call the original functions foreach(Array( 'fopen', 'file_get_contents', 'curl_init', 'curl_setopt', //List of functions to intercept ) as $FuncName) { runkit_function_rename($FuncName, "OVERRIDE_$FuncName"); runkit_function_add($FuncName, '', "return GlobalRunFunc('$FuncName', func_get_args());"); } //This optionally function GlobalRunFunc($FuncName, $Args) { global $GlobalLogArr; if( ($FuncName=='curl_setopt' && $Args[1]==10002) || //CURLOPT enumeration can be found at https://curl.haxx.se/mail/archive-2004-07/0100.html ($FuncName=='curl_init' && isset($Args[0])) || (($FuncName=='file_get_contents' || $FuncName=='fopen') && $Args[0][0]!='/') ) $GlobalLogArr[]=serialize(Array('FuncName'=>$FuncName, 'Args'=>$Args, 'Trace'=>array_slice(debug_backtrace(), 1, 2))); return call_user_func_array("OVERRIDE_$FuncName", $Args); } function GlobalShutdown() { global $GlobalLogArr, $GlobalLogDir; $Time=microtime(true); if(count($GlobalLogArr)) file_put_contents($GlobalLogDir.date('Y-m-d_H:i:s.'.substr($Time-floor($Time), 2, 3), floor($Time)).'.srl', implode("\n", $GlobalLogArr)); } register_shutdown_function('GlobalShutdown'); ?>

The PHP MySQL extension is being deprecated in favor of the MySQLi extension in PHP 5.5, and removed as of PHP 7.0. MySQLi was first referenced in PHP v5.0.0 beta 4 on 2004-02-12, with the first stable release in PHP 5.0.0 on 2004-07-13^[1]. Before that, the PHP MySQL extension was by far the most popular way of interacting with MySQL on PHP, and still was for a very long time after. This website was opened only 2 years after the first stable release!

With the deprecation, problems from some websites I help host have popped up, many of these sites being very, very old. I needed a quick and dirty solution to monkey-patch these websites to use MySQLi without rewriting all their code. The obvious answer is to overwrite the functions with wrappers for MySQLi. The generally known way of doing this is with the Advanced PHP Debugger (APD). However, using this extension has a lot of requirements that are not appropriate for a production web server. Fortunately, another extension I recently learned of offers the renaming functionality; runkit. It was a super simple install for me.

Besides the ability to override these functions with wrappers, I also needed a way to make sure this file was always loaded before all other PHP files. The simple solution for that is adding “auto_prepend_file=/PATH/TO/FILE” to the “.user.ini” in the user’s root web directory.

The code for this script is as follows. It only contains a limited set of the MySQL functions, including some very esoteric ones that the web site used. This is not a foolproof script, but it gets the job done.

//Override the MySQL functions
foreach(Array(
    'connect', 'error', 'fetch_array', 'fetch_row', 'insert_id', 'num_fields', 'num_rows',
    'query', 'select_db', 'field_len', 'field_name', 'field_type', 'list_dbs', 'list_fields',
    'list_tables', 'tablename'
) as $FuncName)
    runkit_function_redefine("mysql_$FuncName", '',
        'return call_user_func_array("mysql_'.$FuncName.'_OVERRIDE", func_get_args());');

//If a connection is not explicitely passed to a mysql_ function, use the last created connection
global $SQLLink; //The remembered SQL Link
function GetConn($PassedConn)
{
    if(isset($PassedConn))
        return $PassedConn;
    global $SQLLink;
    return $SQLLink;
}

//Override functions
function mysql_connect_OVERRIDE($Host, $Username, $Password) {
    global $SQLLink;
    return $SQLLink=mysqli_connect($Host, $Username, $Password);
}
function mysql_error_OVERRIDE($SQLConn=NULL) {
    return mysqli_error(GetConn($SQLConn));
}
function mysql_fetch_array_OVERRIDE($Result, $ResultType=MYSQL_BOTH) {
    return mysqli_fetch_array($Result, $ResultType);
}
function mysql_fetch_row_OVERRIDE($Result) {
    return mysqli_fetch_row($Result);
}
function mysql_insert_id_OVERRIDE($SQLConn=NULL) {
    return mysqli_insert_id(GetConn($SQLConn));
}
function mysql_num_fields_OVERRIDE($Result) {
    return mysqli_num_fields($Result);
}
function mysql_num_rows_OVERRIDE($Result) {
    return mysqli_num_rows($Result);
}
function mysql_query_OVERRIDE($Query, $SQLConn=NULL) {
    return mysqli_query(GetConn($SQLConn), $Query);
}
function mysql_select_db_OVERRIDE($DBName, $SQLConn=NULL) {
    return mysqli_select_db(GetConn($SQLConn), $DBName);
}
function mysql_field_len_OVERRIDE($Result, $Offset) {
    $Fields=$Result->fetch_fields();
    return $Fields[$Offset]->length;
}
function mysql_field_name_OVERRIDE($Result, $Offset) {
    $Fields=$Result->fetch_fields();
    return $Fields[$Offset]->name;
}
function mysql_field_type_OVERRIDE($Result, $Offset) {
    $Fields=$Result->fetch_fields();
    return $Fields[$Offset]->type;
}
function mysql_list_dbs_OVERRIDE($SQLConn=NULL) {
    $Result=mysql_query('SHOW DATABASES', GetConn($SQLConn));
    $Tables=Array();
    while($Row=mysqli_fetch_assoc($Result))
        $Tables[]=$Row['Database'];
    return $Tables;
}
function mysql_list_fields_OVERRIDE($DBName, $TableName, $SQLConn=NULL) {
    $SQLConn=GetConn($SQLConn);
    $CurDB=mysql_fetch_array(mysql_query('SELECT Database()', $SQLConn));
    $CurDB=$CurDB[0];
    mysql_select_db($DBName, $SQLConn);
    $Result=mysql_query("SHOW COLUMNS FROM $TableName", $SQLConn);
    mysql_select_db($CurDB, $SQLConn);
    if(!$Result) {
        print 'Could not run query: '.mysql_error($SQLConn);
        return Array();
    }
    $Fields=Array();
    while($Row=mysqli_fetch_assoc($Result))
        $Fields[]=$Row['Field'];
    return $Fields;
}
function mysql_list_tables_OVERRIDE($DBName, $SQLConn=NULL) {
    $SQLConn=GetConn($SQLConn);
    $CurDB=mysql_fetch_array(mysql_query('SELECT Database()', $SQLConn));
    $CurDB=$CurDB[0];
    mysql_select_db($DBName, $SQLConn);
    $Result=mysql_query("SHOW TABLES", $SQLConn);
    mysql_select_db($CurDB, $SQLConn);
    if(!$Result) {
        print 'Could not run query: '.mysql_error($SQLConn);
        return Array();
    }
    $Tables=Array();
    while($Row=mysql_fetch_row($Result))
        $Tables[]=$Row[0];
    return $Tables;
}
function mysql_tablename_OVERRIDE($Result) {
    $Fields=$Result->fetch_fields();
    return $Fields[0]->table;
}

global $MyConn, $TEST_Table;
$TEST_Server='localhost';
$TEST_UserName='...';
$TEST_Password='...';
$TEST_DB='...';
$TEST_Table='...';
function GetResult() {
    global $MyConn, $TEST_Table;
    return mysql_query('SELECT * FROM '.$TEST_Table.' LIMIT 1', $MyConn);
}
var_dump($MyConn=mysql_connect($TEST_Server, $TEST_UserName, $TEST_Password));
//Set $MyConn to NULL here if you want to test global $SQLLink functionality
var_dump(mysql_select_db($TEST_DB, $MyConn));
var_dump(mysql_query('SELECT * FROM INVALIDTABLE LIMIT 1', $MyConn));
var_dump(mysql_error($MyConn));
var_dump($Result=GetResult());
var_dump(mysql_fetch_array($Result));
$Result=GetResult(); var_dump(mysql_fetch_row($Result));
$Result=GetResult(); var_dump(mysql_num_fields($Result));
var_dump(mysql_num_rows($Result));
var_dump(mysql_field_len($Result, 0));
var_dump(mysql_field_name($Result, 0));
var_dump(mysql_field_type($Result, 0));
var_dump(mysql_tablename($Result));
var_dump(mysql_list_dbs($MyConn));
var_dump(mysql_list_fields($TEST_DB, $TEST_Table, $MyConn));
var_dump(mysql_list_tables($TEST_DB, $MyConn));
mysql_query('CREATE TEMPORARY TABLE mysqltest (i int auto_increment, primary key (i))', $MyConn);
mysql_query('INSERT INTO mysqltest VALUES ()', $MyConn);
mysql_query('INSERT INTO mysqltest VALUES ()', $MyConn);
var_dump(mysql_insert_id($MyConn));
mysql_query('DROP TEMPORARY TABLE mysqltest', $MyConn);

void DoOpcode(int OpcodeNumber, ...) { void *Opcodes[]={&&ADD, &&SUB, &&JUMP, &&MUL}; //assuming ADD=opcode 0 and so forth goto *Opcodes[OpcodeNumber]; ADD: //... SUB: //... JUMP: //... MUL: //... }

//Define the switch for which type of opcode picker we want #define UseSwitchStatement //#define UseJumpTable //#define UseFunctionPointers //Defines for how each opcode picker acts #if defined(UseSwitchStatement) #define OPCODE(o) case OP_##o: #elif defined(UseJumpTable) #define OPCODE(o) o: #define GET_OPCODE(o) &&o #elif defined(UseFunctionPointers) #define OPCODE(o) void Opcode_##o() #define GET_OPCODE(o) (void*)&Opcode_##o //The above GET_OPCODE is actually a problem since the opcode functions aren't listed until after their ... //address is requested, but there are a couple of ways around that I'm not going to worry about going into here. #endif enum {OP_ADD=0, OP_SUB}; //assuming ADD=opcode 0 and so forth void DoOpcode(int OpcodeNumber, ...) { #ifndef UseSwitchStatement //If using JumpTable or FunctionPointers we need an array of the opcode jump locations void *Opcodes[]={GET_OPCODE(ADD), GET_OPCODE(SUB)}; //assuming ADD=opcode 0 and so forth #endif #if defined(UseSwitchStatement) switch(OpcodeNumber) { //Normal switch statement #elif defined(UseJumpTable) goto *Opcodes[OpcodeNumber]; //Jump to the proper label #elif defined(UseFunctionPointers) *(void(*)(void))Opcodes[OpcodeNumber]; //Jump to the proper function } //End the current function #endif //For testing under "UseFunctionPointers" (see GET_OPCODE comment under "defined(UseFunctionPointers)") //put the following OPCODE sections directly above this "DoOpcode" function OPCODE(ADD) { //... } OPCODE(SUB) { //... } #ifdef UseSwitchStatement //End the switch statement } #endif #ifndef UseFunctionPointers //End the function } #endif

//** Double stars denotes changes for custom circumstance [The About Window Mask] #include <windows.h> #include <stdio.h> #include <conio.h> //Our encoding functions int ErrorOut(char* Error, FILE* HandleToClose); //If an error occurs, output UINT Encode(UCHAR* Input, UCHAR* Output, UINT Width, UINT Height); //Encoding process UCHAR NumBitsRequired(UINT Num); //Tests how many bits are required to represent a number void WriteToBits(UCHAR* StartPointer, UINT BitStart, UINT Value); //Write Value to Bit# BitStart after StartPointer - Assumes more than 8 bits are never written //Program constants const UCHAR BytesPerPixel=3, TranspMask=255; //24 bits per pixel, and white = transparent background color //Encoding file header typedef struct { USHORT DataSize; //Data size in bits - **Should be UINT UCHAR Width, Height; //**Should be USHORTs UCHAR TranspSize, TranslSize; //Largest number of bits required for a run length for Transp[arent] and Transl[ucent] UCHAR NumIndexes, Indexes[0]; //Number and list of indexes } EncodedFileHeader; int main() { UCHAR *InputBuffer, *OutputBuffer; //Where we will hold our input and output data FILE *File; //Handle to current input or output file UINT FileSize; //Holds input and output file sizes //The bitmap headers tell us about its contents BITMAPFILEHEADER BitmapFileHead; BITMAPINFOHEADER BitmapHead; //Read in bitmap header and confirm file type File=fopen("AboutWindow-Mask.bmp", "rb"); //Normally you'd read in the filename from passed arguments (argv) if(!File) //Confirm file open return ErrorOut("Cannot open file for reading", NULL); fread(&BitmapFileHead, sizeof(BITMAPFILEHEADER), 1, File); if(BitmapFileHead.bfType!=*(WORD*)"BM" || BitmapFileHead.bfReserved1 || BitmapFileHead.bfReserved2) //Confirm we are opening a bitmap return ErrorOut("Not a bitmap", File); //Read in the rest of the data fread(&BitmapHead, sizeof(BITMAPINFOHEADER), 1, File); if(BitmapHead.biPlanes!=1 || BitmapHead.biBitCount!=24 || BitmapHead.biCompression!=BI_RGB) //Confirm bitmap type - this code would probably have been simpler if I did an 8 bit indexed file instead... oh well, NBD. **It has also been programmed for easy transition to 8 bit indexed files via the "BytesPerPixel" constant. return ErrorOut("Bitmap must be in 24 bit RGB format", File); FileSize=BitmapFileHead.bfSize-sizeof(BITMAPINFOHEADER)-sizeof(BITMAPFILEHEADER); //Size of the data portion InputBuffer=malloc(FileSize); fread(InputBuffer, FileSize, 1, File); fclose(File); //Run Encode OutputBuffer=malloc(FileSize); //We should only ever need at most FileSize space for output (output should always be smaller) memset(OutputBuffer, 0, FileSize); //Needs to be zeroed out due to how writing of data file is non sequential FileSize=Encode(InputBuffer, OutputBuffer, BitmapHead.biWidth, BitmapHead.biHeight); //Encode the file and get the output size //Write encoded data out File=fopen("Output.msk", "wb"); fwrite(OutputBuffer, FileSize, 1, File); fclose(File); printf("File %d written with %d bytes\n", 1, FileSize); //Free up memory and wait for user input free(InputBuffer); free(OutputBuffer); getch(); //Pause for user input return 0; } int ErrorOut(char* Error, FILE* HandleToClose) //If an error occurs, output { if(HandleToClose) fclose(HandleToClose); printf("%s\n", Error); getch(); //Pause for user input return 1; } UINT Encode(UCHAR* Input, UCHAR* Output, UINT Width, UINT Height) //Encoding process { UCHAR Indexes[256], NumIndexes, IndexSize, RowPad; //The index re-mappings, number of indexes, number of bits an index takes in output data, padding at input row ends for windows bitmaps USHORT TranspSize, TranslSize; //Largest number of bits required for a run length for Transp[arent] (zero) and Transl[ucent] (non zero) - should be UCHAR's, but these are used as explained under "CurTranspLen" below UINT BitSize, x, y, ByteOn, NumPixels; //Current output size in bits, x/y coordinate counters, current byte location in Input, number of pixels in mask //Calculate some stuff NumPixels=Width*Height; //Number of pixels in mask RowPad=4-(Width*BytesPerPixel%4); //Account for windows DWORD row padding - see declaration comment RowPad=(RowPad==4 ? 0 : RowPad); { //Do a first pass to find number of different mask values, run lengths, and their encoded values const UCHAR UnusedIndex=255; //In our index list, unused indexes are marked with this constant USHORT CurTranspLen, CurTranslLen; //Keep track of the lengths of the current transparent & translucent runs - TranspSize and TranslSize are temporarily used to hold the maximum run lengths //Zero out all index references and counters memset(Indexes, UnusedIndex, 256); NumIndexes=0; TranspSize=TranslSize=CurTranspLen=CurTranslLen=0; //Start gathering data for(y=ByteOn=0;y<Height;y++) //Column { for(x=0;x<Width;x++,ByteOn+=BytesPerPixel) //Row { UCHAR CurMask=Input[ByteOn]; //Curent alpha mask if(CurMask!=TranspMask) //Translucent value? { //Determine if index has been used yet if(Indexes[CurMask]==UnusedIndex) //We only need to check 1 byte per pixel as they are all the same for gray-scale **This would need to change if using non 24-bit or non gray-scale { ((EncodedFileHeader*)Output)->Indexes[NumIndexes]=CurMask; //Save mask number in the index header Indexes[CurMask]=NumIndexes++; //Save index number to the mask } //Length of current transparent run TranspSize=(CurTranspLen>TranspSize ? CurTranspLen : TranspSize); //Max(CurTranspLen, TranspSize) CurTranspLen=0; //Length of current translucent run CurTranslLen++; } else //Transparent value? { //Length of current translucent run TranslSize=(CurTranslLen>TranslSize ? CurTranslLen : TranslSize); //Max(CurTranslLen, TranslSize) CurTranslLen=0; //Length of current transparent run CurTranspLen++; } } ByteOn+=RowPad; //Account for windows DWORD row padding } //Determine number of required bits per value printf("Number of Indexes: %d\nLongest Transparent Run: %d\nLongest Translucent Run: %d\n", NumIndexes, TranspSize=CurTranspLen>TranspSize ? CurTranspLen : TranspSize, //Max(CurTranspLen, TranspSize) TranslSize=CurTranslLen>TranslSize ? CurTranslLen : TranslSize //Max(CurTranslLen, TranslSize) ); IndexSize=NumBitsRequired(NumIndexes); TranspSize=NumBitsRequired(TranspSize); //**This is currently overwritten a few lines down TranslSize=NumBitsRequired(TranslSize); //**This is currently overwritten a few lines down printf("Bit Lengths of - Indexes, Trasparent Run Length, Translucent Run Length: %d, %d, %d\n", IndexSize, TranspSize, TranslSize); } //**Modify run sizes (custom) - this function could be run multiple times with different TranspSize and TranslSize until the best values are found - the best values would always be a weighted average TranspSize=6; TranslSize=3; //Start processing data BitSize=(sizeof(EncodedFileHeader)+NumIndexes)*8; //Skip the file+bitmap headers and measure in bits x=ByteOn=0; do { //Transparent run UINT CurRun=0; while(Input[ByteOn]==TranspMask && x<NumPixels && CurRun<(UINT)(1<<TranspSize)-1) //Final 2 checks are for EOF and capping run size to max bit length { x++; CurRun++; ByteOn+=BytesPerPixel; if(x%Width==0) //Account for windows DWORD row padding ByteOn+=RowPad; } WriteToBits(Output, BitSize, CurRun); BitSize+=TranspSize; //Translucent run CurRun=0; BitSize+=TranslSize; //Prepare to start writing masks first while(x<NumPixels && Input[ByteOn]!=TranspMask && CurRun<(UINT)(1<<TranslSize)-1) //Final 2 checks are for EOF and and capping run size to max bit length { WriteToBits(Output, BitSize+CurRun*IndexSize, Indexes[Input[ByteOn]]); x++; CurRun++; ByteOn+=BytesPerPixel; if(x%Width==0) //Account for windows DWORD row padding ByteOn+=RowPad; } WriteToBits(Output, BitSize-TranslSize, CurRun); //Write the mask before the indexes BitSize+=CurRun*IndexSize; } while(x<NumPixels); { //Output header EncodedFileHeader *OutputHead; OutputHead=(EncodedFileHeader*)Output; OutputHead->DataSize=BitSize-(sizeof(EncodedFileHeader)+NumIndexes)*8; //Length of file in bits not including header OutputHead->Width=Width; OutputHead->Height=Height; OutputHead->TranspSize=(UCHAR)TranspSize; OutputHead->TranslSize=(UCHAR)TranslSize; OutputHead->NumIndexes=NumIndexes; } return BitSize/8+(BitSize%8 ? 1 : 0); //Return entire length of file in bytes } UCHAR NumBitsRequired(UINT Num) //Tests how many bits are required to represent a number { UCHAR RetNum; _asm //Find the most significant bit { xor eax, eax //eax=0 bsr eax, Num //Find most significant bit in eax mov RetNum, al } return RetNum+((UCHAR)(1<<RetNum)==Num ? 0 : 1); //Test if the most significant bit is the only one set, if not, at least 1 more bit is required } void WriteToBits(UCHAR* StartPointer, UINT BitStart, UINT Value) //Write Value to Bit# BitStart after StartPointer - Assumes more than 8 bits are never written { *(WORD*)(&StartPointer[BitStart/8])|=Value<<(BitStart%8); }

//Decode void Decode(UCHAR* Input, UCHAR* Output); //Decoding process UCHAR ReadBits(UCHAR* StartPointer, UINT BitStart, UCHAR BitSize); //Read value from Bit# BitStart after StartPointer - Assumes more than 8 bits are never read UCHAR NumBitsRequired(UINT Num); //Tests how many bits are required to represent a number --In Encoding Code-- int main() { //--Encoding Code-- UCHAR *InputBuffer, *OutputBuffer; //Where we will hold our input and output data FILE *File; //Handle to current input or output file UINT FileSize; //Holds input and output file sizes //The bitmap headers tell us about its contents //Read in bitmap header and confirm file type //Read in the rest of the data //Run Encode //Write encoded data out //--END Encoding Code-- //Run Decode UCHAR* O2=(BYTE*)malloc(BitmapFileHead.bfSize); Decode(OutputBuffer, O2); /* //If writing back out to a 24 bit windows bitmap, this adds the row padding back in File=fopen("output.bmp", "wb"); fwrite(&BitmapFileHead, sizeof(BITMAPFILEHEADER), 1, File); fwrite(&BitmapHead, sizeof(BITMAPINFOHEADER), 1, File); fwrite(O2, BitmapFileHead.bfSize-sizeof(BITMAPINFOHEADER)-sizeof(BITMAPFILEHEADER), 1, File);*/ //Free up memory and wait for user input --In Encoding Code-- return 0; } //Decoding void Decode(UCHAR* Input, UCHAR* Output) //Decoding process { EncodedFileHeader H=*(EncodedFileHeader*)Input; //Save header locally so we have quick memory lookups UCHAR Indexes[256], IndexSize=NumBitsRequired(H.NumIndexes); //Save indexes locally so we have quick lookups, use 256 index array so we don't have to allocate memory UINT BitOn=0; //Bit we are currently on in reading memcpy(Indexes, ((EncodedFileHeader*)Input)->Indexes, 256); //Save the indexes Input+=(sizeof(EncodedFileHeader)+H.NumIndexes); //Start reading input past the header //Unroll/unencode all the pixels do { UINT i, l; //index counter, length (transparent and then index) //Transparent pixels memset(Output, TranspMask, l=ReadBits(Input, BitOn, H.TranspSize)*BytesPerPixel); Output+=l; //Translucent pixels l=ReadBits(Input, BitOn+=H.TranspSize, H.TranslSize); BitOn+=H.TranslSize; for(i=0;i<l;i++) //Write the gray scale out to the 3 pixels, this should technically be done in a for loop, which would unroll itself anyways, but this way ReadBits+index lookup is only done once - ** Would need to be in a for loop if not using gray-scale or 24 bit output Output[i*BytesPerPixel]=Output[i*BytesPerPixel+1]=Output[i*BytesPerPixel+2]=Indexes[ReadBits(Input, BitOn+i*IndexSize, IndexSize)]; Output+=l*BytesPerPixel; BitOn+=l*IndexSize; } while(BitOn<H.DataSize); /* { //If writing back out to a 24 bit windows bitmap, this adds the row padding back in UINT i; UCHAR RowPad=4-(H.Width*BytesPerPixel%4); //Account for windows DWORD row padding RowPad=(RowPad==4 ? 0 : RowPad); Output-=H.Width*H.Height*BytesPerPixel; //Restore original output pointer for(i=H.Height;i>0;i--) //Go backwards so data doesn't overwrite itself memcpy(Output+(H.Width*BytesPerPixel+RowPad)*i, Output+(H.Width*BytesPerPixel)*i, H.Width*BytesPerPixel); }*/ } UCHAR ReadBits(UCHAR* StartPointer, UINT BitStart, UCHAR BitSize) //Read value from Bit# BitStart after StartPointer - Assumes more than 8 bits are never read { return (*(WORD*)&StartPointer[BitStart/8]>>BitStart%8)&((1<<BitSize)-1); }

//Confirm Decoding BOOL CheckDecode(UCHAR* Input1, UCHAR* Input2, UINT Width, UINT Height); //Confirm Decoding //---- Put in main function above "//Free up memory and wait for user input" ---- printf(CheckDecode(InputBuffer, O2, BitmapHead.biWidth, BitmapHead.biHeight) ? "good" : "bad"); BOOL CheckDecode(UCHAR* Input1, UCHAR* Input2, UINT Width, UINT Height) //Confirm Decoding { UINT x,y,i; UCHAR RowPad=4-(Width*BytesPerPixel%4); //Account for windows DWORD row padding RowPad=(RowPad==4 ? 0 : RowPad); for(y=0;y<Height;y++) for(x=0;x<Width;x++) for(i=0;i<BytesPerPixel;i++) if(Input1[y*(Width*BytesPerPixel+RowPad)+x*BytesPerPixel+i]!=Input2[y*(Width*BytesPerPixel)+x*BytesPerPixel+i]) return FALSE; return TRUE; }

'Swap in and out bits Private Declare Function GetDIBits Lib "gdi32" (ByVal aHDC As Long, ByVal hBitmap As Long, ByVal nStartScan As Long, ByVal nNumScans As Long, lpBits As Any, lpBI As BITMAPINFOHEADER, ByVal wUsage As Long) As Long Private Declare Function SetDIBitsToDevice Lib "gdi32" (ByVal hdc As Long, ByVal x As Long, ByVal y As Long, ByVal dx As Long, ByVal dy As Long, ByVal SrcX As Long, ByVal SrcY As Long, ByVal Scan As Long, ByVal NumScans As Long, Bits As Any, BitsInfo As BITMAPINFOHEADER, ByVal wUsage As Long) As Long lpBits As Any, lpBitsInfo As BITMAPINFOHEADER, ByVal wUsage As Long, ByVal dwRop As Long) As Long Private Type RGBQUAD b As Byte g As Byte r As Byte Reserved As Byte End Type Private Type BITMAPINFOHEADER '40 bytes biSize As Long biWidth As Long biHeight As Long biPlanes As Integer biBitCount As Integer biCompression As Long biSizeImage As Long biXPelsPerMeter As Long biYPelsPerMeter As Long biClrUsed As Long biClrImportant As Long End Type Private Const DIB_RGB_COLORS = 0 ' color table in RGBs 'Prepare colors Private Declare Sub CopyMemory Lib "kernel32" Alias "RtlMoveMemory" (Destination As Any, Source As Any, ByVal Length As Long) Private Declare Function GetBkColor Lib "gdi32" (ByVal hdc As Long) As Long Public Sub DisplaySignature(ByRef TheForm As Form) 'Read in Signature Dim BitmapLength As Long, OutBitmap() As RGBQUAD, BitInfo As BITMAPINFOHEADER, Signature As PictureBox Set Signature = TheForm.Signature BitmapLength = Signature.Width * Signature.Height ReDim OutBitmap(0 To BitmapLength - 1) As RGBQUAD With BitInfo .biSize = 40 .biWidth = Signature.Width .biHeight = -Signature.Height .biPlanes = 1 .biBitCount = 32 .biCompression = 0 'BI_RGB .biSizeImage = .biWidth * 4 * -.biHeight End With GetDIBits Signature.hdc, Signature.Image, 0, Signature.Height, OutBitmap(0), BitInfo, DIB_RGB_COLORS 'Alpha blend signature Dim i As Long, Alpha As Double, BackColor As RGBQUAD, ForeColor As RGBQUAD, OBC As Long, OFC As Long OFC = &H67906 OBC = GetBkColor(TheForm.hdc) CopyMemory BackColor, OBC, 4 CopyMemory ForeColor, OFC, 4 For i = 0 To BitmapLength - 1 Alpha = 1 - (CDbl(OutBitmap(i).r) / 255) OutBitmap(i).r = ForeColor.r * Alpha + BackColor.r * (1 - Alpha) OutBitmap(i).g = ForeColor.g * Alpha + BackColor.g * (1 - Alpha) OutBitmap(i).b = ForeColor.b * Alpha + BackColor.b * (1 - Alpha) Next i SetDIBitsToDevice TheForm.hdc, Signature.Left, Signature.Top, Signature.Width, Signature.Height, 0, 0, 0, Signature.Height, OutBitmap(0), BitInfo, DIB_RGB_COLORS TheForm.Refresh End Sub

//Prepare to decode signature //const UCHAR BytesPerPixel=4, TranspMask=255; //32 bits per pixel (for quicker copies and such - variable not used due to changing BYTE*s to DWORD*s), and white=transparent background color - also not used anymore since we directly write in the background color //Load data from executable HGLOBAL GetData=LoadResource(NULL, FindResource(NULL, "DakSig", "Sig")); //Load the resource from the executable BYTE *Input=(BYTE*)LockResource(GetData); //Get the resource data //Prepare header and decoding data UINT BitOn=0; //Bit we are currently on in reading EncodedFileHeader H=*(EncodedFileHeader*)Input; //Save header locally so we have quick memory lookups DWORD *Output=Signature=new DWORD[H.Width*H.Height]; //Allocate signature memory //Prepare the index colors DWORD Indexes[17], IndexSize=NumBitsRequired(H.NumIndexes); //Save full color indexes locally so we have quick lookups, use 17 index array so we don't have to allocate memory (since we already know how many there will be), #16=transparent color DWORD BackgroundColor=GetSysColor(COLOR_BTNFACE), FontColor=0x067906; BYTE *BGC=(BYTE*)&BackgroundColor, *FC=(BYTE*)&FontColor; for(UINT i=0;i<16;i++) //Alpha blend the indexes { float Alpha=((EncodedFileHeader*)Input)->Indexes[i] / 255.0f; BYTE IndexColor[4]; for(int n=0;n<3;n++) IndexColor[n]=(BYTE)(BGC[n]*Alpha + FC[n]*(1-Alpha)); //IndexColor[3]=0; //Don't really need to worry about the last byte as it is unused Indexes[i]=*(DWORD*)IndexColor; } Indexes[16]=BackgroundColor; //Translucent background = window background color //Unroll/unencode all the pixels Input+=(sizeof(EncodedFileHeader)+H.NumIndexes); //Start reading input past the header do { UINT l; //Length (transparent and then index) //Transparent pixels memsetd(Output, Indexes[16], l=ReadBits(Input, BitOn, H.TranspSize)); Output+=l; //Translucent pixels l=ReadBits(Input, BitOn+=H.TranspSize, H.TranslSize); BitOn+=H.TranslSize; for(i=0;i<l;i++) //Write the gray scale out to the 3 pixels, this should technically be done in a for loop, which would unroll itself anyways, but this way ReadBits+index lookup is only done once - ** Would need to be in a for loop if not using gray-scale or 24 bit output Output[i]=Indexes[ReadBits(Input, BitOn+i*IndexSize, IndexSize)]; Output+=l; BitOn+=l*IndexSize; } while(BitOn<H.DataSize); //Output the signature const BITMAPINFOHEADER MyBitmapInfo={sizeof(BITMAPINFOHEADER), 207, 42, 1, 32, BI_RGB, 0, 0, 0, 0, 0}; SetDIBitsToDevice(MyDC, x, y, MyBitmapInfo.biWidth, MyBitmapInfo.biHeight, 0, 0, 0, MyBitmapInfo.biHeight, Signature, (BITMAPINFO*)&MyBitmapInfo, DIB_RGB_COLORS);