Issues in gif.php (scrutinizer-code-quality) - Issues in scrutinizer-code-quality - adamjakab/SuiteCRM - Measure and Improve Code Quality continuously with Scrutinizer

Issues (4069)

Security Analysis not enabled

Cross-Site Scripting

Cross-Site Scripting enables an attacker to inject code into the response of a web-request that is viewed by other users. It can for example be used to bypass access controls, or even to take over other users' accounts.

File Exposure

File Exposure allows an attacker to gain access to local files that he should not be able to access. These files can for example include database credentials, or other configuration files.

File Manipulation

File Manipulation enables an attacker to write custom data to files. This potentially leads to injection of arbitrary code on the server.

Object Injection

Object Injection enables an attacker to inject an object into PHP code, and can lead to arbitrary code execution, file exposure, or file manipulation attacks.

Code Injection

Code Injection enables an attacker to execute arbitrary code on the server.

Response Splitting

Response Splitting can be used to send arbitrary responses.

File Inclusion

File Inclusion enables an attacker to inject custom files into PHP's file loading mechanism, either explicitly passed to include, or for example via PHP's auto-loading mechanism.

Command Injection

Command Injection enables an attacker to inject a shell command that is execute with the privileges of the web-server. This can be used to expose sensitive data, or gain access of your server.

SQL Injection

SQL Injection enables an attacker to execute arbitrary SQL code on your database server gaining access to user data, or manipulating user data.

XPath Injection

XPath Injection enables an attacker to modify the parts of XML document that are read. If that XML document is for example used for authentication, this can lead to further vulnerabilities similar to SQL Injection.

LDAP Injection

LDAP Injection enables an attacker to inject LDAP statements potentially granting permission to run unauthorized queries, or modify content inside the LDAP tree.

Header Injection

Other Vulnerability

This category comprises other attack vectors such as manipulating the PHP runtime, loading custom extensions, freezing the runtime, or similar.

Regex Injection

Regex Injection enables an attacker to execute arbitrary code in your PHP process.

XML Injection

XML Injection enables an attacker to read files on your local filesystem including configuration files, or can be abused to freeze your web-server process.

Variable Injection

Variable Injection enables an attacker to overwrite program variables with custom data, and can lead to further vulnerabilities.

Unfortunately, the security analysis is currently not available for your project. If you are a non-commercial open-source project, please contact support to gain access.

modules/AOS_PDF_Templates/PDF_Lib/classes/gif.php (7 issues)

Labels

Severity

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?php
///////////////////////////////////////////////////////////////////////////////////////////////////
// 2009-12-22 Adapted for mPDF 4.2
///////////////////////////////////////////////////////////////////////////////////////////////////
// GIF Util - (C) 2003 Yamasoft (S/C)
// http://www.yamasoft.com
// All Rights Reserved
// This file can be freely copied, distributed, modified, updated by anyone under the only
// condition to leave the original address (Yamasoft, http://www.yamasoft.com) and this header.
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
// 2009-12-22 Adapted INB 
// Functions calling functionname($x, $len = 0) were not working on PHP5.1.5 as pass by reference
// All edited to $len = 0; then call function.
///////////////////////////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////////////////////////

class CGIFLZW
{
	var $MAX_LZW_BITS;
	var $Fresh, $CodeSize, $SetCodeSize, $MaxCode, $MaxCodeSize, $FirstCode, $OldCode;

	var $ClearCode, $EndCode, $Next, $Vals, $Stack, $sp, $Buf, $CurBit, $LastBit, $Done, $LastByte;


	///////////////////////////////////////////////////////////////////////////

	// CONSTRUCTOR
	function CGIFLZW()
	{
		$this->MAX_LZW_BITS = 12;
		unSet($this->Next);
		unSet($this->Vals);
		unSet($this->Stack);
		unSet($this->Buf);

		$this->Next  = range(0, (1 << $this->MAX_LZW_BITS)       - 1);
		$this->Vals  = range(0, (1 << $this->MAX_LZW_BITS)       - 1);
		$this->Stack = range(0, (1 << ($this->MAX_LZW_BITS + 1)) - 1);
		$this->Buf   = range(0, 279);
	}

	///////////////////////////////////////////////////////////////////////////

	function deCompress($data, &$datLen)
	{
		$stLen  = strlen($data);
		$datLen = 0;
		$ret    = "";
		$dp = 0; 	// data pointer

		// INITIALIZATION
		$this->LZWCommandInit($data, $dp);

		while(($iIndex = $this->LZWCommand($data, $dp)) >= 0) {
			$ret .= chr($iIndex);
		}

		$datLen = $dp;

		if($iIndex != -2) {
			return false;
		}

		return $ret;
	}

	///////////////////////////////////////////////////////////////////////////
	function LZWCommandInit(&$data, &$dp)
	{
			$this->SetCodeSize = ord($data[0]);
			$dp += 1;

			$this->CodeSize    = $this->SetCodeSize + 1;
			$this->ClearCode   = 1 << $this->SetCodeSize;
			$this->EndCode     = $this->ClearCode + 1;
			$this->MaxCode     = $this->ClearCode + 2;
			$this->MaxCodeSize = $this->ClearCode << 1;

			$this->GetCodeInit($data, $dp);

			$this->Fresh = 1;
			for($i = 0; $i < $this->ClearCode; $i++) {
				$this->Next[$i] = 0;
				$this->Vals[$i] = $i;
			}

			for(; $i < (1 << $this->MAX_LZW_BITS); $i++) {
				$this->Next[$i] = 0;
				$this->Vals[$i] = 0;
			}

			$this->sp = 0;
			return 1;
	}

	function LZWCommand(&$data, &$dp)
	{
		if($this->Fresh) {
			$this->Fresh = 0;
			do {
				$this->FirstCode = $this->GetCode($data, $dp);
				$this->OldCode   = $this->FirstCode;
			}
			while($this->FirstCode == $this->ClearCode);

			return $this->FirstCode;
		}

		if($this->sp > 0) {
			$this->sp--;
			return $this->Stack[$this->sp];
		}

		while(($Code = $this->GetCode($data, $dp)) >= 0) {
			if($Code == $this->ClearCode) {
				for($i = 0; $i < $this->ClearCode; $i++) {
					$this->Next[$i] = 0;
					$this->Vals[$i] = $i;
				}

				for(; $i < (1 << $this->MAX_LZW_BITS); $i++) {
					$this->Next[$i] = 0;
					$this->Vals[$i] = 0;
				}

				$this->CodeSize    = $this->SetCodeSize + 1;
				$this->MaxCodeSize = $this->ClearCode << 1;
				$this->MaxCode     = $this->ClearCode + 2;
				$this->sp          = 0;
				$this->FirstCode   = $this->GetCode($data, $dp);
				$this->OldCode     = $this->FirstCode;

				return $this->FirstCode;
			}

			if($Code == $this->EndCode) {
				return -2;
			}

			$InCode = $Code;
			if($Code >= $this->MaxCode) {
				$this->Stack[$this->sp++] = $this->FirstCode;
				$Code = $this->OldCode;
			}

			while($Code >= $this->ClearCode) {
				$this->Stack[$this->sp++] = $this->Vals[$Code];

				if($Code == $this->Next[$Code]) // Circular table entry, big GIF Error!
					return -1;

				$Code = $this->Next[$Code];
			}

			$this->FirstCode = $this->Vals[$Code];
			$this->Stack[$this->sp++] = $this->FirstCode;

			if(($Code = $this->MaxCode) < (1 << $this->MAX_LZW_BITS)) {
				$this->Next[$Code] = $this->OldCode;
				$this->Vals[$Code] = $this->FirstCode;
				$this->MaxCode++;

				if(($this->MaxCode >= $this->MaxCodeSize) && ($this->MaxCodeSize < (1 << $this->MAX_LZW_BITS))) {
					$this->MaxCodeSize *= 2;
					$this->CodeSize++;
				}
			}

			$this->OldCode = $InCode;
			if($this->sp > 0) {
				$this->sp--;
				return $this->Stack[$this->sp];
			}
		}

		return $Code;
	}

	///////////////////////////////////////////////////////////////////////////

	function GetCodeInit(&$data, &$dp)
	{
			$this->CurBit   = 0;
			$this->LastBit  = 0;
			$this->Done     = 0;
			$this->LastByte = 2;
			return 1;
	}

	function GetCode(&$data, &$dp)
	{
		if(($this->CurBit + $this->CodeSize) >= $this->LastBit) {
			if($this->Done) {
				if($this->CurBit >= $this->LastBit) {
					// Ran off the end of my bits
					return 0;
				}
				return -1;
			}

			$this->Buf[0] = $this->Buf[$this->LastByte - 2];
			$this->Buf[1] = $this->Buf[$this->LastByte - 1];

			$Count = ord($data[$dp]);
			$dp += 1;

			if($Count) {
				for($i = 0; $i < $Count; $i++) {
					$this->Buf[2 + $i] = ord($data[$dp+$i]);
				}
				$dp += $Count;
			}
			else {
				$this->Done = 1;
			}

			$this->LastByte = 2 + $Count;
			$this->CurBit   = ($this->CurBit - $this->LastBit) + 16;
			$this->LastBit  = (2 + $Count) << 3;
		}

		$iRet = 0;
		for($i = $this->CurBit, $j = 0; $j < $this->CodeSize; $i++, $j++) {
			$iRet |= (($this->Buf[intval($i / 8)] & (1 << ($i % 8))) != 0) << $j;
		}

		$this->CurBit += $this->CodeSize;
		return $iRet;
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////

class CGIFCOLORTABLE

{
	var $m_nColors;
	var $m_arColors;

	///////////////////////////////////////////////////////////////////////////

	// CONSTRUCTOR
	function CGIFCOLORTABLE()
	{
		unSet($this->m_nColors);
		unSet($this->m_arColors);
	}

	///////////////////////////////////////////////////////////////////////////

	function load($lpData, $num)
	{
		$this->m_nColors  = 0;
		$this->m_arColors = array();

		for($i = 0; $i < $num; $i++) {
			$rgb = substr($lpData, $i * 3, 3);
			if(strlen($rgb) < 3) {
				return false;
			}

			$this->m_arColors[] = (ord($rgb[2]) << 16) + (ord($rgb[1]) << 8) + ord($rgb[0]);
			$this->m_nColors++;
		}

		return true;
	}

	///////////////////////////////////////////////////////////////////////////

	function toString()
	{
		$ret = "";

		for($i = 0; $i < $this->m_nColors; $i++) {
			$ret .=
				chr(($this->m_arColors[$i] & 0x000000FF))       . // R
				chr(($this->m_arColors[$i] & 0x0000FF00) >>  8) . // G
				chr(($this->m_arColors[$i] & 0x00FF0000) >> 16);  // B
		}

		return $ret;
	}


	///////////////////////////////////////////////////////////////////////////

	function colorIndex($rgb)
	{
		$rgb  = intval($rgb) & 0xFFFFFF;
		$r1   = ($rgb & 0x0000FF);
		$g1   = ($rgb & 0x00FF00) >>  8;
		$b1   = ($rgb & 0xFF0000) >> 16;
		$idx  = -1;

		for($i = 0; $i < $this->m_nColors; $i++) {
			$r2 = ($this->m_arColors[$i] & 0x000000FF);
			$g2 = ($this->m_arColors[$i] & 0x0000FF00) >>  8;
			$b2 = ($this->m_arColors[$i] & 0x00FF0000) >> 16;
			$d  = abs($r2 - $r1) + abs($g2 - $g1) + abs($b2 - $b1);

			if(($idx == -1) || ($d < $dif)) {
				$idx = $i;
				$dif = $d;
			}
		}

		return $idx;
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////

class CGIFFILEHEADER

{
	var $m_lpVer;
	var $m_nWidth;
	var $m_nHeight;
	var $m_bGlobalClr;
	var $m_nColorRes;
	var $m_bSorted;
	var $m_nTableSize;
	var $m_nBgColor;
	var $m_nPixelRatio;
	var $m_colorTable;

	///////////////////////////////////////////////////////////////////////////

	// CONSTRUCTOR
	function CGIFFILEHEADER()
	{
		unSet($this->m_lpVer);
		unSet($this->m_nWidth);
		unSet($this->m_nHeight);
		unSet($this->m_bGlobalClr);
		unSet($this->m_nColorRes);
		unSet($this->m_bSorted);
		unSet($this->m_nTableSize);
		unSet($this->m_nBgColor);
		unSet($this->m_nPixelRatio);
		unSet($this->m_colorTable);
	}

	///////////////////////////////////////////////////////////////////////////

	function load($lpData, &$hdrLen)
	{
		$hdrLen = 0;

		$this->m_lpVer = substr($lpData, 0, 6);
		if(($this->m_lpVer <> "GIF87a") && ($this->m_lpVer <> "GIF89a")) {
			return false;
		}

		$this->m_nWidth  = $this->w2i(substr($lpData, 6, 2));
		$this->m_nHeight = $this->w2i(substr($lpData, 8, 2));
		if(!$this->m_nWidth || !$this->m_nHeight) {
			return false;
		}

		$b = ord(substr($lpData, 10, 1));
		$this->m_bGlobalClr  = ($b & 0x80) ? true : false;
		$this->m_nColorRes   = ($b & 0x70) >> 4;
		$this->m_bSorted     = ($b & 0x08) ? true : false;
		$this->m_nTableSize  = 2 << ($b & 0x07);
		$this->m_nBgColor    = ord(substr($lpData, 11, 1));
		$this->m_nPixelRatio = ord(substr($lpData, 12, 1));
		$hdrLen = 13;

		if($this->m_bGlobalClr) {
			$this->m_colorTable = new CGIFCOLORTABLE();
			if(!$this->m_colorTable->load(substr($lpData, $hdrLen), $this->m_nTableSize)) {
				return false;
			}
			$hdrLen += 3 * $this->m_nTableSize;
		}

		return true;
	}

	///////////////////////////////////////////////////////////////////////////

	function w2i($str)
	{
		return ord(substr($str, 0, 1)) + (ord(substr($str, 1, 1)) << 8);
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////

class CGIFIMAGEHEADER

{
	var $m_nLeft;
	var $m_nTop;
	var $m_nWidth;
	var $m_nHeight;
	var $m_bLocalClr;
	var $m_bInterlace;
	var $m_bSorted;
	var $m_nTableSize;
	var $m_colorTable;

	///////////////////////////////////////////////////////////////////////////

	// CONSTRUCTOR
	function CGIFIMAGEHEADER()
	{
		unSet($this->m_nLeft);
		unSet($this->m_nTop);
		unSet($this->m_nWidth);
		unSet($this->m_nHeight);
		unSet($this->m_bLocalClr);
		unSet($this->m_bInterlace);
		unSet($this->m_bSorted);
		unSet($this->m_nTableSize);
		unSet($this->m_colorTable);
	}

	///////////////////////////////////////////////////////////////////////////

	function load($lpData, &$hdrLen)
	{
		$hdrLen = 0;

		$this->m_nLeft   = $this->w2i(substr($lpData, 0, 2));
		$this->m_nTop    = $this->w2i(substr($lpData, 2, 2));
		$this->m_nWidth  = $this->w2i(substr($lpData, 4, 2));
		$this->m_nHeight = $this->w2i(substr($lpData, 6, 2));

		if(!$this->m_nWidth || !$this->m_nHeight) {
			return false;
		}

		$b = ord($lpData{8});
		$this->m_bLocalClr  = ($b & 0x80) ? true : false;
		$this->m_bInterlace = ($b & 0x40) ? true : false;
		$this->m_bSorted    = ($b & 0x20) ? true : false;
		$this->m_nTableSize = 2 << ($b & 0x07);
		$hdrLen = 9;

		if($this->m_bLocalClr) {
			$this->m_colorTable = new CGIFCOLORTABLE();
			if(!$this->m_colorTable->load(substr($lpData, $hdrLen), $this->m_nTableSize)) {
				return false;
			}
			$hdrLen += 3 * $this->m_nTableSize;
		}

		return true;
	}

	///////////////////////////////////////////////////////////////////////////

	function w2i($str)
	{
		return ord(substr($str, 0, 1)) + (ord(substr($str, 1, 1)) << 8);
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////

class CGIFIMAGE

{
	var $m_disp;
	var $m_bUser;
	var $m_bTrans;
	var $m_nDelay;
	var $m_nTrans;
	var $m_lpComm;
	var $m_gih;
	var $m_data;
	var $m_lzw;

	///////////////////////////////////////////////////////////////////////////

	function CGIFIMAGE()
	{
		unSet($this->m_disp);
		unSet($this->m_bUser);
		unSet($this->m_bTrans);
		unSet($this->m_nDelay);
		unSet($this->m_nTrans);
		unSet($this->m_lpComm);
		unSet($this->m_data);
		$this->m_gih = new CGIFIMAGEHEADER();
		$this->m_lzw = new CGIFLZW();
	}

	///////////////////////////////////////////////////////////////////////////

	function load($data, &$datLen)
	{
		$datLen = 0;

		while(true) {
			$b = ord($data[0]);
			$data = substr($data, 1);
			$datLen++;

			switch($b) {
			case 0x21: // Extension
				$len = 0;
				if(!$this->skipExt($data, $len)) {
					return false;
				}
				$datLen += $len;
				break;

			case 0x2C: // Image
				// LOAD HEADER & COLOR TABLE
				$len = 0;
				if(!$this->m_gih->load($data, $len)) {
					return false;
				}
				$data = substr($data, $len);
				$datLen += $len;

				// ALLOC BUFFER
				$len = 0;

				if(!($this->m_data = $this->m_lzw->deCompress($data, $len))) {
					return false;
				}

				$data = substr($data, $len);
				$datLen += $len;

				if($this->m_gih->m_bInterlace) {
					$this->deInterlace();
				}

				return true;

			case 0x3B: // EOF
			default:
				return false;
			}
		}
		return false;
	}

	///////////////////////////////////////////////////////////////////////////

	function skipExt(&$data, &$extLen)
	{
		$extLen = 0;

		$b = ord($data[0]);
		$data = substr($data, 1);
		$extLen++;

		switch($b) {
		case 0xF9: // Graphic Control
			$b = ord($data[1]);
			$this->m_disp   = ($b & 0x1C) >> 2;
			$this->m_bUser  = ($b & 0x02) ? true : false;
			$this->m_bTrans = ($b & 0x01) ? true : false;
			$this->m_nDelay = $this->w2i(substr($data, 2, 2));
			$this->m_nTrans = ord($data[4]);
			break;

		case 0xFE: // Comment
			$this->m_lpComm = substr($data, 1, ord($data[0]));
			break;

		case 0x01: // Plain text
			break;

		case 0xFF: // Application
			break;
		}

		// SKIP DEFAULT AS DEFS MAY CHANGE
		$b = ord($data[0]);
		$data = substr($data, 1);
		$extLen++;
		while($b > 0) {
			$data = substr($data, $b);
			$extLen += $b;
			$b    = ord($data[0]);
			$data = substr($data, 1);
			$extLen++;
		}
		return true;
	}

	///////////////////////////////////////////////////////////////////////////

	function w2i($str)
	{
		return ord(substr($str, 0, 1)) + (ord(substr($str, 1, 1)) << 8);
	}

	///////////////////////////////////////////////////////////////////////////

	function deInterlace()
	{
		$data = $this->m_data;

		for($i = 0; $i < 4; $i++) {
			switch($i) {
			case 0:
				$s = 8;
				$y = 0;
				break;

			case 1:
				$s = 8;
				$y = 4;
				break;

			case 2:
				$s = 4;
				$y = 2;
				break;

			case 3:
				$s = 2;
				$y = 1;
				break;
			}

			for(; $y < $this->m_gih->m_nHeight; $y += $s) {
				$lne = substr($this->m_data, 0, $this->m_gih->m_nWidth);
				$this->m_data = substr($this->m_data, $this->m_gih->m_nWidth);

				$data =
					substr($data, 0, $y * $this->m_gih->m_nWidth) .
					$lne .
					substr($data, ($y + 1) * $this->m_gih->m_nWidth);
			}
		}

		$this->m_data = $data;
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////

class CGIF

{
	var $m_gfh;
	var $m_lpData;
	var $m_img;
	var $m_bLoaded;

	///////////////////////////////////////////////////////////////////////////

	// CONSTRUCTOR
	function CGIF()
	{
		$this->m_gfh     = new CGIFFILEHEADER();
		$this->m_img     = new CGIFIMAGE();
		$this->m_lpData  = "";
		$this->m_bLoaded = false;
	}

	///////////////////////////////////////////////////////////////////////////
	function ClearData() {
		$this->m_lpData = '';
		unSet($this->m_img->m_data);
		unSet($this->m_img->m_lzw->Next);
		unSet($this->m_img->m_lzw->Vals);
		unSet($this->m_img->m_lzw->Stack);
		unSet($this->m_img->m_lzw->Buf);
	}

	function loadFile(&$data, $iIndex)
	{
		if($iIndex < 0) {
			return false;
		}
		$this->m_lpData = $data;

		// GET FILE HEADER
		$len = 0;
		if(!$this->m_gfh->load($this->m_lpData, $len)) {
			return false;
		}

		$this->m_lpData = substr($this->m_lpData, $len);

		do {
			$imgLen = 0;
			if(!$this->m_img->load($this->m_lpData, $imgLen)) {
				return false;
			}
			$this->m_lpData = substr($this->m_lpData, $imgLen);
		}
		while($iIndex-- > 0);

		$this->m_bLoaded = true;
		return true;
	}

}

///////////////////////////////////////////////////////////////////////////////////////////////////

?>

1			<?php
2			///////////////////////////////////////////////////////////////////////////////////////////////////
3			// 2009-12-22 Adapted for mPDF 4.2
4			///////////////////////////////////////////////////////////////////////////////////////////////////
5			// GIF Util - (C) 2003 Yamasoft (S/C)
6			// http://www.yamasoft.com
7			// All Rights Reserved
8			// This file can be freely copied, distributed, modified, updated by anyone under the only
9			// condition to leave the original address (Yamasoft, http://www.yamasoft.com) and this header.
10			///////////////////////////////////////////////////////////////////////////////////////////////////
11			///////////////////////////////////////////////////////////////////////////////////////////////////
12			// 2009-12-22 Adapted INB
13			// Functions calling functionname($x, $len = 0) were not working on PHP5.1.5 as pass by reference
14			// All edited to $len = 0; then call function.
15			///////////////////////////////////////////////////////////////////////////////////////////////////
16
17
18			///////////////////////////////////////////////////////////////////////////////////////////////////
19
20			class CGIFLZW
21			{
22			var $MAX_LZW_BITS;
23			var $Fresh, $CodeSize, $SetCodeSize, $MaxCode, $MaxCodeSize, $FirstCode, $OldCode;
			0 ignored issues – show Coding Style introduced 2016-03-07 18:00 UTC by Report Bug Copy Issue Report Show Similar Issues like this It is generally advisable to only define one property per statement. Only declaring a single property per statement allows you to later on add doc comments more easily. It is also recommended by PSR2, so it is a common style that many people expect. Loading history...
24			var $ClearCode, $EndCode, $Next, $Vals, $Stack, $sp, $Buf, $CurBit, $LastBit, $Done, $LastByte;
			0 ignored issues – show Coding Style introduced 2016-03-07 18:00 UTC by Report Bug Copy Issue Report Show Similar Issues like this It is generally advisable to only define one property per statement. Only declaring a single property per statement allows you to later on add doc comments more easily. It is also recommended by PSR2, so it is a common style that many people expect. Loading history...
25
26			///////////////////////////////////////////////////////////////////////////
27
28			// CONSTRUCTOR
29			function CGIFLZW()
30			{
31			$this->MAX_LZW_BITS = 12;
32			unSet($this->Next);
33			unSet($this->Vals);
34			unSet($this->Stack);
35			unSet($this->Buf);
36
37			$this->Next = range(0, (1 << $this->MAX_LZW_BITS) - 1);
38			$this->Vals = range(0, (1 << $this->MAX_LZW_BITS) - 1);
39			$this->Stack = range(0, (1 << ($this->MAX_LZW_BITS + 1)) - 1);
40			$this->Buf = range(0, 279);
41			}
42
43			///////////////////////////////////////////////////////////////////////////
44
45			function deCompress($data, &$datLen)
46			{
47			$stLen = strlen($data);
48			$datLen = 0;
49			$ret = "";
50			$dp = 0; // data pointer
51
52			// INITIALIZATION
53			$this->LZWCommandInit($data, $dp);
54
55			while(($iIndex = $this->LZWCommand($data, $dp)) >= 0) {
56			$ret .= chr($iIndex);
57			}
58
59			$datLen = $dp;
60
61			if($iIndex != -2) {
62			return false;
63			}
64
65			return $ret;
66			}
67
68			///////////////////////////////////////////////////////////////////////////
69			function LZWCommandInit(&$data, &$dp)
70			{
71			$this->SetCodeSize = ord($data[0]);
72			$dp += 1;
73
74			$this->CodeSize = $this->SetCodeSize + 1;
75			$this->ClearCode = 1 << $this->SetCodeSize;
76			$this->EndCode = $this->ClearCode + 1;
77			$this->MaxCode = $this->ClearCode + 2;
78			$this->MaxCodeSize = $this->ClearCode << 1;
79
80			$this->GetCodeInit($data, $dp);
81
82			$this->Fresh = 1;
83			for($i = 0; $i < $this->ClearCode; $i++) {
84			$this->Next[$i] = 0;
85			$this->Vals[$i] = $i;
86			}
87
88			for(; $i < (1 << $this->MAX_LZW_BITS); $i++) {
89			$this->Next[$i] = 0;
90			$this->Vals[$i] = 0;
91			}
92
93			$this->sp = 0;
94			return 1;
95			}
96
97			function LZWCommand(&$data, &$dp)
98			{
99			if($this->Fresh) {
100			$this->Fresh = 0;
101			do {
102			$this->FirstCode = $this->GetCode($data, $dp);
103			$this->OldCode = $this->FirstCode;
104			}
105			while($this->FirstCode == $this->ClearCode);
106
107			return $this->FirstCode;
108			}
109
110			if($this->sp > 0) {
111			$this->sp--;
112			return $this->Stack[$this->sp];
113			}
114
115			while(($Code = $this->GetCode($data, $dp)) >= 0) {
116			if($Code == $this->ClearCode) {
117			for($i = 0; $i < $this->ClearCode; $i++) {
118			$this->Next[$i] = 0;
119			$this->Vals[$i] = $i;
120			}
121
122			for(; $i < (1 << $this->MAX_LZW_BITS); $i++) {
123			$this->Next[$i] = 0;
124			$this->Vals[$i] = 0;
125			}
126
127			$this->CodeSize = $this->SetCodeSize + 1;
128			$this->MaxCodeSize = $this->ClearCode << 1;
129			$this->MaxCode = $this->ClearCode + 2;
130			$this->sp = 0;
131			$this->FirstCode = $this->GetCode($data, $dp);
132			$this->OldCode = $this->FirstCode;
133
134			return $this->FirstCode;
135			}
136
137			if($Code == $this->EndCode) {
138			return -2;
139			}
140
141			$InCode = $Code;
142			if($Code >= $this->MaxCode) {
143			$this->Stack[$this->sp++] = $this->FirstCode;
144			$Code = $this->OldCode;
145			}
146
147			while($Code >= $this->ClearCode) {
148			$this->Stack[$this->sp++] = $this->Vals[$Code];
149
150			if($Code == $this->Next[$Code]) // Circular table entry, big GIF Error!
151			return -1;
152
153			$Code = $this->Next[$Code];
154			}
155
156			$this->FirstCode = $this->Vals[$Code];
157			$this->Stack[$this->sp++] = $this->FirstCode;
158
159			if(($Code = $this->MaxCode) < (1 << $this->MAX_LZW_BITS)) {
160			$this->Next[$Code] = $this->OldCode;
161			$this->Vals[$Code] = $this->FirstCode;
162			$this->MaxCode++;
163
164			if(($this->MaxCode >= $this->MaxCodeSize) && ($this->MaxCodeSize < (1 << $this->MAX_LZW_BITS))) {
165			$this->MaxCodeSize *= 2;
166			$this->CodeSize++;
167			}
168			}
169
170			$this->OldCode = $InCode;
171			if($this->sp > 0) {
172			$this->sp--;
173			return $this->Stack[$this->sp];
174			}
175			}
176
177			return $Code;
178			}
179
180			///////////////////////////////////////////////////////////////////////////
181
182			function GetCodeInit(&$data, &$dp)
183			{
184			$this->CurBit = 0;
185			$this->LastBit = 0;
186			$this->Done = 0;
187			$this->LastByte = 2;
188			return 1;
189			}
190
191			function GetCode(&$data, &$dp)
192			{
193			if(($this->CurBit + $this->CodeSize) >= $this->LastBit) {
194			if($this->Done) {
195			if($this->CurBit >= $this->LastBit) {
196			// Ran off the end of my bits
197			return 0;
198			}
199			return -1;
200			}
201
202			$this->Buf[0] = $this->Buf[$this->LastByte - 2];
203			$this->Buf[1] = $this->Buf[$this->LastByte - 1];
204
205			$Count = ord($data[$dp]);
206			$dp += 1;
207
208			if($Count) {
209			for($i = 0; $i < $Count; $i++) {
210			$this->Buf[2 + $i] = ord($data[$dp+$i]);
211			}
212			$dp += $Count;
213			}
214			else {
215			$this->Done = 1;
216			}
217
218			$this->LastByte = 2 + $Count;
219			$this->CurBit = ($this->CurBit - $this->LastBit) + 16;
220			$this->LastBit = (2 + $Count) << 3;
221			}
222
223			$iRet = 0;
224			for($i = $this->CurBit, $j = 0; $j < $this->CodeSize; $i++, $j++) {
225			$iRet \|= (($this->Buf[intval($i / 8)] & (1 << ($i % 8))) != 0) << $j;
226			}
227
228			$this->CurBit += $this->CodeSize;
229			return $iRet;
230			}
231			}
232
233			///////////////////////////////////////////////////////////////////////////////////////////////////
234
235			class CGIFCOLORTABLE
			0 ignored issues – show Coding Style Compatibility introduced 2016-03-07 18:00 UTC by Report Bug Copy Issue Report Show Similar Issues like this PSR1 recommends that each class should be in its own file to aid autoloaders. Having each class in a dedicated file usually plays nice with PSR autoloaders and is therefore a well established practice. If you use other autoloaders, you might not want to follow this rule. Loading history...
236			{
237			var $m_nColors;
238			var $m_arColors;
239
240			///////////////////////////////////////////////////////////////////////////
241
242			// CONSTRUCTOR
243			function CGIFCOLORTABLE()
244			{
245			unSet($this->m_nColors);
246			unSet($this->m_arColors);
247			}
248
249			///////////////////////////////////////////////////////////////////////////
250
251			function load($lpData, $num)
252			{
253			$this->m_nColors = 0;
254			$this->m_arColors = array();
255
256			for($i = 0; $i < $num; $i++) {
257			$rgb = substr($lpData, $i * 3, 3);
258			if(strlen($rgb) < 3) {
259			return false;
260			}
261
262			$this->m_arColors[] = (ord($rgb[2]) << 16) + (ord($rgb[1]) << 8) + ord($rgb[0]);
263			$this->m_nColors++;
264			}
265
266			return true;
267			}
268
269			///////////////////////////////////////////////////////////////////////////
270
271			function toString()
272			{
273			$ret = "";
274
275			for($i = 0; $i < $this->m_nColors; $i++) {
276			$ret .=
277			chr(($this->m_arColors[$i] & 0x000000FF)) . // R
278			chr(($this->m_arColors[$i] & 0x0000FF00) >> 8) . // G
279			chr(($this->m_arColors[$i] & 0x00FF0000) >> 16); // B
280			}
281
282			return $ret;
283			}
284
285
286			///////////////////////////////////////////////////////////////////////////
287
288			function colorIndex($rgb)
289			{
290			$rgb = intval($rgb) & 0xFFFFFF;
291			$r1 = ($rgb & 0x0000FF);
292			$g1 = ($rgb & 0x00FF00) >> 8;
293			$b1 = ($rgb & 0xFF0000) >> 16;
294			$idx = -1;
295
296			for($i = 0; $i < $this->m_nColors; $i++) {
297			$r2 = ($this->m_arColors[$i] & 0x000000FF);
298			$g2 = ($this->m_arColors[$i] & 0x0000FF00) >> 8;
299			$b2 = ($this->m_arColors[$i] & 0x00FF0000) >> 16;
300			$d = abs($r2 - $r1) + abs($g2 - $g1) + abs($b2 - $b1);
301
302			if(($idx == -1) \|\| ($d < $dif)) {
303			$idx = $i;
304			$dif = $d;
305			}
306			}
307
308			return $idx;
309			}
310			}
311
312			///////////////////////////////////////////////////////////////////////////////////////////////////
313
314			class CGIFFILEHEADER
			0 ignored issues – show Coding Style Compatibility introduced 2016-03-07 18:00 UTC by Report Bug Copy Issue Report Show Similar Issues like this PSR1 recommends that each class should be in its own file to aid autoloaders. Having each class in a dedicated file usually plays nice with PSR autoloaders and is therefore a well established practice. If you use other autoloaders, you might not want to follow this rule. Loading history...
315			{
316			var $m_lpVer;
317			var $m_nWidth;
318			var $m_nHeight;
319			var $m_bGlobalClr;
320			var $m_nColorRes;
321			var $m_bSorted;
322			var $m_nTableSize;
323			var $m_nBgColor;
324			var $m_nPixelRatio;
325			var $m_colorTable;
326
327			///////////////////////////////////////////////////////////////////////////
328
329			// CONSTRUCTOR
330			function CGIFFILEHEADER()
331			{
332			unSet($this->m_lpVer);
333			unSet($this->m_nWidth);
334			unSet($this->m_nHeight);
335			unSet($this->m_bGlobalClr);
336			unSet($this->m_nColorRes);
337			unSet($this->m_bSorted);
338			unSet($this->m_nTableSize);
339			unSet($this->m_nBgColor);
340			unSet($this->m_nPixelRatio);
341			unSet($this->m_colorTable);
342			}
343
344			///////////////////////////////////////////////////////////////////////////
345
346			function load($lpData, &$hdrLen)
347			{
348			$hdrLen = 0;
349
350			$this->m_lpVer = substr($lpData, 0, 6);
351			if(($this->m_lpVer <> "GIF87a") && ($this->m_lpVer <> "GIF89a")) {
352			return false;
353			}
354
355			$this->m_nWidth = $this->w2i(substr($lpData, 6, 2));
356			$this->m_nHeight = $this->w2i(substr($lpData, 8, 2));
357			if(!$this->m_nWidth \|\| !$this->m_nHeight) {
358			return false;
359			}
360
361			$b = ord(substr($lpData, 10, 1));
362			$this->m_bGlobalClr = ($b & 0x80) ? true : false;
363			$this->m_nColorRes = ($b & 0x70) >> 4;
364			$this->m_bSorted = ($b & 0x08) ? true : false;
365			$this->m_nTableSize = 2 << ($b & 0x07);
366			$this->m_nBgColor = ord(substr($lpData, 11, 1));
367			$this->m_nPixelRatio = ord(substr($lpData, 12, 1));
368			$hdrLen = 13;
369
370			if($this->m_bGlobalClr) {
371			$this->m_colorTable = new CGIFCOLORTABLE();
372			if(!$this->m_colorTable->load(substr($lpData, $hdrLen), $this->m_nTableSize)) {
373			return false;
374			}
375			$hdrLen += 3 * $this->m_nTableSize;
376			}
377
378			return true;
379			}
380
381			///////////////////////////////////////////////////////////////////////////
382
383			function w2i($str)
384			{
385			return ord(substr($str, 0, 1)) + (ord(substr($str, 1, 1)) << 8);
386			}
387			}
388
389			///////////////////////////////////////////////////////////////////////////////////////////////////
390
391			class CGIFIMAGEHEADER
			0 ignored issues – show Coding Style Compatibility introduced 2016-03-07 18:00 UTC by Report Bug Copy Issue Report Show Similar Issues like this PSR1 recommends that each class should be in its own file to aid autoloaders. Having each class in a dedicated file usually plays nice with PSR autoloaders and is therefore a well established practice. If you use other autoloaders, you might not want to follow this rule. Loading history...
392			{
393			var $m_nLeft;
394			var $m_nTop;
395			var $m_nWidth;
396			var $m_nHeight;
397			var $m_bLocalClr;
398			var $m_bInterlace;
399			var $m_bSorted;
400			var $m_nTableSize;
401			var $m_colorTable;
402
403			///////////////////////////////////////////////////////////////////////////
404
405			// CONSTRUCTOR
406			function CGIFIMAGEHEADER()
407			{
408			unSet($this->m_nLeft);
409			unSet($this->m_nTop);
410			unSet($this->m_nWidth);
411			unSet($this->m_nHeight);
412			unSet($this->m_bLocalClr);
413			unSet($this->m_bInterlace);
414			unSet($this->m_bSorted);
415			unSet($this->m_nTableSize);
416			unSet($this->m_colorTable);
417			}
418
419			///////////////////////////////////////////////////////////////////////////
420
421			function load($lpData, &$hdrLen)
422			{
423			$hdrLen = 0;
424
425			$this->m_nLeft = $this->w2i(substr($lpData, 0, 2));
426			$this->m_nTop = $this->w2i(substr($lpData, 2, 2));
427			$this->m_nWidth = $this->w2i(substr($lpData, 4, 2));
428			$this->m_nHeight = $this->w2i(substr($lpData, 6, 2));
429
430			if(!$this->m_nWidth \|\| !$this->m_nHeight) {
431			return false;
432			}
433
434			$b = ord($lpData{8});
435			$this->m_bLocalClr = ($b & 0x80) ? true : false;
436			$this->m_bInterlace = ($b & 0x40) ? true : false;
437			$this->m_bSorted = ($b & 0x20) ? true : false;
438			$this->m_nTableSize = 2 << ($b & 0x07);
439			$hdrLen = 9;
440
441			if($this->m_bLocalClr) {
442			$this->m_colorTable = new CGIFCOLORTABLE();
443			if(!$this->m_colorTable->load(substr($lpData, $hdrLen), $this->m_nTableSize)) {
444			return false;
445			}
446			$hdrLen += 3 * $this->m_nTableSize;
447			}
448
449			return true;
450			}
451
452			///////////////////////////////////////////////////////////////////////////
453
454			function w2i($str)
455			{
456			return ord(substr($str, 0, 1)) + (ord(substr($str, 1, 1)) << 8);
457			}
458			}
459
460			///////////////////////////////////////////////////////////////////////////////////////////////////
461
462			class CGIFIMAGE
			0 ignored issues – show Coding Style Compatibility introduced 2016-03-07 18:00 UTC by Report Bug Copy Issue Report Show Similar Issues like this PSR1 recommends that each class should be in its own file to aid autoloaders. Having each class in a dedicated file usually plays nice with PSR autoloaders and is therefore a well established practice. If you use other autoloaders, you might not want to follow this rule. Loading history...
463			{
464			var $m_disp;
465			var $m_bUser;
466			var $m_bTrans;
467			var $m_nDelay;
468			var $m_nTrans;
469			var $m_lpComm;
470			var $m_gih;
471			var $m_data;
472			var $m_lzw;
473
474			///////////////////////////////////////////////////////////////////////////
475
476			function CGIFIMAGE()
477			{
478			unSet($this->m_disp);
479			unSet($this->m_bUser);
480			unSet($this->m_bTrans);
481			unSet($this->m_nDelay);
482			unSet($this->m_nTrans);
483			unSet($this->m_lpComm);
484			unSet($this->m_data);
485			$this->m_gih = new CGIFIMAGEHEADER();
486			$this->m_lzw = new CGIFLZW();
487			}
488
489			///////////////////////////////////////////////////////////////////////////
490
491			function load($data, &$datLen)
492			{
493			$datLen = 0;
494
495			while(true) {
496			$b = ord($data[0]);
497			$data = substr($data, 1);
498			$datLen++;
499
500			switch($b) {
501			case 0x21: // Extension
502			$len = 0;
503			if(!$this->skipExt($data, $len)) {
504			return false;
505			}
506			$datLen += $len;
507			break;
508
509			case 0x2C: // Image
510			// LOAD HEADER & COLOR TABLE
511			$len = 0;
512			if(!$this->m_gih->load($data, $len)) {
513			return false;
514			}
515			$data = substr($data, $len);
516			$datLen += $len;
517
518			// ALLOC BUFFER
519			$len = 0;
520
521			if(!($this->m_data = $this->m_lzw->deCompress($data, $len))) {
522			return false;
523			}
524
525			$data = substr($data, $len);
526			$datLen += $len;
527
528			if($this->m_gih->m_bInterlace) {
529			$this->deInterlace();
530			}
531
532			return true;
533
534			case 0x3B: // EOF
535			default:
536			return false;
537			}
538			}
539			return false;
540			}
541
542			///////////////////////////////////////////////////////////////////////////
543
544			function skipExt(&$data, &$extLen)
545			{
546			$extLen = 0;
547
548			$b = ord($data[0]);
549			$data = substr($data, 1);
550			$extLen++;
551
552			switch($b) {
553			case 0xF9: // Graphic Control
554			$b = ord($data[1]);
555			$this->m_disp = ($b & 0x1C) >> 2;
556			$this->m_bUser = ($b & 0x02) ? true : false;
557			$this->m_bTrans = ($b & 0x01) ? true : false;
558			$this->m_nDelay = $this->w2i(substr($data, 2, 2));
559			$this->m_nTrans = ord($data[4]);
560			break;
561
562			case 0xFE: // Comment
563			$this->m_lpComm = substr($data, 1, ord($data[0]));
564			break;
565
566			case 0x01: // Plain text
567			break;
568
569			case 0xFF: // Application
570			break;
571			}
572
573			// SKIP DEFAULT AS DEFS MAY CHANGE
574			$b = ord($data[0]);
575			$data = substr($data, 1);
576			$extLen++;
577			while($b > 0) {
578			$data = substr($data, $b);
579			$extLen += $b;
580			$b = ord($data[0]);
581			$data = substr($data, 1);
582			$extLen++;
583			}
584			return true;
585			}
586
587			///////////////////////////////////////////////////////////////////////////
588
589			function w2i($str)
590			{
591			return ord(substr($str, 0, 1)) + (ord(substr($str, 1, 1)) << 8);
592			}
593
594			///////////////////////////////////////////////////////////////////////////
595
596			function deInterlace()
597			{
598			$data = $this->m_data;
599
600			for($i = 0; $i < 4; $i++) {
601			switch($i) {
602			case 0:
603			$s = 8;
604			$y = 0;
605			break;
606
607			case 1:
608			$s = 8;
609			$y = 4;
610			break;
611
612			case 2:
613			$s = 4;
614			$y = 2;
615			break;
616
617			case 3:
618			$s = 2;
619			$y = 1;
620			break;
621			}
622
623			for(; $y < $this->m_gih->m_nHeight; $y += $s) {
624			$lne = substr($this->m_data, 0, $this->m_gih->m_nWidth);
625			$this->m_data = substr($this->m_data, $this->m_gih->m_nWidth);
626
627			$data =
628			substr($data, 0, $y * $this->m_gih->m_nWidth) .
629			$lne .
630			substr($data, ($y + 1) * $this->m_gih->m_nWidth);
631			}
632			}
633
634			$this->m_data = $data;
635			}
636			}
637
638			///////////////////////////////////////////////////////////////////////////////////////////////////
639
640			class CGIF
			0 ignored issues – show Coding Style Compatibility introduced 2016-03-07 18:00 UTC by Report Bug Copy Issue Report Show Similar Issues like this PSR1 recommends that each class should be in its own file to aid autoloaders. Having each class in a dedicated file usually plays nice with PSR autoloaders and is therefore a well established practice. If you use other autoloaders, you might not want to follow this rule. Loading history...
641			{
642			var $m_gfh;
643			var $m_lpData;
644			var $m_img;
645			var $m_bLoaded;
646
647			///////////////////////////////////////////////////////////////////////////
648
649			// CONSTRUCTOR
650			function CGIF()
651			{
652			$this->m_gfh = new CGIFFILEHEADER();
653			$this->m_img = new CGIFIMAGE();
654			$this->m_lpData = "";
655			$this->m_bLoaded = false;
656			}
657
658			///////////////////////////////////////////////////////////////////////////
659			function ClearData() {
660			$this->m_lpData = '';
661			unSet($this->m_img->m_data);
662			unSet($this->m_img->m_lzw->Next);
663			unSet($this->m_img->m_lzw->Vals);
664			unSet($this->m_img->m_lzw->Stack);
665			unSet($this->m_img->m_lzw->Buf);
666			}
667
668			function loadFile(&$data, $iIndex)
669			{
670			if($iIndex < 0) {
671			return false;
672			}
673			$this->m_lpData = $data;
674
675			// GET FILE HEADER
676			$len = 0;
677			if(!$this->m_gfh->load($this->m_lpData, $len)) {
678			return false;
679			}
680
681			$this->m_lpData = substr($this->m_lpData, $len);
682
683			do {
684			$imgLen = 0;
685			if(!$this->m_img->load($this->m_lpData, $imgLen)) {
686			return false;
687			}
688			$this->m_lpData = substr($this->m_lpData, $imgLen);
689			}
690			while($iIndex-- > 0);
691
692			$this->m_bLoaded = true;
693			return true;
694			}
695
696			}
697
698			///////////////////////////////////////////////////////////////////////////////////////////////////
699
700			?>

adamjakab / SuiteCRM

Issues (4069)

Security Analysis not enabled

modules/AOS_PDF_Templates/PDF_Lib/classes/gif.php (7 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like