hardsploit_gui 2.2 → 2.3

data/lib/HardsploitAPI/HardsploitAPI.rb

@@ -1,133 +0,0 @@
-#!/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_relative 'HardsploitAPI_ERROR'
-
-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","callbackProgress","callbackSpeedOfTransfert"],args)
-		@callbackData = parametters[:callbackData]
-		@callbackInfo = parametters[:callbackInfo]
-		@callbackProgress = parametters[:callbackProgress]
-		@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 consoleProgress(percent:,startTime:,endTime:)
-		@callbackProgress.call(percent:percent,startTime:startTime,endTime:endTime)
-	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

@@ -1,145 +0,0 @@
-#!/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.2.1"
-	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_ERROR.rb

@@ -1,38 +0,0 @@
-#!/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

@@ -1,311 +0,0 @@
-#!/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| HardsploitAPI.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| HardsploitAPI.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