hardsploit_gui 2.0 → 2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 030b1c7ca30ebc3603c750b93147ad1a7b2d407f
-  data.tar.gz: 7595d0cc31b7a3fab274252985577064e581ebb6
+  metadata.gz: b79bd73280ea7c66e0edaf61103cb36b18db5a96
+  data.tar.gz: ebf960a577ff3f24cdaec29553c1255ceb6fc93d
 SHA512:
-  metadata.gz: 058934a2bef35c81153d96ce0b21d12069c6abe32cbb5f32166f9a3777d865b5761cea0dcaaca56bc0477bba4fb047875d3f2929fe7b23388e247c7fa427f2ea
-  data.tar.gz: 9586a89c0be2be5df3e39754711563c3885e4506c7bf8d7f4f68ed2005988fe42c511555c73c4aa7842ff2ee4b68a98fe01569cebd317b613255d814dbf27530
+  metadata.gz: 07f8c87b9042222abe141b2db89ae4719f4c2a2776b0a0599ad39f401ad60c51eb6de16415bc1304ca5d1b499d6aa44912f6af98757c7a8a44a13fa18c5a9d35
+  data.tar.gz: ba298ca43356b5939f485b206223bc9699875edc447f3d5db902cdfd5a457874bc4735f95e404d2ff3f3c75931d16b9b2425c8cefb96c32a0b238afbfb8cb677

data/lib/HardsploitAPI/HardsploitAPI.rb

@@ -15,6 +15,7 @@ require_relative 'HardsploitAPI_I2C'
 require_relative 'HardsploitAPI_SPI'
 require_relative 'HardsploitAPI_TEST_INTERACT'
 require_relative 'SWD/HardsploitAPI_SWD'
+require_relative 'HardsploitAPI_ERROR'
 
 require 'thread'
 
@@ -33,10 +34,10 @@ public
 	  # * +callbackError+:: callback not used for the moment and transform into progressCallback soon
 		# * +callbackSpeedOfTransfert+:: callback to get back +information about speed+
 	def initialize(*args)
-		parametters = HardsploitAPI.checkParametters(["callbackData","callbackInfo","callbackError","callbackSpeedOfTransfert"],args)
+		parametters = HardsploitAPI.checkParametters(["callbackData","callbackInfo","callbackProgress","callbackSpeedOfTransfert"],args)
 		@callbackData = parametters[:callbackData]
 		@callbackInfo = parametters[:callbackInfo]
-		@callbackError = parametters[:callbackError]
+		@callbackProgress = parametters[:callbackProgress]
 		@callbackSpeedOfTransfert = parametters[:callbackSpeedOfTransfert]
 
 		@packet_send = Array.new
@@ -88,8 +89,6 @@ public
 
 	end
 
-
-
 	def self.reverseBit(byte)
 		return byte.to_s(2).rjust(8, "0").reverse.to_i(2)
 	end
@@ -117,8 +116,8 @@ public
 		return params
 	end
 
-	def consoleError(value)
-		@callbackError.call(value)
+	def consoleProgress(percent:,startTime:,endTime:)
+		@callbackProgress.call(percent:percent,startTime:startTime,endTime:endTime)
 	end
 	def consoleData(value)
 		@callbackData.call(value)

data/lib/HardsploitAPI/HardsploitAPI_CONSTANT.rb

@@ -126,7 +126,7 @@ def signalHelpingWiring(*args)
 			USB_TRAME_SIZE = 8191
 	end
 	module VERSION
-		API   = "1.1.0"
+		API   = "1.2.1"
 	end
 	module USB_STATE
 		public

data/lib/HardsploitAPI/HardsploitAPI_ERROR.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/ruby
+#===================================================
+#  Hardsploit API - By Opale Security
+#  www.opale-security.com || www.hardsploit.io
+#  License: GNU General Public License v3
+#  License URI: http://www.gnu.org/licenses/gpl.txt
+#===================================================
+
+class HardsploitAPI
+	module Error
+    class Standard < StandardError; end
+
+    class FileIssue < Standard
+			def initialize(msg="Issue with file")
+					super(msg)
+			end
+    end
+
+
+    class I2CWrongSpeed < Standard
+			def initialize(msg="Uknown speed")
+					super(msg)
+			end
+		end
+
+		class WrongStartAddress < Standard
+			def initialize(msg="Start address can't be negative and not more than size max - 1")
+					super(msg)
+			end
+		end
+
+		class SpiError < Standard
+			def initialize(msg="Error during SPI processing")
+					super(msg)
+			end
+		end
+	end
+end

data/lib/HardsploitAPI/HardsploitAPI_FIRMWARE.rb

@@ -72,7 +72,7 @@ protected
 					p "TIMEOUT_RECEIVE"
 					return HardsploitAPI::USB_STATE::TIMEOUT_RECEIVE
 				else
-					t2 = Time.now 
+					t2 = Time.now
 					delta = t2 - t1
 					consoleSpeed "Firmware erased in #{delta.round(4)} sec\n\n"
 			end
@@ -244,7 +244,7 @@ protected
 						received_data = received_data.drop(7)
 
 						#reverse byte
-						received_data = received_data.collect {|x| self.reverseBit(x) }
+						received_data = received_data.collect {|x| HardsploitAPI.reverseBit(x) }
 
 					    readFirmware.push *received_data
 
@@ -293,7 +293,7 @@ protected
 						received_data = received_data.drop(7)
 
 						#reverse byte
-						received_data = received_data.collect {|x| self.reverseBit(x) }
+						received_data = received_data.collect {|x| HardsploitAPI.reverseBit(x) }
 				    readFirmware.push *received_data
 
 				    consoleSpeed "READ AT 100%\n"

data/lib/HardsploitAPI/HardsploitAPI_I2C.rb

@@ -122,7 +122,7 @@ public
 		if numberOfByteAddress <= 0 then
 			raise TypeError, "There is an issue with calculating of number of byte needed"
 		end
-
+		startTime = Time.now
 		packet_size = 2000 - numberOfByteAddress - 1
 		number_complet_packet = ( (stopAddress-startAddress+1) / packet_size).floor
 		size_last_packet =  (stopAddress-startAddress+1) % packet_size
@@ -130,7 +130,6 @@ public
 		#SEND the first complete trame
 		for i in 0..number_complet_packet-1 do
 			packet = generate_i2c_read_command i2cBaseAddress,numberOfByteAddress+startAddress,i*packet_size,packet_size
-
 			temp = i2c_Interact(speed,packet)
 			case temp
 				when HardsploitAPI::USB_STATE::PACKET_IS_TOO_LARGE
@@ -145,8 +144,11 @@ public
 					#Remove header, result of read command and numberOfByte Address too
 					consoleData ( process_dump_i2c_result( temp ) )
 			end
+
+			consoleProgress(percent:100*(i+1)/(number_complet_packet+ (size_last_packet.zero? ? 0 : 1)),startTime:startTime,endTime:Time.new)
 		end
 
+	if(size_last_packet > 0 )then
 		packet = generate_i2c_read_command i2cBaseAddress,numberOfByteAddress,number_complet_packet*packet_size+startAddress,size_last_packet
 		temp = i2c_Interact(speed,packet)
 		case temp
@@ -161,10 +163,117 @@ public
 			else
 				#Remove header, result of read command and numberOfByte Address too
 				consoleData ( process_dump_i2c_result ( temp ) )
+		 end
+		 consoleProgress(percent:100,startTime:startTime,endTime:Time.new)
+	end
+
+	delta = Time.now - startTime
+	consoleSpeed "Write in #{delta.round(4)} sec"
+end
+
+#For the moment only with EEPROM (not need to erase or activate write)
+	def i2c_Generic_Import (*args)
+		parametters = HardsploitAPI.checkParametters(["speed","i2cBaseAddress","startAddress","pageSize","memorySize","dataFile","writePageLatency"],args)
+		speed = parametters[:speed]
+		i2cBaseAddress = parametters[:i2cBaseAddress]
+		startAddress = parametters[:startAddress]
+		pageSize = parametters[:pageSize]
+		memorySize = parametters[:memorySize]
+		dataFile = parametters[:dataFile]
+		writePageLatency = parametters[:writePageLatency]
+
+		startTime = Time.now
+		begin
+			file =	File.open(dataFile, 'rb')
+			sizeFile = file.size
+		rescue Exception => e
+			raise Error::FileIssue, e.message
+		end
+
+		if ((startAddress < 0)  or (startAddress > memorySize-1)) then
+			raise Error::WrongStartAddress
+		end
+
+		if ((pageSize <= 0) and (pageSize >1024)) then
+			raise TypeError, "pageSize need to be greater than 0 and less than 1024"
+		end
+
+		numberOfByteAddress = (((Math.log(memorySize-1,2)).floor + 1) / 8.0).ceil
+		if numberOfByteAddress > 4 then
+			raise TypeError, "Size max must be less than 2^32 about 4Gb"
+		end
+
+		if numberOfByteAddress <= 0 then
+			raise TypeError, "There is an issue with calculating of number of byte needed"
 		end
+
+		packet_size = pageSize
+		number_complet_packet = (sizeFile / packet_size).floor
+		size_last_packet =  sizeFile % packet_size
+
+		#SEND the first complete trame
+		for i in 0..number_complet_packet-1 do
+			packet = generate_i2c_write_command i2cBaseAddress,numberOfByteAddress,i*packet_size,file.read(packet_size).unpack("C*")
+			temp = i2c_Interact(speed,packet)
+			case temp
+				when HardsploitAPI::USB_STATE::PACKET_IS_TOO_LARGE
+					puts "PACKET_IS_TOO_LARGE max: #{HardsploitAPI::USB::USB_TRAME_SIZE}"
+				when HardsploitAPI::USB_STATE::ERROR_SEND
+					puts "ERROR_SEND\n"
+				when HardsploitAPI::USB_STATE::BUSY
+					puts "BUSY"
+				when HardsploitAPI::USB_STATE::TIMEOUT_RECEIVE
+					puts "TIMEOUT_RECEIVE\n"
+				else
+					#Remove header, result of read command and numberOfByte Address too
+					process_import_i2c_result( temp )
+			end
+
+			consoleProgress(percent:100*(i+1)/(number_complet_packet+ (size_last_packet.zero? ? 0 : 1)),startTime:startTime,endTime:Time.new)
+
+			#if too many error when write increase because we need to wait to write a full page
+			sleep(writePageLatency)
+		end
+
+		if(size_last_packet > 0 )then
+			packet = generate_i2c_write_command(i2cBaseAddress,numberOfByteAddress,number_complet_packet*packet_size+startAddress,file.read(size_last_packet).unpack("C*"))
+			temp = i2c_Interact(speed,packet)
+			case temp
+				when HardsploitAPI::USB_STATE::PACKET_IS_TOO_LARGE
+					puts "PACKET_IS_TOO_LARGE max: #{HardsploitAPI::USB::USB_TRAME_SIZE}"
+				when HardsploitAPI::USB_STATE::ERROR_SEND
+					puts "ERROR_SEND\n"
+				when HardsploitAPI::USB_STATE::BUSY
+					puts "BUSY"
+				when HardsploitAPI::USB_STATE::TIMEOUT_RECEIVE
+					puts "TIMEOUT_RECEIVE\n"
+				else
+					#Remove header, result of read command and numberOfByte Address too
+					process_import_i2c_result ( temp )
+			end
+				consoleProgress(percent:100,startTime:startTime,endTime:Time.new)
+		end
+
+		delta = Time.now - startTime
+		consoleSpeed "Write in #{delta.round(4)} sec"
 	end
 
 private
+
+def process_import_i2c_result (packet)
+	result = Array.new
+	for i in (0..packet.size-1).step(2) do
+		case packet[i]
+		when 0  #Write ACK
+			#Do nothing,don't save write ack
+		else
+			raise TypeError, "Error in I2C transaction (NACK), write failed "
+		end
+	end
+	return result
+end
+
+
 	def process_dump_i2c_result (packet)
 		result = Array.new
 		for i in (0..packet.size-1).step(2) do
@@ -175,12 +284,44 @@ private
 			when 0  #Write ACK
 				#Do nothing,don't save write ack
 			else
-				raise TypeError, "Error in I2C transaction, I2C dump seems to be wrong"
+				raise TypeError, "Error in I2C transaction, I2C export seems to be wrong"
 			end
 		end
 		return result
 	end
 
+	def generate_i2c_write_command ( i2cBaseAddress, numberOfByteAddress,startAddress,data)
+		packet = Array.new
+		#Push write command
+		packet.push HardsploitAPI.lowByte(numberOfByteAddress+data.size)  #size of write command
+		packet.push HardsploitAPI.highByte(numberOfByteAddress+data.size) #size of write command
+
+		packet.push i2cBaseAddress #push Write address
+
+		case  numberOfByteAddress
+			when 1
+				packet.push  ((startAddress & 0x000000FF) >> 0)   #AddStart0
+			when 2
+				packet.push  ((startAddress & 0x0000FF00) >> 8 )  #AddStart1
+				packet.push  ((startAddress & 0x000000FF) >> 0)   #AddStart
+			when 3
+				packet.push  ((startAddress & 0x00FF0000) >> 16 ) #AddStart2
+				packet.push  ((startAddress & 0x0000FF00) >> 8 )  #AddStart1
+				packet.push  ((startAddress & 0x000000FF) >> 0)   #AddStart0
+			when 4
+				packet.push  ((startAddress & 0xFF000000) >> 24 ) #AddStart3
+				packet.push  ((startAddress & 0x00FF0000) >> 16 ) #AddStart2
+				packet.push  ((startAddress & 0x0000FF00) >> 8 )  #AddStart1
+				packet.push  ((startAddress & 0x000000FF) >> 0)   #AddStart0
+			else
+				raise TypeError, "Issue in generate_i2c_write_command function when parse number of byte address"
+		end
+
+		#Push data to write
+		packet.push *data
+		return packet
+	end
+
 	def generate_i2c_read_command ( i2cBaseAddress, numberOfByteAddress,startAddress,size)
 		packet = Array.new
 		#Push write command for start address
@@ -215,4 +356,5 @@ private
 
 		return packet
 	end
+
 end

data/lib/HardsploitAPI/HardsploitAPI_PROGRESS.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/ruby
+#===================================================
+#  Hardsploit API - By Opale Security
+#  www.opale-security.com || www.hardsploit.io
+#  License: GNU General Public License v3
+#  License URI: http://www.gnu.org/licenses/gpl.txt
+#===================================================
+
+class HardsploitAPI
+	class HardsploitProgress
+		def initialize(percent,timeElasped)
+				@Percent = percent
+				@TimeElasped = timeElasped
+		end
+		def	getPercent
+			return @Percent
+		end
+		def	setPercent(percent)
+			 @Percent = percent
+		end
+		def	getTimeElasped
+			return @TimeElasped
+		end
+		def	setTimeElasped(timeElasped)
+			 @TimeElasped = timeElasped
+		end
+	end
+end

data/lib/HardsploitAPI/HardsploitAPI_SPI.rb

@@ -57,6 +57,147 @@ def spi_Interact(*args)
 	end
 end
 
+
+# Spi generic Import
+# * +mode+:: SPI mode 0,1,2,3
+# * +speed+:: Range 1-255  SPI clock =  150Mhz / (2*speed) tested from 3 to 255 (25Mhz to about 0.3Khz)
+# * +writeSpiCommand+:: The write command
+# * +startAddress+:: Start address (included)
+# * +pageSize+:: Size of page
+# * +memorySize+:: Size max of memory in byte (important, to calculate automatically the number of byte to set address)
+# * +saveFile+:: File contain data
+# * +writePageLatency+:: Time to wait after each pages written
+# * +enableWriteSpiCommand+:: Enable write commad
+# * +clearSpiCommand+:: Bulk erase command
+# * +clearChipTime+:: Time to erase entire the memory (bulk erase) in case of flash memory, 240 seconds for a 512Mb spansion memory and  13 seconds for a 16Mb Micron memory, see the datasheet
+# * +isFLASH+:: True if it is a Flash memory (add clear content)
+	def spi_Generic_Import (*args)
+		parametters = HardsploitAPI.checkParametters(["mode","speed","startAddress","pageSize","memorySize","dataFile","writeSpiCommand","writePageLatency","enableWriteSpiCommand","clearSpiCommand","clearChipTime","isFLASH"],args)
+		mode = parametters[:mode]
+		speed = parametters[:speed]
+		startAddress = parametters[:startAddress]
+		pageSize = parametters[:pageSize]
+		memorySize = parametters[:memorySize]
+		dataFile = parametters[:dataFile]
+		writePageLatency = parametters[:writePageLatency]
+
+		#most of the time 0x02
+		writeSpiCommand = parametters[:writeSpiCommand]
+		writeSpiCommand
+		#most of the time 0x06
+		enableWriteSpiCommand = parametters[:enableWriteSpiCommand]
+
+		#most of the time 0x60  chip eraseTime
+		clearSpiCommand = parametters[:clearWriteSpiCommand]
+
+		# in second
+		clearChipTime = parametters[:clearChipTime]
+
+		#if flash memory
+		isFLASH = parametters[:isEEPROM]
+
+		#Start time
+		startTime = Time.now
+		begin
+			file =	File.open(dataFile, 'rb')
+			sizeFile = file.size
+		rescue Exception => e
+			raise Error::FileIssue, e.message
+		end
+
+		if (mode < 0)  and (mode >3) then
+			raise TypeError, 'Mode must be between 0 and 3'
+		end
+		if (speed <= 2)  and (speed >256) then
+			raise TypeError, 'Speed must be between 3 and 255'
+		end
+
+		if ((startAddress < 0)  or (startAddress > memorySize-1)) then
+			raise Error::WrongStartAddress
+		end
+
+		if ((pageSize <= 0) and (pageSize >2048)) then
+			raise TypeError, "pageSize need to be greater than 0 and less than 2048"
+		end
+
+		numberOfByteAddress = (((Math.log(memorySize-1,2)).floor + 1) / 8.0).ceil
+		if numberOfByteAddress > 4 then
+			raise TypeError, "Size max must be less than 2^32 about 4Gb"
+		end
+
+		if numberOfByteAddress <= 0 then
+			raise TypeError, "There is an issue with calculating of number of byte needed"
+		end
+
+		#if flash memory we need to erase it before and wait enought
+		#time (erase cycle time in datasheet) or polling status register
+		if isFLASH then
+		  spi_Interact(mode:mode,speed:speed,payload:[clearSpiCommand])
+			sleep(clearChipTime)
+		end
+
+		startTime = Time.now
+		packet_size = pageSize
+		number_complet_packet = (sizeFile / packet_size).floor
+		size_last_packet =  sizeFile % packet_size
+
+		#SEND the first complete trame
+		for i in 0..number_complet_packet-1 do
+			#Enable write latch
+			spi_Interact(mode:mode,speed:speed,payload:[enableWriteSpiCommand])
+			packet = generate_spi_write_command numberOfByteAddress,writeSpiCommand,i*packet_size+startAddress,file.read(packet_size).unpack("C*")
+		  temp = spi_Interact(mode,speed,packet)
+			case temp
+				when HardsploitAPI::USB_STATE::PACKET_IS_TOO_LARGE
+					puts "PACKET_IS_TOO_LARGE max: #{HardsploitAPI::USB::USB_TRAME_SIZE}"
+				when HardsploitAPI::USB_STATE::ERROR_SEND
+					puts "ERROR_SEND\n"
+				when HardsploitAPI::USB_STATE::BUSY
+					puts "BUSY"
+				when HardsploitAPI::USB_STATE::TIMEOUT_RECEIVE
+					puts "TIMEOUT_RECEIVE\n"
+				else
+					#Remove header, result of read command and numberOfByte Address too
+					#consoleData temp.drop(numberOfByteAddress+1)
+					if packet.size != packet.size then
+						raise HardsploitAPI::SpiError
+					end
+			end
+
+			consoleProgress(percent:100*(i+1)/(number_complet_packet+ (size_last_packet.zero? ? 0 : 1)),startTime:startTime,endTime:Time.new)
+			#if too many error when write increase because we need to wait to write a full page
+			sleep(writePageLatency)
+		end
+
+		if(size_last_packet > 0 )then
+			#Enable write latch
+			spi_Interact(mode:mode,speed:speed,payload:[enableWriteSpiCommand])
+			packet = generate_spi_write_command numberOfByteAddress,writeSpiCommand,number_complet_packet*packet_size+startAddress,file.read(size_last_packet).unpack("C*")
+			temp = spi_Interact(mode,speed,packet)
+			case temp
+				when HardsploitAPI::USB_STATE::PACKET_IS_TOO_LARGE
+					puts "PACKET_IS_TOO_LARGE max: #{HardsploitAPI::USB::USB_TRAME_SIZE}"
+				when HardsploitAPI::USB_STATE::ERROR_SEND
+					puts "ERROR_SEND\n"
+				when HardsploitAPI::USB_STATE::BUSY
+					puts "BUSY"
+				when HardsploitAPI::USB_STATE::TIMEOUT_RECEIVE
+					puts "TIMEOUT_RECEIVE\n"
+				else
+					#Remove header, result of write command and numberOfByte Address too
+					#consoleData temp.drop(numberOfByteAddress+1)
+					if packet.size != packet.size then
+						raise HardsploitAPI::SpiError
+					end
+			end
+			#Send 100% in case of last packet
+			consoleProgress(percent:100,startTime:startTime,endTime:Time.now)
+		end
+		delta = Time.now - startTime
+		consoleSpeed "Write in #{delta.round(4)} sec"
+end
+
+
 # Spi generic dump
 # * +mode+:: SPI mode 0,1,2,3
 # * +speed+:: Range 1-255  SPI clock =  150Mhz / (2*speed) tested from 3 to 255 (25Mhz to about 0.3Khz)
@@ -73,6 +214,14 @@ end
 		stopAddress = parametters[:stopAddress]
 		sizeMax = parametters[:sizeMax]
 
+
+		if (mode < 0)  and (mode >3) then
+			raise TypeError, 'Mode must be between 0 and 3'
+		end
+		if (speed <= 2)  and (speed >256) then
+			raise TypeError, 'Speed must be between 3 and 255'
+		end
+
 		if ((startAddress < 0)  or (startAddress > sizeMax-1)) then
 			raise TypeError, "Start address can't be negative and not more than size max - 1"
 		end
@@ -93,6 +242,8 @@ end
 			raise TypeError, "There is an issue with calculating of number of byte needed"
 		end
 
+		#Start time
+		startTime = Time.now
 		packet_size = 4000 - numberOfByteAddress - 1
 		number_complet_packet = ( (stopAddress-startAddress+1) / packet_size).floor
 		size_last_packet =  (stopAddress-startAddress+1) % packet_size
@@ -100,7 +251,6 @@ end
 		#SEND the first complete trame
 		for i in 0..number_complet_packet-1 do
 			packet = generate_spi_read_command numberOfByteAddress,readSpiCommand,i*packet_size+startAddress,packet_size
-
 			temp = spi_Interact(mode,speed,packet)
 			case temp
 				when HardsploitAPI::USB_STATE::PACKET_IS_TOO_LARGE
@@ -113,11 +263,13 @@ end
 					puts "TIMEOUT_RECEIVE\n"
 				else
 					#Remove header, result of read command and numberOfByte Address too
-					puts "receive real size #{temp.size}"
+					#puts "receive real size #{temp.size}"
 					consoleData temp.drop(numberOfByteAddress+1)
 			end
+			consoleProgress(percent:100*(i+1)/(number_complet_packet+ (size_last_packet.zero? ? 0 : 1)),startTime:startTime,endTime:Time.new)
 		end
 
+	if(size_last_packet > 0 )then
 			packet = generate_spi_read_command numberOfByteAddress,readSpiCommand,number_complet_packet*packet_size+startAddress,size_last_packet
 			temp = spi_Interact(mode,speed,packet)
 			case temp
@@ -131,10 +283,14 @@ end
 					puts "TIMEOUT_RECEIVE\n"
 				else
 					#Remove header, result of read command and numberOfByte Address too
-					puts "receive real size #{temp.size}"
+					#puts "receive real size #{temp.size}"
 					consoleData temp.drop(numberOfByteAddress+1)
-			end
+					consoleProgress(percent:100,startTime:startTime,endTime:Time.now)
+				end
 		end
+		delta = Time.now - startTime
+		consoleSpeed "Write in #{delta.round(4)} sec"
+end
 
 protected
 	def generate_spi_read_command ( numberOfByteAddress,readSpiCommand,startAddress,size)
@@ -168,8 +324,42 @@ protected
 
 		#put N dummy byte to read size data
 		packet.push *Array.new(size, 0)
+		if packet.size > 4000 then
+			raise TypeError, "Too many byte to send in spi mode not more than 4000 is needed"
+		end
+
+		return packet
+	end
+
+	def generate_spi_write_command ( numberOfByteAddress,writeSpiCommand,startAddress,data)
+		packet = Array.new
+			#Push write command
+		packet.push writeSpiCommand
+
+		case  numberOfByteAddress
+			when 1
+				packet.push  ((startAddress & 0x000000FF) >> 0)   #AddStart0
+
+			when 2
+				packet.push  ((startAddress & 0x0000FF00) >> 8 )  #AddStart1
+				packet.push  ((startAddress & 0x000000FF) >> 0)   #AddStart0
+
+			when 3
+				packet.push  ((startAddress & 0x00FF0000) >> 16 ) #AddStart2
+				packet.push  ((startAddress & 0x0000FF00) >> 8 )  #AddStart1
+				packet.push  ((startAddress & 0x000000FF) >> 0)   #AddStart0
+
+			when 4
+				packet.push  ((startAddress & 0xFF000000) >> 24 ) #AddStart3
+				packet.push  ((startAddress & 0x00FF0000) >> 16 ) #AddStart2
+				packet.push  ((startAddress & 0x0000FF00) >> 8 )  #AddStart1
+				packet.push  ((startAddress & 0x000000FF) >> 0)   #AddStart0
+			else
+				raise TypeError, "Issue in generate_spi_write_command function when parse number of byte address"
+		end
 
-	puts  " Send real size #{packet.size}"
+		#Push data to write
+		packet.push *data
 		if packet.size > 4000 then
 			raise TypeError, "Too many byte to send in spi mode not more than 4000 is needed"
 		end