hardsploit_gui 2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 030b1c7ca30ebc3603c750b93147ad1a7b2d407f
+  data.tar.gz: 7595d0cc31b7a3fab274252985577064e581ebb6
+SHA512:
+  metadata.gz: 058934a2bef35c81153d96ce0b21d12069c6abe32cbb5f32166f9a3777d865b5761cea0dcaaca56bc0477bba4fb047875d3f2929fe7b23388e247c7fa427f2ea
+  data.tar.gz: 9586a89c0be2be5df3e39754711563c3885e4506c7bf8d7f4f68ed2005988fe42c511555c73c4aa7842ff2ee4b68a98fe01569cebd317b613255d814dbf27530

data/README.md

@@ -0,0 +1,22 @@
+# Hardsploit
+
+    The essential security auditing tool for Internet of Things devices you'll need in your toolbox
+
+### [GO TO HARDSPLOIT](http://www.hardsploit.io)
+
+    TO LEARN ABOUT IT
+
+### [GO TO SHOP](https://www.shop-hardsploit.com)
+    TO BUY
+
+### [GO TO WIKI](http://wiki.hardsploit.io)
+
+    TO UNDERSTAND HOW USE IT
+
+### [GO TO FORUM](http://forum.hardsploit.io)
+
+    FOR SUPPORT / HELP
+
+### [GO TO BUG TRACKER] (http://issues.hardsploit.io)
+
+        FOR BUGS OR IMPROVEMENTS

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/hardsploit_gui

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require "hardsploit"
+Hardsploit_GUI.new

data/lib/Firmware/FPGA/VersionFPGA.rb

@@ -0,0 +1,5 @@
+class VersionFPGA
+	module VERSION_FPGA
+     FPGA = "V1.1.0"
+  end
+end

data/lib/Firmware/UC/VersionUC.rb

@@ -0,0 +1,12 @@
+#===================================================
+#  Hardsploit UC - 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 VersionUC
+	module VERSION_UC
+	   UC = "V1.0.2"
+  end
+end

data/lib/HardsploitAPI/HardsploitAPI.rb

@@ -0,0 +1,134 @@
+#!/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 'libusb'
+require_relative 'HardsploitAPI_CONSTANT'
+require_relative 'HardsploitAPI_USB_COMMUNICATION'
+require_relative 'HardsploitAPI_FIRMWARE'
+require_relative 'HardsploitAPI_NO_MUX_PARALLELE_MEMORY'
+require_relative 'HardsploitAPI_I2C'
+require_relative 'HardsploitAPI_SPI'
+require_relative 'HardsploitAPI_TEST_INTERACT'
+require_relative 'SWD/HardsploitAPI_SWD'
+
+require 'thread'
+
+class HardsploitAPI
+public
+
+	attr_accessor :dev
+
+	include USB
+	include USB_STATE
+	include USB_COMMAND
+
+ 	  # Initialize the HARDSPLOIT API
+		# * +callbackData+:: callback to return data for dump function
+	  # * +callbackInfo+:: callback to get back general information
+	  # * +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)
+		@callbackData = parametters[:callbackData]
+		@callbackInfo = parametters[:callbackInfo]
+		@callbackError = parametters[:callbackError]
+		@callbackSpeedOfTransfert = parametters[:callbackSpeedOfTransfert]
+
+		@packet_send = Array.new
+		@usb = LIBUSB::Context.new
+		@device = nil
+	end
+
+	# Set custom value to wiring led
+  # * +value+:: 64 bits (8x8 Bytes) values to represent led (PortH PortG PortF PortE PortD PortC PortB PortA)
+	def setWiringLeds(*args)
+		parametters = HardsploitAPI.checkParametters(["value"],args)
+		val = parametters[:value]
+
+		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(USB_COMMAND::FPGA_COMMAND)
+		packet.push HardsploitAPI.highByte(USB_COMMAND::FPGA_COMMAND)
+
+		packet.push 0x23 #Command SPI write wiring led
+
+		packet.push  HardsploitAPI.reverseBit((val & 0x00000000000000FF) >> 0)
+		packet.push  HardsploitAPI.reverseBit((val & 0x000000000000FF00) >> 8 )
+		packet.push  HardsploitAPI.reverseBit((val & 0x0000000000FF0000) >> 16 )
+		packet.push  HardsploitAPI.reverseBit((val & 0x00000000FF000000) >> 24 )
+		packet.push  HardsploitAPI.reverseBit((val & 0x000000FF00000000) >> 32 )
+		packet.push  HardsploitAPI.reverseBit((val & 0x0000FF0000000000) >> 40 )
+		packet.push  HardsploitAPI.reverseBit((val & 0x00FF000000000000) >> 48 )
+		packet.push  HardsploitAPI.reverseBit((val & 0xFF00000000000000) >> 56 )
+
+		return  self.sendPacket(packet)
+	end
+
+	# Obtaint the version number of the board
+	def getVersionNumber
+		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(USB_COMMAND::GET_VERSION_NUMBER)
+		packet.push HardsploitAPI.highByte(USB_COMMAND::GET_VERSION_NUMBER)
+
+		#remove header
+		version_number = sendAndReceiveDATA(packet,1000).drop(4)
+		if version_number.size < 20 then #if size more thant 20 char error when reading version number
+				return version_number.pack('U*')
+		else
+			return "BAD VERSION NUMBER"
+		end
+
+	end
+
+
+
+	def self.reverseBit(byte)
+		return byte.to_s(2).rjust(8, "0").reverse.to_i(2)
+	end
+
+	def self.checkParametters(arr_parametters,*args)
+		params = Hash.new
+		if args[0][0].class == Hash then
+			hash_args = args[0][0]
+				arr_parametters.each  do |param|
+					if hash_args[param.to_sym] == nil then
+							raise "Wrong parametters, you need to specify #{param.to_sym}"
+					else
+							params[param.to_sym] = hash_args[param.to_sym]
+					end
+				end
+		else
+			if args[0].length == arr_parametters.size then
+					args[0].each_with_index do |value,key|
+						params[arr_parametters[key].to_sym] = value
+					end
+			else
+				raise "Error : method need #{arr_parametters.size} parametters"
+			end
+		end
+		return params
+	end
+
+	def consoleError(value)
+		@callbackError.call(value)
+	end
+	def consoleData(value)
+		@callbackData.call(value)
+	end
+	def consoleSpeed(value)
+		@callbackSpeedOfTransfert.call(value)
+	end
+	def consoleInfo(value)
+		@callbackInfo.call(value)
+	end
+
+
+end

data/lib/HardsploitAPI/HardsploitAPI_CONSTANT.rb

@@ -0,0 +1,145 @@
+#!/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
+public
+
+	# Power on the led for each signal specified
+	# Params:
+	# +signal+:: Name of signal you want visual help (set the led)
+def signalHelpingWiring(*args)
+		parametters = HardsploitAPI.checkParametters(["signal"],args)
+		signal = parametters[:signal]
+
+		wires = Hash.new
+
+		#Parallel module
+		wires["A0"] = 0
+		wires["A1"] = 1
+		wires["A2"] = 2
+		wires["A3"] = 3
+		wires["A4"] = 4
+		wires["A5"] = 5
+		wires["A6"] = 6
+		wires["A7"] = 7
+		wires["A8"] = 8
+		wires["A9"] = 9
+		wires["A10"] = 10
+		wires["A11"] = 11
+		wires["A12"] = 12
+		wires["A13"] = 13
+		wires["A14"] = 14
+		wires["A15"] = 15
+		wires["A16"] = 16
+		wires["A17"] = 17
+		wires["A18"] = 18
+		wires["A19"] = 19
+		wires["A20"] = 20
+		wires["A21"] = 21
+		wires["A22"] = 22
+		wires["A23"] = 23
+		wires["A24"] = 24
+		wires["A25"] = 25
+		wires["A26"] = 26
+		wires["A27"] = 27
+		wires["A28"] = 28
+		wires["A29"] = 29
+		wires["A30"] = 30
+		wires["A31"] = 31
+
+		wires["D0"] = 32
+		wires["D1"] = 33
+		wires["D2"] = 34
+		wires["D3"] = 35
+		wires["D4"] = 36
+		wires["D5"] = 37
+		wires["D6"] = 38
+		wires["D7"] = 39
+		wires["D8"] = 40
+		wires["D9"] = 41
+		wires["D10"] = 42
+		wires["D11"] = 43
+		wires["D12"] = 44
+		wires["D13"] = 45
+		wires["D14"] = 46
+		wires["D15"] = 47
+
+		wires["RST"] = 48
+		wires["CE"] = 49
+		wires["OE"] = 50
+		wires["WE"] = 51
+		wires["CLK"] = 52
+		wires["WP"] = 53
+		wires["ADV"] = 54
+
+
+		#SPI module
+		wires["CS"] = 0
+		wires["SPI_CLK"] = 1
+		wires["MOSI"] = 2
+		wires["MISO"] = 3
+
+		#I2C module
+		wires["I2C_CLK"] = 0
+		wires["SDA"] = 1
+
+		begin
+			setWiringLeds(2**wires[signal])
+		rescue Exception => e
+		   raise 'UNKNOWN SIGNAL'
+		end
+	end
+
+	module USB_COMMAND
+		GREEN_LED                    =  0
+		RED_LED                      =  1
+		LOOPBACK                     =  2
+		ERASE_FIRMWARE               =  3
+		WRITE_PAGE_FIRMWARE          =  4
+		READ_PAGE_FIRMWARE           =  5
+		READ_ID_FLASH                =  6
+		START_FPGA                   =  7
+		STOP_FPGA                    =  8
+		FPGA_COMMAND                 =  9
+		FPGA_DATA 									 = 10
+		STOP_FPGA_DATA               = 11
+		START_FPGA_DATA              = 12
+		GET_SERIAL_NUMBER            = 13
+		GET_VERSION_NUMBER           = 14
+		VCP_ERROR                    = 0xFFFF
+	end
+
+	module I2C
+		KHZ_100 = 0
+		KHZ_400 = 1
+		KHZ_1000 = 2
+	end
+
+	module USB
+			OUT_ENDPOINT   = 0X02
+			IN_ENDPOINT    = 0X81
+			USB_TRAME_SIZE = 8191
+	end
+	module VERSION
+		API   = "1.1.0"
+	end
+	module USB_STATE
+		public
+		UNKNOWN_STATE   	  = -2
+		BUSY     			      = -1
+		NOT_CONNECTED  		  =  0
+		CONNECTED   		    =  1
+		UNKNOWN_CONNECTED   =  2
+		SUCCESSFUL_SEND		  =  3
+		PACKET_IS_TOO_LARGE =  4
+		ERROR_SEND		      =  5
+		SUCCESSFUL_RECEIVE  =  6
+		TIMEOUT_RECEIVE     =  7
+
+	end
+end

data/lib/HardsploitAPI/HardsploitAPI_FIRMWARE.rb

@@ -0,0 +1,311 @@
+#!/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
+public
+
+	# Wait to receive data
+	# * +pathFirmware+:: path of rpd file (vhdl)
+	# * +checkFirmware+:: boolean if check is needed (recommended false, in case issue true to check)
+	# Return true if firmware write == firmware read (slow because read the firmware for check)
+	def uploadFirmware(*args)
+			parametters = HardsploitAPI.checkParametters(["pathFirmware","checkFirmware"],args)
+			pathFirmware = parametters[:pathFirmware]
+			checkFirmware = parametters[:checkFirmware]
+
+			stopFPGA
+			eraseFirmware
+			firmwarewrite = self.writeFirmware(pathFirmware)#return array of bytes write
+			if checkFirmware == true then
+				firmwareRead = self.readFirmware(firmwarewrite.length) #return array of bytes read
+				startFPGA
+				return (firmwarewrite == firmwareRead)
+			else
+				startFPGA
+				return true
+			end
+		end
+
+		def startFPGA
+			packet = Array.new
+			packet.push HardsploitAPI.lowByte(4)
+			packet.push HardsploitAPI.highByte(4)
+			packet.push HardsploitAPI.lowByte(USB_COMMAND::START_FPGA)
+			packet.push HardsploitAPI.highByte(USB_COMMAND::START_FPGA)
+			self.sendPacket(packet)
+		end
+		def stopFPGA
+			packet = Array.new
+			packet.push HardsploitAPI.lowByte(4)
+			packet.push HardsploitAPI.highByte(4)
+			packet.push HardsploitAPI.lowByte(USB_COMMAND::STOP_FPGA)
+			packet.push HardsploitAPI.highByte(USB_COMMAND::STOP_FPGA)
+			self.sendPacket(packet)
+		end
+
+
+protected
+		def eraseFirmware
+			usbPacket = Array.new
+			usbPacket.push HardsploitAPI.lowByte(4) #length of trame
+			usbPacket.push HardsploitAPI.highByte(4)
+			usbPacket.push HardsploitAPI.lowByte(USB_COMMAND::ERASE_FIRMWARE)
+			usbPacket.push HardsploitAPI.highByte(USB_COMMAND::ERASE_FIRMWARE)
+
+			consoleInfo "Start to erase Firmware\n"
+			t1 = Time.now
+			received_data  = sendAndReceiveDATA(usbPacket,15000)
+
+			case received_data
+				when HardsploitAPI::USB_STATE::PACKET_IS_TOO_LARGE
+					return HardsploitAPI::USB_STATE::ERROR_SEND
+				when HardsploitAPI::USB_STATE::ERROR_SEND
+					return HardsploitAPI::USB_STATE::ERROR_SEND
+				when HardsploitAPI::USB_STATE::BUSY
+					return HardsploitAPI::USB_STATE::ERROR_SEND
+				when HardsploitAPI::USB_STATE::TIMEOUT_RECEIVE
+					p "TIMEOUT_RECEIVE"
+					return HardsploitAPI::USB_STATE::TIMEOUT_RECEIVE
+				else
+					t2 = Time.now 
+					delta = t2 - t1
+					consoleSpeed "Firmware erased in #{delta.round(4)} sec\n\n"
+			end
+		end
+
+		#Just path of file and wait. is a blocking function until firmware has been uploaded
+		def writeFirmware (file_path)
+			t1 = Time.now
+			consoleInfo "Upload firmware in progress\n"
+
+			usbPacket= Array.new
+			file = File.read(file_path,:encoding => 'iso-8859-1').unpack('C*') #string to array byte
+			#file = file.drop(168) #remove header of pof file
+			#file.pop(52+355000) #remove footer of pof file + about 355k of unused memory
+
+			consoleInfo "FIRMARE Write #{file.size} bytes\n"
+
+			#firmwareFile = file.clone  #copy the file in other variable to return it not just egal because copy pointer and after is the same array we want a copy -> clone
+
+			nbFullPage = file.size/256
+			nbLastByte =  file.size%256
+
+			nbFullPacket = nbFullPage/31
+			nbLastPagePacket =  nbFullPage%31
+
+			#complete last page with the last alone byte ( without full page)
+			if nbLastByte > 0 then
+				for i in 0.. (256-nbLastByte)
+					file.push 0xFF
+				end
+				nbFullPage = nbFullPage+1
+				nbLastByte = 0
+
+				#recalculating packet after complete half page to a full page
+				nbFullPacket = nbFullPage/31
+				nbLastPagePacket =  nbFullPage%31
+			end
+
+			consoleInfo "REAL Write #{file.size} bytes\n"
+
+			#Now only full page but maybe a half packet
+			#Prepare the full packet (31 pages of 256 byte each)
+			for ipacket in 0..nbFullPacket-1
+				usbPacket= Array.new
+				usbPacket.push 0  #lenght of trame modify by sendUSBPacket
+				usbPacket.push 0
+				usbPacket.push HardsploitAPI.lowByte(USB_COMMAND::WRITE_PAGE_FIRMWARE)
+				usbPacket.push HardsploitAPI.highByte(USB_COMMAND::WRITE_PAGE_FIRMWARE)
+				usbPacket.push  HardsploitAPI.lowByte((ipacket)*31)  # low byte Nb of the first page
+				usbPacket.push  HardsploitAPI.highByte((ipacket)*31)  # high byte Nb of the first page
+				usbPacket.push 31 #Nb of pages sent
+
+				start = (ipacket)*31*256
+				stop  =  (ipacket+1)*31*256 -1 #array start at index = 0
+
+				for iFile in start..stop
+					usbPacket.push HardsploitAPI.reverseBit(file[iFile])
+					#usbPacket.push file[iFile]
+				 end
+
+				percent = ipacket *100 / (nbFullPacket-1)
+
+				case self.sendPacket(usbPacket)
+					when USB_STATE::SUCCESSFUL_SEND
+							consoleSpeed "UPLOAD AT  : #{ipacket} / #{(nbFullPacket-1)} (#{percent}) %\n"
+					when USB_STATE::PACKET_IS_TOO_LARGE
+						return USB_STATE::PACKET_IS_TOO_LARGE
+					when USB_STATE::ERROR_SEND
+						return USB_STATE::ERROR_SEND
+					else
+						return USB_STATE::ERROR_SEND
+				end
+		end
+
+		#Prepare the last packet with the rest of data
+		if nbLastPagePacket >0 then
+			usbPacket= Array.new
+			usbPacket.push 0  #lenght of trame modify by sendUSBPacket
+			usbPacket.push 0
+			usbPacket.push HardsploitAPI.lowByte(USB_COMMAND::WRITE_PAGE_FIRMWARE)
+			usbPacket.push HardsploitAPI.highByte(USB_COMMAND::WRITE_PAGE_FIRMWARE)
+
+			if nbFullPacket == 0 then
+				usbPacket.push  HardsploitAPI.lowByte((nbFullPacket)*31)  # low byte Nb of the first page
+				usbPacket.push  HardsploitAPI.highByte((nbFullPacket)*31)  # high byte Nb of the first page
+			else
+				usbPacket.push  HardsploitAPI.lowByte((nbFullPacket)*31 + 1 )  # low byte Nb of the first page
+				usbPacket.push  HardsploitAPI.highByte((nbFullPacket)*31+ 1 )   # high byte Nb of the first page
+			end
+
+			usbPacket.push  nbLastPagePacket # nb of page < 31
+
+			start = (nbFullPacket)*31*256
+			stop = (nbFullPacket)*31*256 + nbLastPagePacket*256 -1
+
+			for iFile in start..stop
+				#inverted LSB MSB
+				usbPacket.push HardsploitAPI.reverseBit(file[iFile])
+			end
+
+			case self.sendPacket(usbPacket)
+				when USB_STATE::SUCCESSFUL_SEND
+						consoleSpeed "UPLOAD AT  :  100 %\n"
+				when USB_STATE::PACKET_IS_TOO_LARGE
+					return USB_STATE::PACKET_IS_TOO_LARGE
+				when USB_STATE::ERROR_SEND
+					return USB_STATE::ERROR_SEND
+				else
+					return USB_STATE::ERROR_SEND
+			end
+		end
+
+		t2 = Time.now
+		delta = t2 - t1
+		consoleSpeed "FIRMWARE WAS WRITTEN in #{delta.round(4)} sec\n"
+		return file
+	end
+
+
+	#Read firmware
+	def readFirmware(size)
+			consoleSpeed "START READ FIRMWARE \n"
+			readFirmware = Array.new
+			t1 = Time.now
+
+			nbFullPage = size/256
+			nbLastByte =  size%256
+
+
+			nbFullPacket = nbFullPage/31
+			nbLastPagePacket =  nbFullPage%31
+
+			if nbLastByte > 0 then
+				nbSuppressBytesAtLast = 256-nbLastByte
+
+				nbFullPage = nbFullPage+1
+				nbLastByte = 0
+
+				nbFullPacket = nbFullPage/31
+				nbLastPagePacket =  nbFullPage%31
+			else
+				nbSuppressBytesAtLast = 0
+
+			end
+
+			for ipacket in 0..nbFullPacket-1
+				usbPacket= Array.new
+				usbPacket.push 7
+				usbPacket.push 0
+				usbPacket.push  HardsploitAPI.lowByte(USB_COMMAND::READ_PAGE_FIRMWARE)
+				usbPacket.push  HardsploitAPI.highByte(USB_COMMAND::READ_PAGE_FIRMWARE)
+				usbPacket.push  HardsploitAPI.lowByte((ipacket)*31)  # low byte Nb of the first page
+				usbPacket.push  HardsploitAPI.highByte((ipacket)*31)  # high byte Nb of the first page
+				usbPacket.push  31 # nb of page max 31 per packet
+
+				received_data  = sendAndReceiveDATA(usbPacket,3000)
+				#p received_data
+				case received_data
+					when HardsploitAPI::USB_STATE::PACKET_IS_TOO_LARGE
+						return HardsploitAPI::USB_STATE::ERROR_SEND
+					when HardsploitAPI::USB_STATE::ERROR_SEND
+						return HardsploitAPI::USB_STATE::ERROR_SEND
+					when HardsploitAPI::USB_STATE::BUSY
+						return HardsploitAPI::USB_STATE::ERROR_SEND
+					when HardsploitAPI::USB_STATE::TIMEOUT_RECEIVE
+						return HardsploitAPI::USB_STATE::TIMEOUT_RECEIVE
+					else
+						#remove header
+						received_data = received_data.drop(7)
+
+						#reverse byte
+						received_data = received_data.collect {|x| self.reverseBit(x) }
+
+					    readFirmware.push *received_data
+
+					    if nbFullPacket == 1 then
+					    	consoleSpeed "READ AT  : 1 / 2 50 %\n"
+					    else
+					   	 	percent = ipacket *100 / (nbFullPacket-1)
+							consoleSpeed "READ AT  : #{ipacket} / #{(nbFullPacket-1)} (#{percent} %) \n"
+						end
+
+				end
+			end
+
+
+
+			#Prepare the last packet with the rest of data
+			if nbLastPagePacket >0 then
+				usbPacket= Array.new
+				usbPacket.push 7
+				usbPacket.push 0
+				usbPacket.push HardsploitAPI.lowByte(USB_COMMAND::READ_PAGE_FIRMWARE)
+				usbPacket.push HardsploitAPI.highByte(USB_COMMAND::READ_PAGE_FIRMWARE)
+
+				#Increase nb of page to add the last byte
+				if nbFullPacket == 0 then
+					usbPacket.push  HardsploitAPI.lowByte((nbFullPacket)*31)  # low byte Nb of the first page
+					usbPacket.push  HardsploitAPI.highByte((nbFullPacket)*31)  # high byte Nb of the first page
+				else
+					usbPacket.push  HardsploitAPI.lowByte((nbFullPacket)*31 + 1 )  # low byte Nb of the first page
+					usbPacket.push  HardsploitAPI.highByte((nbFullPacket)*31+ 1 )   # high byte Nb of the first page
+				end
+
+				usbPacket.push  nbLastPagePacket
+				received_data  = sendAndReceiveDATA(usbPacket,15000)
+				case received_data
+					when HardsploitAPI::USB_STATE::PACKET_IS_TOO_LARGE
+						return HardsploitAPI::USB_STATE::ERROR_SEND
+					when HardsploitAPI::USB_STATE::ERROR_SEND
+						return HardsploitAPI::USB_STATE::ERROR_SEND
+					when HardsploitAPI::USB_STATE::BUSY
+						return HardsploitAPI::USB_STATE::ERROR_SEND
+					when HardsploitAPI::USB_STATE::TIMEOUT_RECEIVE
+						return HardsploitAPI::USB_STATE::TIMEOUT_RECEIVE
+					else
+						#remove header
+						received_data = received_data.drop(7)
+
+						#reverse byte
+						received_data = received_data.collect {|x| self.reverseBit(x) }
+				    readFirmware.push *received_data
+
+				    consoleSpeed "READ AT 100%\n"
+				end
+			end
+
+			#remove a fake byte at last of reading just for transmiting
+			readFirmware.pop(nbSuppressBytesAtLast)
+
+			t2 = Time.now
+			delta = t2 - t1
+			consoleSpeed "READ FIRMWARE FINISH  in #{delta.round(4)} sec\n"
+			return readFirmware
+		end
+end