Class: HardsploitAPI_SPI

Inherits:
Object
  • Object
show all
Defined in:
lib/HardsploitAPI/Modules/SPI/HardsploitAPI_SPI.rb

Instance Method Summary collapse

Constructor Details

#initialize(speed:, mode:) ⇒ HardsploitAPI_SPI

Returns a new instance of HardsploitAPI_SPI.



13
14
15
16
17
18
19
 
# File 'lib/HardsploitAPI/Modules/SPI/HardsploitAPI_SPI.rb', line 13

def initialize(speed:,mode:)
	#to be sure the singleton was initialize
	HardsploitAPI.instance.connect
	self.speed=speed
	self.mode=mode
	@pulse = 0
end

Instance Method Details

#mode ⇒ Object 



46
47
48
 
# File 'lib/HardsploitAPI/Modules/SPI/HardsploitAPI_SPI.rb', line 46

def mode
	return @mode
end

#mode=(mode) ⇒ Object 



50
51
52
53
54
55
56
 
# File 'lib/HardsploitAPI/Modules/SPI/HardsploitAPI_SPI.rb', line 50

def mode=(mode)
	if ( mode < 0 ) or ( mode > 3 ) then
		raise HardsploitAPI::ERROR::SPIWrongMode
	else
		@mode = mode
	end
end

#pulse ⇒ Object 



21
22
23
 
# File 'lib/HardsploitAPI/Modules/SPI/HardsploitAPI_SPI.rb', line 21

def pulse
	return @pulse
end

#pulse=(pulse) ⇒ Object 



25
26
27
28
29
30
31
32
 
# File 'lib/HardsploitAPI/Modules/SPI/HardsploitAPI_SPI.rb', line 25

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

#speed ⇒ Object 



34
35
36
 
# File 'lib/HardsploitAPI/Modules/SPI/HardsploitAPI_SPI.rb', line 34

def speed
	return @speed
end

#speed=(speed) ⇒ Object 



38
39
40
41
42
43
44
 
# File 'lib/HardsploitAPI/Modules/SPI/HardsploitAPI_SPI.rb', line 38

def speed=(speed)
	if (speed <=2) or (speed >256) then
		raise HardsploitAPI::ERROR::SPIWrongSpeed
	else
		@speed = speed
	end
end

#spi_Generic_Dump(readSpiCommand:, startAddress:, stopAddress:, sizeMax:) ⇒ Object

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)



206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
 
# File 'lib/HardsploitAPI/Modules/SPI/HardsploitAPI_SPI.rb', line 206

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

#spi_Generic_Import(startAddress:, pageSize:, memorySize:, dataFile:, writeSpiCommand:, writePageLatency:, enableWriteSpiCommand:, clearSpiCommand:, clearChipTime:, isFLASH:) ⇒ Object

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)



112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
 
# File 'lib/HardsploitAPI/Modules/SPI/HardsploitAPI_SPI.rb', line 112

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_Interact(payload:) ⇒ Object

SPI interact

  • payload

    Byte array want to send

  • Return SPI data received



79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
 
# File 'lib/HardsploitAPI/Modules/SPI/HardsploitAPI_SPI.rb', line 79

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_SetSettings ⇒ Object 



58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
 
# File 'lib/HardsploitAPI/Modules/SPI/HardsploitAPI_SPI.rb', line 58

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