hardsploit_gui 2.2 → 2.3

data/lib/HardsploitAPI/Modules/SWD/HardsploitAPI_SWD_DEBUG.rb

@@ -0,0 +1,89 @@
+#!/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 SWD_DEBUG_PORT
+
+	def initialize(swdAPI)
+		@swdAPI = swdAPI
+		sleep(0.5)
+		@swdAPI.resetSWD
+	
+		@curAP = -1
+		@curBank = -1
+		abort(1,1,1,1,1)
+		select(0,0) 
+		
+		# power shit up
+		HardsploitAPI.instance.consoleInfo "Power shit up"
+		
+		@swdAPI.writeSWD(FALSE, 1, 0x54000000)
+		if (status() >> 24) != 0xF4 then
+			raise "error powering up system"
+			exit(0)
+		else
+			HardsploitAPI.instance.consoleInfo "POWERING UP SYTEM OK"
+		end
+	end
+
+	def getAPI
+		return @swdAPI
+	end
+
+	def idcode
+		return @swdAPI.readSWD(FALSE, 0)
+	end
+
+	def abort (orunerr, wdataerr, stickyerr, stickycmp, dap)
+		value = 0x00000000
+		(orunerr ? value |= 0x10 : value |= 0x00)
+		(wdataerr ? value |= 0x08 : value |= 0x00)
+		(stickyerr ? value |= 0x04 : value |= 0x00)
+		(stickycmp ? value |= 0x02 : value |= 0x00)
+		(dap ? value |= 0x01 : value |= 0x00)
+		@swdAPI.writeSWD(FALSE, 0, value)
+	end
+
+	def status
+		val= @swdAPI.readSWD(FALSE,1)
+		return val
+	end
+
+	def control (trnCount = 0, trnMode = 0, maskLane = 0, orunDetect = 0)
+		value = 0x54000000
+		value = value | ((trnCount & 0xFFF) << 12)
+		value = value | ((maskLane & 0x00F) << 8)
+		value = value | ((trnMode  & 0x003) << 2)
+		(orunDetect ? value |= 0x01 : value |= 0x00)
+		@swdAPI.writeSWD(False, 1, value)
+	end
+
+	def select (apsel, apbank)
+		if apsel != @curAP or apbank != @curBank then
+			@curAP = apsel
+			@curBank = apbank
+			value = 0 | ((apsel  & 0xFF) << 24) | ((apbank & 0x0F) <<  4)
+			@swdAPI.writeSWD(FALSE, 2, value)
+		end
+	end
+
+	def readRB
+		return @swdAPI.readSWD(FALSE, 3)
+	end
+	def readAP ( apsel, address)
+		adrBank = (address >> 4) & 0xF
+		adrReg  = (address >> 2) & 0x3
+		select(apsel, adrBank)
+		return @swdAPI.readSWD(TRUE, adrReg)
+	end
+
+	def writeAP (apsel, address, data)
+		adrBank = (address >> 4) & 0xF
+		adrReg  = (address >> 2) & 0x3
+		select(apsel, adrBank)
+		@swdAPI.writeSWD(TRUE, adrReg, data)
+	 end
+end

data/lib/HardsploitAPI/Modules/SWD/HardsploitAPI_SWD_MEM_AP.rb

@@ -0,0 +1,61 @@
+#!/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 SWD_MEM_AP
+
+	def initialize( dp, apsel)
+		@dp = dp
+		@apsel = apsel
+		csw(1,2) # 32-bit auto-incrementing addressing
+	end
+
+	def csw ( addrInc, size)
+	  @dp.readAP(@apsel, 0x00)
+	  val = @dp.readRB() & 0xFFFFFF00
+	  @dp.writeAP(@apsel, 0x00, val + (addrInc << 4) + size)
+	end
+
+	def idcode
+		@dp.readAP(@apsel, 0xFC)
+		id =  @dp.readRB()
+		@dp.select(0,0)
+		return id
+	end
+
+	def readWord (addr)
+	  @dp.writeAP(@apsel, 0x04, addr)
+	  @dp.readAP(@apsel, 0x0C)
+	  return @dp.readRB()
+	end
+
+	def writeWord (addr, data)
+	  @dp.writeAP(@apsel, 0x04, addr)
+	  @dp.writeAP(@apsel, 0x0C, data)
+	  return @dp.readRB()
+	end
+
+	def readBlock ( address, size)#1K boundaries and return 4K of data word alignement
+		if size < 1 then
+			raise "readBlock error : count must be >= 1"
+		end
+		if size > 1024 then
+			raise "readBlock error : size must be <= 1024 "
+		end
+		return	@dp.getAPI.read_mem32(address,size)
+	end
+
+	def writeBlock (address,data) #1K boundaries
+		if data.length < 1 then
+			raise "readBlock error : count must be >= 1"
+		end
+		if data.length > 1024 then
+			raise "readBlock error : size must be <= 1024 "
+		end
+		@dp.getAPI.write_mem16Packed(address,data)
+	end
+end

data/lib/HardsploitAPI/{SWD → Modules/SWD}/HardsploitAPI_SWD_STM32.rb

@@ -13,6 +13,7 @@ attr_accessor :ahb
 
 	def initialize(debugPort)
 		@ahb = SWD_MEM_AP.new(debugPort, 0)
+		@debugPort = debugPort
 	end
 
 	def halt
@@ -38,21 +39,31 @@ attr_accessor :ahb
 		# IMPLEMENTATION DEFINED. This means that auto address incrementing at a 1KB boundary
 		# is IMPLEMENTATION DEFINED
 
-		#But for hardsploit max 8192  so chuck to  1k
+		#But for hardsploit max 8192  so chuck to  1k due to swd limitation
 
 		packet_size = 1024
-		number_complet_packet = (size/packet_size).floor
+		number_complet_packet = (size / packet_size).floor
 		size_last_packet =  size % packet_size
-
+		startTime = Time.now
 		#number_complet_packet
-		for i in 0..number_complet_packet-1 do
- 			data.push(*self.ahb.readBlock(i*4*packet_size+address,packet_size))
-			puts "Read #{packet_size} KB : #{i}"
+		for i in 0..number_complet_packet - 1 do
+ 			data.push(*self.ahb.readBlock(i * 4 * packet_size + address, packet_size))
+			#puts "Read #{packet_size} KB : #{i}"
+			HardsploitAPI.instance.consoleProgress(
+				percent:	 100 * (i + 1) / (number_complet_packet + (size_last_packet.zero? ? 0 : 1)),
+				startTime: startTime,
+				endTime:	 Time.new
+			)
 		end
 		#Last partial packet
 		if size_last_packet > 0 then
 	  	data.push(*self.ahb.readBlock(number_complet_packet*4*packet_size+address,size_last_packet))
-				puts "Read last packet : #{size_last_packet} packet of 4 bytes"
+				#puts "Read last packet : #{size_last_packet} packet of 4 bytes"
+				HardsploitAPI.instance.consoleProgress(
+					percent:	 100,
+					startTime: startTime,
+					endTime:	 Time.new
+				)
 		end
 		return data
 	end
@@ -62,19 +73,25 @@ attr_accessor :ahb
 			packet_size = 1024 #1024
 			number_complet_packet = (data.size/packet_size).floor
 			size_last_packet =  data.size % packet_size
-
-			ahb.csw(2, 1) # 16-bit packed incrementing addressing
+			startTime = Time.now
+			#ahb.csw(2, 1) # 16-bit packed incrementing addressing
 			#number_complet_packet
 			for i in 0..number_complet_packet-1 do
 				self.ahb.writeBlock(address+i*packet_size,data[i*packet_size..i*packet_size-1+packet_size])
-				puts "Write #{packet_size} KB : #{i}"
+				#puts "Write #{packet_size} KB : #{i}"
+				HardsploitAPI.instance.consoleProgress(
+					percent: 100 * (i + 1) / (number_complet_packet + (size_last_packet.zero? ? 0 : 1)),
+					startTime: startTime,
+					endTime:Time.new
+				)
 			end
 			#Last partial packet
 			if size_last_packet > 0 then
 					self.ahb.writeBlock(address+number_complet_packet*packet_size,data[number_complet_packet*packet_size..number_complet_packet*packet_size+size_last_packet])
-					puts "Write last packet : #{size_last_packet} packet"
+					#puts "Write last packet : #{size_last_packet} packet"
+			  	HardsploitAPI.instance.consoleProgress(percent:100,startTime:startTime,endTime:Time.new)
 			end
-			ahb.csw(1, 2) # 16-bit packed incrementing addressing
+			ahb.csw(1, 2) # set to default 32-bit incrementing addressing
 	end
 
 	def flashUnlock
@@ -83,17 +100,17 @@ attr_accessor :ahb
 			@ahb.writeWord(0x40022004, 0xCDEF89AB)
 	end
 	def flashErase
-			puts "Flash unlock"
+			HardsploitAPI.instance.consoleInfo "Flash unlock"
 			flashUnlock
 			# start the mass erase
 			@ahb.writeWord(0x40022010, 0x00000204)
 			@ahb.writeWord(0x40022010, 0x00000244)
 			# check the BSY flag
 			while (@ahb.readWord(0x4002200C) & 1) == 1
-					puts "waiting for erase completion..."
+					HardsploitAPI.instance.consoleInfo "waiting for erase completion..."
 			end
 			@ahb.writeWord(0x40022010, 0x00000200)
-			puts "Finish unlock flash"
+			HardsploitAPI.instance.consoleInfo "Finish unlock flash"
 	end
 	def flashProgram
 			@ahb.writeWord(0x40022010, 0x00000201)

data/lib/HardsploitAPI/{HardsploitAPI_TEST_INTERACT.rb → Modules/TEST/HardsploitAPI_TEST_INTERACT.rb}

@@ -6,7 +6,7 @@
 #  License URI: http://www.gnu.org/licenses/gpl.txt
 #===================================================
 
-class HardsploitAPI
+class HardsploitAPI_TEST
 public
 		# Write value of 64 IO for testing purpose
 		# * +value+:: 64bits to write on all ports

data/lib/HardsploitAPI/Modules/UART/HardsploitAPI_UART.rb

@@ -0,0 +1,196 @@
+#!/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_UART
+public
+	def initialize(baud_rate:,word_width:,use_parity_bit:,parity_type:,nb_stop_bits:,idle_line_level:)
+		#to be sure the singleton was initialize
+		HardsploitAPI.instance
+		self.baud_rate 			 = baud_rate
+		self.word_width 		 = word_width
+		self.use_parity_bit  = use_parity_bit
+		self.parity_type 		 = parity_type
+		self.nb_stop_bits 	 = nb_stop_bits
+		self.idle_line_level = idle_line_level
+		setSettings
+
+		@payload_TX = Array.new
+	end
+
+	def baud_rate
+		return 150000000 / @baud_rate
+	end
+
+	def baud_rate=(baud_rate)
+		if (baud_rate >= 2400) and (baud_rate <= 1036800) then
+			@baud_rate = 150000000 / baud_rate
+		else
+			raise HardsploitAPI::ERROR::UART_WrongSettings
+		end
+	end
+
+	def word_width
+		return @word_width
+	end
+
+	def word_width=(word_width)
+		if (word_width >= 5) and (word_width <= 8) then
+			@word_width = word_width
+		else
+			raise HardsploitAPI::ERROR::UART_WrongSettings
+		end
+	end
+
+	def use_parity_bit
+		return @use_parity_bit
+	end
+
+	def use_parity_bit=(use_parity_bit)
+		if (use_parity_bit >= 0) and (use_parity_bit <= 1) then
+			@use_parity_bit = use_parity_bit
+		else
+			raise HardsploitAPI::ERROR::UART_WrongSettings
+		end
+	end
+
+	def parity_type
+		return @parity_type
+	end
+
+	def parity_type=(parity_type)
+		if (parity_type >= 0) and (parity_type <= 1) then
+			@parity_type = parity_type
+		else
+			raise HardsploitAPI::ERROR::UART_WrongSettings
+		end
+	end
+
+	def nb_stop_bits
+		return @nb_stop_bits
+	end
+
+	def nb_stop_bits=(nb_stop_bits)
+		if (nb_stop_bits >= 1) and (nb_stop_bits <= 2) then
+			@nb_stop_bits = nb_stop_bits
+		else
+			raise HardsploitAPI::ERROR::UART_WrongSettings
+		end
+	end
+
+	def idle_line_level
+		return @idle_line_level
+	end
+
+	def idle_line_level=(idle_line_level)
+		if (idle_line_level >= 0) and (idle_line_level <= 1) then
+			@idle_line_level = idle_line_level
+		else
+			raise HardsploitAPI::ERROR::UART_WrongSettings
+		end
+	end
+
+	#  write
+	# * +payload+:: Byte array want to send
+	# * Return nothing
+	def write(payload:)
+		if ( (@payload_TX.size + payload.size)  > 4000) then
+			raise HardsploitAPI::ERROR::UART_WrongTxPayloadSize
+		end
+		@payload_TX.concat payload #Add data
+	end
+
+  # sendAndReceived  ( send and receive)
+	# First write data if needed and refresh (data are sent and reveived data if needed) and you obtain available data
+	# * Return nothing
+	def sendAndReceived
+		packet = HardsploitAPI.prepare_packet
+		packet.push 0x20 #Send command
+		packet.concat @payload_TX
+
+		begin
+			tmp = HardsploitAPI.instance.sendAndReceiveDATA(packet,1000)
+		rescue
+			raise HardsploitAPI::ERROR::USB_ERROR
+		end
+
+		@payload_TX.clear
+		#remove header (4 bytes   2 for size 2 for type of command 1 dummy byte)
+		return tmp.drop(5)
+	end
+
+	# enableMeasureBaudRate
+	#
+	# *
+	def enableMeasureBaudRate
+		packet = HardsploitAPI.prepare_packet
+		packet.push 0x41 # command
+		begin
+			tmp = HardsploitAPI.instance.sendAndReceiveDATA(packet,1000)
+		rescue
+			raise HardsploitAPI::ERROR::USB_ERROR
+		end
+	end
+
+	# disableMeasureBaudRate
+	#
+	# *
+	def disableMeasureBaudRate
+		packet = HardsploitAPI.prepare_packet
+		packet.push 0x40 # command
+		begin
+			tmp = HardsploitAPI.instance.sendAndReceiveDATA(packet,1000)
+		rescue
+			raise HardsploitAPI::ERROR::USB_ERROR
+		end
+	end
+
+	# measureBaudRate
+	#
+	# * Return 32 bits period
+	def measureBaudRate
+		packet = HardsploitAPI.prepare_packet
+		packet.push 0x30 # command
+
+		begin
+			tmp = HardsploitAPI.instance.sendAndReceiveDATA(packet,1000)
+		rescue
+			raise HardsploitAPI::ERROR::USB_ERROR
+		end
+		#remove header (4 bytes   2 for size 2 for type of command)
+		tmp = tmp.drop(4)
+		period =  tmp[0] + (tmp[1] << 8 )  + (tmp[2] << 16 ) +  (tmp[3] << 24 )
+		period = period * 33.33*(10**-9) #s
+		if period > 0 then
+			return (1 / period).to_i
+		else
+			return 0
+		end
+	end
+
+	#  settings
+	# * Return nothing
+	def setSettings
+		packet = HardsploitAPI.prepare_packet
+		packet.push 0x00 #Settings command
+		packet.push ((@parity_type & 0b1) <<  7) ||  ((@use_parity_bit & 0b1) <<  6) || 	((@nb_stop_bits & 0b11) <<  4) || (@word_width & 0b1111)
+		packet.push @idle_line_level & 1
+		packet.push HardsploitAPI.lowByte(word: @baud_rate)
+		packet.push HardsploitAPI.highByte(word: @baud_rate)
+
+		begin
+			HardsploitAPI.instance.sendPacket packet
+			sleep(1)
+		#	tmp= HardsploitAPI.instance.receiveDATA(1000)
+			#remove header (4 bytes   2 for size 2 for type of command)
+		#	return tmp.bytes.drop(4)
+		rescue
+			raise HardsploitAPI::ERROR::USB_ERROR
+		end
+	end
+end