hardsploit_gui 2.2 → 2.3

data/lib/HardsploitAPI/Modules/NRF24L01/HardsploitAPI_NRF24L01.rb

@@ -0,0 +1,306 @@
+#!/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
+#===================================================
+
+require_relative '../../Core/HardsploitAPI'
+require_relative '../../Modules/SPI/HardsploitAPI_SPI'
+class HardsploitAPI_NRF24L01
+public
+		# Instruction Mnemonics
+		R_REGISTER 	  	 = 0x00
+		W_REGISTER       = 0x20
+		REGISTER_MASK    = 0x1F
+		ACTIVATE         = 0x50
+		R_RX_PL_WID      = 0x60
+		R_RX_PAYLOAD     = 0x61
+		W_TX_PAYLOAD     = 0xA0
+		W_ACK_PAYLOAD    = 0xA8
+		FLUSH_TX         = 0xE1
+		FLUSH_RX         = 0xE2
+		REUSE_TX_PL      = 0xE3
+		NOP              = 0xFF
+
+		#Register map
+    NRF24L01_00_CONFIG      = 0x00
+    NRF24L01_01_EN_AA       = 0x01
+    NRF24L01_02_EN_RXADDR   = 0x02
+    NRF24L01_03_SETUP_AW    = 0x03
+    NRF24L01_04_SETUP_RETR  = 0x04
+    NRF24L01_05_RF_CH       = 0x05
+    NRF24L01_06_RF_SETUP    = 0x06
+    NRF24L01_07_STATUS      = 0x07
+    NRF24L01_08_OBSERVE_TX  = 0x08
+    NRF24L01_09_CD          = 0x09
+    NRF24L01_0A_RX_ADDR_P0  = 0x0A
+    NRF24L01_0B_RX_ADDR_P1  = 0x0B
+    NRF24L01_0C_RX_ADDR_P2  = 0x0C
+    NRF24L01_0D_RX_ADDR_P3  = 0x0D
+    NRF24L01_0E_RX_ADDR_P4  = 0x0E
+    NRF24L01_0F_RX_ADDR_P5  = 0x0F
+    NRF24L01_10_TX_ADDR     = 0x10
+    NRF24L01_11_RX_PW_P0    = 0x11
+    NRF24L01_12_RX_PW_P1    = 0x12
+    NRF24L01_13_RX_PW_P2    = 0x13
+    NRF24L01_14_RX_PW_P3    = 0x14
+    NRF24L01_15_RX_PW_P4    = 0x15
+    NRF24L01_16_RX_PW_P5    = 0x16
+    NRF24L01_17_FIFO_STATUS = 0x17
+    NRF24L01_1C_DYNPD       = 0x1C
+		NRF24L01_1D_FEATURE     = 0x1D
+
+		# Bit mnemonics
+    NRF24L01_00_MASK_RX_DR  = 6
+    NRF24L01_00_MASK_TX_DS  = 5
+    NRF24L01_00_MASK_MAX_RT = 4
+    NRF24L01_00_EN_CRC      = 3
+    NRF24L01_00_CRCO        = 2
+    NRF24L01_00_PWR_UP      = 1
+    NRF24L01_00_PRIM_RX     = 0
+    NRF24L01_07_RX_DR       = 6
+    NRF24L01_07_TX_DS       = 5
+    NRF24L01_07_MAX_RT      = 4
+
+		# Bitrates
+    NRF24L01_BR_1M				  = 0
+    NRF24L01_BR_2M 					= 1
+    NRF24L01_BR_250K			  = 2
+    NRF24L01_BR_RSVD 				= 3
+
+		TXRX_OFF								= 0
+		TX_EN 									= 1
+		RX_EN 									= 2
+
+	def BV(x)
+	 return (1 << x)
+	end
+
+	def sendAndReceiveSPI(packet)
+		begin
+			return @spi.spi_Interact(payload:packet)
+		rescue HardsploitAPI::ERROR::HARDSPLOIT_NOT_FOUND
+			puts "Hardsploit not found"
+	  rescue HardsploitAPI::ERROR::USB_ERROR
+			puts "USB ERROR"
+		end
+	end
+
+	def initialize()
+		#Speed Range 1-255  SPI clock =  150Mhz / (2*speed) tested from 3 to 255 (25Mhz to about 0.3Khz)
+		@spi = HardsploitAPI_SPI.new(speed:8,mode:0) # 150/(2*8) = 9.3Mhz
+		@rf_setup = 0x0F
+		@tout	=0
+	end
+
+	def initDrone(channel:,address:)
+		config = BV(NRF24L01_00_EN_CRC) | BV(NRF24L01_00_CRCO) | BV(NRF24L01_00_PRIM_RX)
+		NRF24L01_WriteReg(NRF24L01_00_CONFIG, config);
+		NRF24L01_WriteReg(NRF24L01_01_EN_AA, 0x0f);      # Auto Acknoledgement
+		NRF24L01_Activate(0x73);                         #Allow write feature reg
+		NRF24L01_WriteReg( NRF24L01_1D_FEATURE,0x06); #enableDynamicPayloads
+		NRF24L01_WriteReg( NRF24L01_1C_DYNPD,0x3f);   #enableDynamicPayloads
+    NRF24L01_WriteReg(NRF24L01_02_EN_RXADDR, 0x01);  # Enable data pipe 0
+		NRF24L01_WriteReg(NRF24L01_03_SETUP_AW, 0x03);   # 5-byte RX/TX address
+  		#NRF24L01_WriteReg(NRF24L01_04_SETUP_RETR, 0xFF); # 4ms retransmit t/o, 15 tries
+		NRF24L01_WriteReg(NRF24L01_05_RF_CH, channel);      # Channel  - bind
+		setBitrate(NRF24L01_BR_250K)
+		setPower(3) #Max power
+		NRF24L01_WriteReg(NRF24L01_07_STATUS, 0x70); 	# Clear data ready, data
+		NRF24L01_WriteReg(NRF24L01_11_RX_PW_P0, 16);
+		NRF24L01_WriteReg(NRF24L01_17_FIFO_STATUS, 0x00);
+		NRF24L01_WriteRegisterMulti(NRF24L01_0A_RX_ADDR_P0,address);
+		NRF24L01_WriteRegisterMulti(NRF24L01_10_TX_ADDR, address);
+
+		initialize();
+
+		config |= BV(NRF24L01_00_PWR_UP);
+	  NRF24L01_WriteReg(NRF24L01_00_CONFIG, config);
+
+		valid_packets = missed_packets = bad_packets = 0;
+
+		NRF24L01_SetTxRxMode(TXRX_OFF);
+		NRF24L01_SetTxRxMode(RX_EN);
+		# puts "EN_AA"
+		# p NRF24L01_ReadReg(NRF24L01_01_EN_AA)
+		# puts "EN_RXADDR"
+		# p NRF24L01_ReadReg(NRF24L01_02_EN_RXADDR)
+		# puts "SETUP_AW"
+		# p NRF24L01_ReadReg(NRF24L01_03_SETUP_AW)
+		# puts "RF_CH"
+		# p NRF24L01_ReadReg(NRF24L01_05_RF_CH)
+		# puts "RX_PW_P0"
+		# p NRF24L01_ReadRegisterMulti(NRF24L01_0A_RX_ADDR_P0,5)
+		# puts "TX_PW_P0"
+		# p NRF24L01_ReadRegisterMulti(NRF24L01_10_TX_ADDR,5)
+		# puts "RX_ADDR_P0"
+		# p NRF24L01_ReadReg(NRF24L01_0A_RX_ADDR_P0)
+		# puts "TX_ADDR"
+		# p NRF24L01_ReadReg(NRF24L01_10_TX_ADDR)
+		# puts "config"
+		# p config
+	end
+
+	def NRF24L01_WriteReg(reg, data)
+		result = sendAndReceiveSPI([ (W_REGISTER | (REGISTER_MASK & reg)),data ])
+		return result[1]
+	end
+
+	def NRF24L01_WriteRegisterMulti(reg, payload)
+		tmppayload = Array.new
+		tmppayload.push (W_REGISTER | (REGISTER_MASK & reg))
+		tmppayload.push *payload
+		result = sendAndReceiveSPI(tmppayload)
+		return result[0]
+	end
+
+	def NRF24L01_WritePayload(payload)
+		tmpWpayload = Array.new
+		tmpWpayload.push (W_TX_PAYLOAD)
+		tmpWpayload.push *payload
+		result = sendAndReceiveSPI(tmpWpayload)
+		return result[0]
+	end
+
+	def NRF24L01_ReadReg(reg)
+		result = sendAndReceiveSPI([R_REGISTER | (REGISTER_MASK & reg) ,0xFF ])
+		return result[1]
+	end
+
+	def readPayloadSize
+		result = sendAndReceiveSPI([R_RX_PL_WID ,0xFF ])
+		return result[1]
+	end
+
+	def NRF24L01_ReadRegisterMulti(reg,length)
+		tab = Array.new
+		tab.push (R_REGISTER | (REGISTER_MASK & reg))
+		tab.push *Array.new(length, 0xFF)
+		return sendAndReceiveSPI(tab).drop(1) #remove the first byte
+	end
+
+	def readPayload(length)
+		tab = Array.new
+		tab.push R_RX_PAYLOAD
+		tab.push *Array.new(length, 0xFF)
+		return sendAndReceiveSPI(tab).drop(1) #remove the first byte
+	end
+
+	def readAvailableData
+			return readPayload(readPayloadSize)
+	end
+
+	def Strobe(state)
+		result = sendAndReceiveSPI([state])
+		return result[0];
+	end
+
+	def NRF24L01_FlushTx()
+		return Strobe(FLUSH_TX);
+	end
+
+	def NRF24L01_FlushRx()
+		return Strobe(FLUSH_RX);
+	end
+
+	def NRF24L01_Activate(code)
+		result = sendAndReceiveSPI([ACTIVATE ,code])
+		return result[0];
+	end
+
+	def dataAvailable()
+		result = sendAndReceiveSPI([R_REGISTER ,HardsploitAPI_NRF24L01::NRF24L01_07_STATUS])
+		if ((result[0] & BV(HardsploitAPI_NRF24L01::NRF24L01_07_RX_DR))>>6)==1
+			return true
+		else
+			return false
+		end
+	end
+
+	def changeChannel(channel:)
+		NRF24L01_WriteReg(NRF24L01_05_RF_CH, channel)
+	end
+
+	def setBitrate(bitrate)
+		 #Note that bitrate 250kbps (and bit RF_DR_LOW) is valid only
+		 #for nRF24L01+. There is no way to programmatically tell it from
+		 #older version, nRF24L01, but the older is practically phased out
+		 #by Nordic, so we assume that we deal with with modern version.
+
+		# Bit 0 goes to RF_DR_HIGH, bit 1 - to RF_DR_LOW
+		@rf_setup = (@rf_setup & 0xD7) | ((bitrate & 0x02) << 4) | ((bitrate & 0x01) << 3);
+		return NRF24L01_WriteReg(NRF24L01_06_RF_SETUP, @rf_setup);
+	end
+
+	# Power setting is 0..3 for nRF24L01
+	def setPower(nrf_power)
+		if (nrf_power < 0) or (nrf_power > 3) then
+			raise "NRF setPower, wrong must be between 0 and 3"
+		end
+		@rf_setup = (@rf_setup & 0xF9) | ((nrf_power & 0x03) << 1)
+		return NRF24L01_WriteReg(NRF24L01_06_RF_SETUP, @rf_setup)
+	end
+
+	def CE_lo
+		@spi.pulse = 0
+	end
+
+	def CE_hi
+		@spi.pulse = 1
+	end
+
+	def NRF24L01_SetTxRxMode(mode)
+		if(mode == TX_EN) then
+			CE_lo()
+			#sleep(0.5)
+			NRF24L01_WriteReg(NRF24L01_07_STATUS, (1 << NRF24L01_07_RX_DR) | (1 << NRF24L01_07_TX_DS) 	| (1 << NRF24L01_07_MAX_RT))   #reset the flag(s)
+			NRF24L01_WriteReg(NRF24L01_00_CONFIG, (1 << NRF24L01_00_EN_CRC)| (1 << NRF24L01_00_CRCO) | (1 << NRF24L01_00_PWR_UP))  #switch to TX mode
+			#sleep(0.5)
+			CE_hi()
+		elsif (mode == RX_EN) then
+			CE_lo()
+		#	sleep(0.5)
+			NRF24L01_WriteReg(NRF24L01_07_STATUS, 0x70)        # reset the flag(s)
+			NRF24L01_WriteReg(NRF24L01_00_CONFIG, 0x0F)        # switch to RX mode
+			NRF24L01_WriteReg(NRF24L01_07_STATUS, (1 << NRF24L01_07_RX_DR) | (1 << NRF24L01_07_TX_DS) | (1 << NRF24L01_07_MAX_RT)) #reset the flag(s)
+			NRF24L01_WriteReg(NRF24L01_00_CONFIG, (1 << NRF24L01_00_EN_CRC)| (1 << NRF24L01_00_CRCO) 	| (1 << NRF24L01_00_PWR_UP) | (1 << NRF24L01_00_PRIM_RX)) #switch to RX mode
+		#	sleep(0.5)
+			CE_hi()
+		else
+			NRF24L01_WriteReg(NRF24L01_00_CONFIG, (1 << NRF24L01_00_EN_CRC)) #PowerDown
+			CE_lo()
+		end
+	end
+
+	def reset()
+		NRF24L01_SetTxRxMode(TXRX_OFF)
+	 	NRF24L01_FlushTx()
+	 	NRF24L01_FlushRx()
+		return true
+	end
+
+	def Read()
+		tabdataread = Array.new
+		if dataAvailable()
+			NRF24L01_WriteReg(0x07,BV(HardsploitAPI_NRF24L01::NRF24L01_07_RX_DR))
+			tabdataread.push *readPayload(16)
+    	return tabdataread
+		else
+			return tabdataread
+		end
+	end
+
+	def Send(dataSend)
+		NRF24L01_SetTxRxMode(TXRX_OFF)
+		NRF24L01_FlushTx()
+		NRF24L01_WritePayload(dataSend)
+		NRF24L01_SetTxRxMode(TX_EN)
+  	sleep(0.1)
+		NRF24L01_SetTxRxMode(TXRX_OFF)
+		NRF24L01_FlushTx()
+		NRF24L01_FlushRx()
+		NRF24L01_SetTxRxMode(RX_EN);
+	end
+end

data/lib/HardsploitAPI/Modules/SPI/HardsploitAPI_SPI.rb

@@ -0,0 +1,340 @@
+#!/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
+#===================================================
+
+require_relative '../../Core/HardsploitAPI'
+class HardsploitAPI_SPI
+public
+
+def initialize(speed:,mode:)
+	#to be sure the singleton was initialize
+	HardsploitAPI.instance.connect
+	self.speed=speed
+	self.mode=mode
+	@pulse = 0
+end
+
+def pulse
+	return @pulse
+end
+
+def pulse=(pulse)
+	if (pulse == 0) or (pulse == 1) then
+		@pulse = pulse
+		spi_SetSettings #Send an Empty array to validate the value of pulse
+	else
+		raise HardsploitAPI::ERROR::SPIWrongPulse
+	end
+end
+
+def speed
+	return @speed
+end
+
+def speed=(speed)
+	if (speed <=2) or (speed >256) then
+		raise HardsploitAPI::ERROR::SPIWrongSpeed
+	else
+		@speed = speed
+	end
+end
+
+def mode
+	return @mode
+end
+
+def mode=(mode)
+	if ( mode < 0 ) or ( mode > 3 ) then
+		raise HardsploitAPI::ERROR::SPIWrongMode
+	else
+		@mode = mode
+	end
+end
+
+def spi_SetSettings()
+	packet = Array.new
+	packet.push 0  #low byte of lenght of trame refresh automaticly before send by usb
+	packet.push 0  #high byte of lenght of trame refresh automaticly before send by usb
+	packet.push HardsploitAPI.lowByte(word:HardsploitAPI::USB_COMMAND::FPGA_COMMAND)
+	packet.push HardsploitAPI.highByte(word:HardsploitAPI::USB_COMMAND::FPGA_COMMAND)
+
+	packet.push 0x50 #Command RAW COMMUNICATION TO FPGA FIFO
+
+	packet.push (( @pulse & 1 ) << 2 ) || ( @mode & 3 ) #Add mode and the value of pin pulse
+	packet.push @speed #Add speed
+	begin
+		HardsploitAPI.instance.sendPacket packet
+		rescue
+		raise HardsploitAPI::ERROR::USB_ERROR
+	end
+end
+
+#  SPI interact
+# * +payload+:: Byte array want to send
+# * Return SPI data received
+def spi_Interact(payload:)
+	if ( payload.size > 4000 ) then
+		raise SPIWrongPayloadSize
+	end
+
+	packet = Array.new
+	packet.push 0  #low byte of lenght of trame refresh automaticly before send by usb
+	packet.push 0  #high byte of lenght of trame refresh automaticly before send by usb
+	packet.push HardsploitAPI.lowByte(word:HardsploitAPI::USB_COMMAND::FPGA_COMMAND)
+	packet.push HardsploitAPI.highByte(word:HardsploitAPI::USB_COMMAND::FPGA_COMMAND)
+
+	packet.push 0x50 #Command RAW COMMUNICATION TO FPGA FIFO
+	packet.push (( @pulse & 1 ) << 2 ) || ( @mode & 3 ) #Add mode and the value of pin pulse
+	packet.push @speed #Add speed
+	packet.concat payload #Add data
+	#puts "Payload : #{payload}"
+
+	#remove header (4 bytes   2 for size 2 for type of command)
+	return HardsploitAPI.instance.sendAndReceiveDATA(packet, 1000).drop(4)
+end
+
+
+# Spi generic Import
+# * +writeSpiCommand+:: The write command most of the time 0x02
+# * +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 most of the time 0x06
+# * +clearSpiCommand+:: Bulk erase command most of the time 0x60  chip eraseTime
+# * +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 (startAddress:,pageSize:,memorySize:,dataFile:,writeSpiCommand:,writePageLatency:,enableWriteSpiCommand:,clearSpiCommand:,clearChipTime:,isFLASH:)
+		#Start time
+		startTime = Time.now
+
+		file =	File.open(dataFile, 'rb')
+		sizeFile = file.size
+
+		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(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(payload:	[enableWriteSpiCommand])
+			packet = generate_spi_write_command(
+				numberOfByteAddress:	numberOfByteAddress,
+				writeSpiCommand:			writeSpiCommand,
+				startAddress:					i * packet_size + startAddress,
+				data:									file.read(packet_size).unpack("C*")
+			)
+
+			temp = spi_Interact( payload:	packet )
+			#Remove header, result of read command and numberOfByte Address too
+			unless packet.size == temp.size then
+				raise HardsploitAPI::SpiError
+			end
+
+			HardsploitAPI.instance.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( payload:	[enableWriteSpiCommand]	)
+			packet = generate_spi_write_command(
+				numberOfByteAddress:	numberOfByteAddress,
+				writeSpiCommand:			writeSpiCommand,
+				startAddress: 				number_complet_packet * packet_size + startAddress,
+				data:									file.read(size_last_packet).unpack("C*")
+			)
+			temp = spi_Interact( payload:	packet )
+			#Remove header, result of write command and numberOfByte Address too
+			unless packet.size == temp.size then
+				raise HardsploitAPI::SpiError
+			end
+
+			#Send 100% in case of last packet
+			HardsploitAPI.instance.consoleProgress(
+				percent:		100,
+				startTime:	startTime,
+				endTime:		Time.now
+			)
+		end
+		delta = Time.now - startTime
+		HardsploitAPI.instance.consoleSpeed "Write in #{delta.round(4)} sec"
+end
+
+
+# Spi generic dump
+# * +readSpiCommand+:: The read command
+# * +startAddress+:: Start address (included)
+# * +stopAddress+:: Stop address (included)
+# * +sizeMax+:: Size max of memory (important to calculate automaticly the number of byte to set address)
+	def spi_Generic_Dump (readSpiCommand:,startAddress:,stopAddress:,sizeMax:)
+		if (( startAddress < 0 )  or ( startAddress > sizeMax - 1 )) then
+			raise TypeError, "Start address can't be negative and not more than size max - 1"
+		end
+
+		if (( stopAddress < 0 )  or ( stopAddress > ( sizeMax - 1 ))) then
+			raise TypeError, "Stop address can't be negative and not more than size max-1 because start at 0"
+		end
+
+		if ( stopAddress < startAddress ) then
+			raise TypeError, "Stop address need to be greater than start address"
+		end
+
+		numberOfByteAddress = ((( Math.log( sizeMax - 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
+
+		#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
+
+		#SEND the first complete trame
+		for i in 0..number_complet_packet - 1 do
+			packet = generate_spi_read_command(
+				numberOfByteAddress:	numberOfByteAddress,
+				readSpiCommand:				readSpiCommand,
+				startAddress:					i * packet_size + startAddress,
+				size:									packet_size
+			)
+			begin
+				temp = spi_Interact( payload: packet )
+			rescue
+				raise HardsploitAPI::ERROR::USB_ERROR
+			end
+			#Remove header, result of read command and numberOfByte Address too
+			#puts "receive real size #{temp.size}"
+			HardsploitAPI.instance.consoleData temp.drop( numberOfByteAddress + 1 )
+			HardsploitAPI.instance.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:	numberOfByteAddress,
+			readSpiCommand: 			readSpiCommand,
+			startAddress: 				number_complet_packet * packet_size + startAddress,
+			size:									size_last_packet
+		)
+		temp = spi_Interact( payload: packet )
+		#Remove header, result of read command and numberOfByte Address too
+		HardsploitAPI.instance.consoleData temp.drop( numberOfByteAddress + 1 )
+		begin
+			HardsploitAPI.instance.consoleProgress(
+				percent: 	 100,
+				startTime: startTime,
+				endTime: 	 Time.now
+			)
+		rescue
+			raise HardsploitAPI::ERROR::USB_ERROR
+		end
+	end
+		delta = Time.now - startTime
+		HardsploitAPI.instance.consoleSpeed "Write in #{delta.round(4)} sec"
+end
+
+protected
+	def generate_spi_read_command (numberOfByteAddress:,readSpiCommand:,startAddress:,size:)
+		packet = Array.new
+		packet.push readSpiCommand
+		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_read_command function when parse number of byte address"
+		end
+
+		#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
+		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
+		#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
+		return packet
+	end
+end