Jochem
If you want to succeed, double your failure rate.
Ja, ik wilde het niet zeggen om het verhaal niet nog meer uit te breiden, maar de aardigheid van Arduino is nu juist dat alles al een keer gedaan is en er libraries bij de vleet zijn. Een hele lap first-try bitbang-code is het laatste waar ik mee zou beginnen. Wat rew zegt zou ook mijn uitgangspunt zijn.
Daarnaast is het misschien verstandig een aansluitschema/foto van jouw setup te tonen; I2C heeft pullups nodig en dat moet dan aan dezelfde voedingsspanning als je Arduino (5V). Is de EEPROM uit de S7 gesoldeerd?
Dankje, ik zal zo kijken.
Inmiddels heb ik de seriele output nu in het formaat:
01001111
79
01010110
86
00001001
9
10100010
162
[Bericht gewijzigd door ed1973 op (31%)]
Hallo Ed,
Helaas, dat de code niet werkt, altijd lastig op afstand. De laatste output heb je gegenereerd op basis van het door jou geposte stuk code denk ik? Maar dan zonder de for loop?
Volgens mij zou die oneindig alle adressen moeten printen, en dan heb je bereikt wat je wilde toch? Of doet deze inderdaad echt alleen die 4 bytes?
Direct beginnen met de beschikbare i2c libraries was inderdaad een stuk efficiënter geweest, maar als je nu code hebt die bijna bereikt wat je wil bereiken zou ik t mooi zo laten, als je eenmaal de data uit de eeprom hebt is het toch klaar.
Groeten,
Emiel
Na kleine aanpassing is de output nu:
01001111
01010110
00001001
10100010
00000010
00000000
00011110
00000010
00000100
11110011
00110010
00110010
00110010
00110010
Het tooltje welke ik wil gaan gebruiken, S200_Password.exe , verwacht een binary image in .bin formaat.
Ik ben er dus bijna.
Kan wel binnen serial monitor, "geen regeleinde" selecteren.
[Bericht gewijzigd door ed1973 op (21%)]
Op 5 februari 2017 02:48:45 schreef ed1973:
Echter geeft de fabrikant zijn wachtwoord niet prijs (logisch)...
Dat is helemaal niet echt logisch. Op een PLC hoort geen wachtwoord thuis.
Neemt niet weg dat als de fabrikant je voor het kraken voor de rechter daagt hij wel gelijk kan krijgen, de software in de PLC is zijn eigendom. Hou daar rekening mee.
Op 8 februari 2017 12:52:48 schreef ed1973:
Kan wel binnen serial monitor, "geen regeleinde" selecteren.
Als je de onderstaande regel verwijdert (uitgaande van de door jou geposte code), stuurt de Arduino geen carriage return.
Serial.println(" "); Groeten,
Emiel
De reden dat ik het wachtwoord wil kraken, is dat ik de opslingering uit de topheater wil halen. De nieuwe topheater coil is kleiner, reageert te snel. Verder dacht ik, het is mijn machine, ik heb het recht om ermee te doen, wat ik wil.
Overigens was is mezelf zeer bewust van het feit dat het niet verstandig is, deze informatie met de leverancier te delen, en ook niet het wachtwoord te delen op internet.
Emiel, denk je dan niet, dat als ik die regel verwijder, dat telkens de inhoud van het volgende adres op het scherm verschijnt en niet achter elkaar?
Dat klopt, die regel zorgt ervoor dat na elke byte (acht bitjes) een "enter" wordt verstuurd. Je krijgt dan als output een enkele regel met alle bytes. Misschien is dat praktischer bij het kopieeren naar de bin file, afhankelijk van hoe je dat gaat doen.
Groeten,
Emiel
Zelf zou ik het bestand wegschrijven als Intel HEX , dan is het met het blote oog nog prima te controleren vervolgens heb je tientallen tooltjes om er een .BIN van te maken.
http://www.keil.com/support/docs/1584/
rew
four NANDS do make a NOR . Kijk ook eens in onze shop: http://www.bitwizard.nl/shop/
Op 8 februari 2017 14:27:47 schreef GJ_:
[...]Dat is helemaal niet echt logisch. Op een PLC hoort geen wachtwoord thuis.
Neemt niet weg dat als de fabrikant je voor het kraken voor de rechter daagt hij wel gelijk kan krijgen, de software in de PLC is zijn eigendom. Hou daar rekening mee.
Het uitlezen van een eeprom chip waar (zo goed als) plaintext een wachtwoord in staat... is geen kraken. En copyright treed pas in werking als het materiaal in kwestie VERVEELVOUDIGD wordt.
Dat neemt niet weg dat hij wel gelijk kan krijgen... 
Het password tooltje werkt
Heb een Eeprom dump van een andere Siemens PLC gevonden (24C256), en het stukje code waarin het password staat, gereduceerd tot 11 bytes. Het is inderdaad encrypted. Net ff 1 byte aangepast, en dan wijzigen 2 karakters in het wachtwoord.
Misschien nu beetje off-topic, weet ook niet of deze dingen besproken mogen worden hier. Vond het wel leuk om te delen.
Arduino, is bezig om mijn ST24C64 8KB te dumpen (net over de helft met dumpen). Heb voor de zekerheid de delay aangepast van 5ms naar 10ms:
int delay_time=10;
Jochem
If you want to succeed, double your failure rate.
Alles trager maken wil niet zeggen dat het per definitie beter werkt, maar dat merk je dan vanzelf wel.
Jochem
If you want to succeed, double your failure rate.
Als je het hebt over de typische problemen bij lange kabels en bitbangen.. ja dan wel.
Maar een I2C-clock buiten specs van de EEPROM laten lopen (ik heb niet nagekeken of het werkelijk zo is, maar iemand suggereerde dat) kan zeker problemen geven.
Nogmaals: je merkt vanzelf wel of het gaat, maar mocht het nou ineens niet meer werken dan wilde ik je gewoon even de suggestie meegeven dat dat mee kan spelen.
Op 9 februari 2017 09:04:50 schreef rew:...En copyright treed pas in werking als het materiaal in kwestie VERVEELVOUDIGD wordt. ...
Op 9 februari 2017 06:48:33 schreef ed1973:..Verder dacht ik, het is mijn machine, ik heb het recht om ermee te doen, wat ik wil..
Die gedachte is niet helemaal juist: de software is namelijk niet jouw eigendom. Dat is nooit het geval....officieel.
Ik geef zelf altijd alle projectgegevens aan de klant, inclusief de software, ondanks dat het mijn eigendom is. Ik vind namelijk dat een klant zelf in staat moet zijn om storingen op te sporen, en met een wachtwoord kan dat niet. Bovendien komt een tevreden klant toch wel terug, zelfs voor simpele storingen. Ik wantrouw daarom iedere leverancier die met wachtwoorden werkt.
Terug on-topic: als je een temperatuurregeling wilt aanpassen: sterkte. Een separate temperatuurregelaar is een stuk eenvoudiger, zeker omdat die tegenwoordig allemaal een uitstekende auto-tune hebben. Wellicht een optie om te overwegen de regeling buiten de PLC te halen.
henri62
1-st law of Henri: De wet van behoud van ellende. 2-nd law of Henri: Ellende komt nooit alleen.
int read_from_24C64(int ic_number, int memory_byte_address){
int data_read = 0;
i2c_start();
i2c_write_byte(0xA0 | (ic_number << 1)); // Send device address to eeprom
i2c_ack();
i2c_write_byte(memory_byte_address >> 8); // Send high byte of memory byte address to eeprom
i2c_ack();
i2c_write_byte(memory_byte_address); // Send low byte of memory byte address to eeprom
i2c_ack();
i2c_start();
i2c_write_byte(0xA0 | (ic_number << 1)); // @@@ Send device address to eeprom
i2c_ack();
data_read = i2c_read_byte(); // Read data byte
i2c_stop();
delay(100);
return(data_read);
}
In bovenstaande code zit een fout bij de repeated start, daar waar ik @@@ bij gezet heb. Hier hoor je het R/W bit hoog te maken, dus die regel zou moeten zijn (let op de 0xA1):
i2c_write_byte(0xA1 | (ic_number << 1)); // Send device address to eeprom
Ik lees dit soort types EEPROM met een PicKit2 uit. Comfortabel via de GUI en in naar HEX file.
Ah kijk eens aan! Dat tweede blok had ik inderdaad klakkeloos gekopieerd, en niet meer naar die bits gekeken, stom...
Bedankt voor het opmerken Henri!
Groeten,
Emiel
Het is uiteindelijk gelukt, en ik heb het password.
Ik wist dat voor een cpu 222, het wachtwoord op positie 1E74 stond en dat het encrypted wachtwoord begon met altijd 00 03 , echter het tool herkende niets mbt wachtwoorden.
Dus heb het volgende gedaan:
- 1E74 hex = 7796 dec
- opnieuw gelezen vanaf 7750 tot 7850
- binary code vertaald naar hex met Text Converter van Nookkin
- 00 03 opgezocht
- extra 00 verwijderd (de newline characters)
- de 11 bytes van het wachtwoord gesaved in .bin bestand
- geopend met S200_Password.exe , waar het wachtwoord te zien was.
Iemand vroeg mij nog om een foto te posten van hoe ik de 12C64 had aangesloten. Lach niet..... zie foto (heb geen breadboard).
Dank jullie wel allemaal voor jullie input, dit heeft me goed geholpen. Ik ga me eens verder verdiepen in I2C en hoe daarmee data uit te lezen.
Daarna de 24C64 opnieuw vastgesoldeerd met kortere draden :
En code geoptimaliseerd met als doel:
- zo snel mogelijk uitlezen
- alle binary info (0 en 1) op 1 regel
- programma stopt na laatste adres
- 5x dumpen met als resultaat 5x zelfde inhoud
De 24C64 (8KB) kon dan worden gedumpt in 840 seconden, met de volgende code:
int sda = 5;
int scl = 6;
int Memory_byte_address = 0;
int sda_read;
int delay_time=0.5;
// the setup function runs once when you press reset or power the board
void setup() {
Serial.begin(9600);
pinMode(scl, OUTPUT);
}
int power(int x, unsigned int y)
{
if( y == 0)
return 1;
else if (y%2 == 0)
return power(x, y/2)*power(x, y/2);
else
return x*power(x, y/2)*power(x, y/2);
}
int read_from_24C64(int IC_number, int Memory_byte_address)
{
int remainder, i, j, data_read=0;
int position_in_binary;
int binary_of_IC_number[] = {0, 0, 0};
int binary_of_Memory_byte_address[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
int binary_of_Data[] = {0, 0, 0, 0, 0, 0, 0, 0};
if(Memory_byte_address > 0)
{
position_in_binary=12;
while(Memory_byte_address!=1)
{
remainder = Memory_byte_address %2;
Memory_byte_address= Memory_byte_address / 2;
binary_of_Memory_byte_address[position_in_binary] = remainder;
position_in_binary--;
}
binary_of_Memory_byte_address[position_in_binary]=1;
}
/*
for(i=0;i<12;i++)
{
Serial.print(binary_of_Memory_byte_address[i]);
}
*/
pinMode(sda, OUTPUT);
digitalWrite(sda, HIGH); //
delay(delay_time); //
digitalWrite(scl, HIGH); //
delay(delay_time); //
digitalWrite(sda, LOW); // START
delay(delay_time); //
digitalWrite(scl, LOW); //
delay(delay_time); //
/***************** DEVICE ADDRESS STARTS HERE ******************/
digitalWrite(sda, HIGH); //
delay(delay_time); //
digitalWrite(scl, HIGH); //
delay(delay_time); // 1 MSB
digitalWrite(scl, LOW); //
delay(delay_time); //
digitalWrite(sda, LOW); //
delay(delay_time); //
digitalWrite(scl, HIGH); //
delay(delay_time); // 2
digitalWrite(scl, LOW); //
delay(delay_time); //
digitalWrite(sda, HIGH); //
delay(delay_time); //
digitalWrite(scl, HIGH); //
delay(delay_time); // 3
digitalWrite(scl, LOW); //
delay(delay_time); //
digitalWrite(sda, LOW); //
delay(delay_time); //
digitalWrite(scl, HIGH); //
delay(delay_time); // 4
digitalWrite(scl, LOW); //
delay(delay_time); //
digitalWrite(sda, binary_of_IC_number[0]); //
delay(delay_time); //
digitalWrite(scl, HIGH); //
delay(delay_time); // 5
digitalWrite(scl, LOW); //
delay(delay_time); //
digitalWrite(sda, binary_of_IC_number[1]); //
delay(delay_time); //
digitalWrite(scl, HIGH); //
delay(delay_time); // 6
digitalWrite(scl, LOW); //
delay(delay_time); //
digitalWrite(sda, binary_of_IC_number[2]); //
delay(delay_time); //
digitalWrite(scl, HIGH); //
delay(delay_time); // 7
digitalWrite(scl, LOW); //
delay(delay_time); //
digitalWrite(sda, LOW); //
delay(delay_time); //
digitalWrite(scl, HIGH); //
delay(delay_time); // 8 LSB
digitalWrite(scl, LOW); //
delay(delay_time); //
/***************** DEVICE ADDRESS ENDS HERE ******************/
pinMode(sda, INPUT); //
digitalWrite(scl, HIGH); //
sda_read=digitalRead(sda);//
delay(delay_time); // ACKNOWLEDGEMENT
digitalWrite(scl, LOW); //
delay(delay_time); //
/***************** WORD ADDRESS 1 STARTS HERE ******************/
pinMode(sda, OUTPUT);
/****** Don't care part starts here. This part have no relevance for 24C32 ******/
for(i=0;i<3;i++)
{
digitalWrite(sda, LOW); //
delay(delay_time); //
digitalWrite(scl, HIGH); //
delay(delay_time); // 1 MSB
digitalWrite(scl, LOW); //
delay(delay_time); //
}
/****** Don't care part ends here ******/
for(i=0;i<5;i++)
{
digitalWrite(sda, binary_of_Memory_byte_address[i]); //
delay(delay_time); //
digitalWrite(scl, HIGH); //
delay(delay_time); // 1 MSB
digitalWrite(scl, LOW); //
delay(delay_time); //
}
/***************** WORD ADDRESS 1 ENDS HERE ******************/
pinMode(sda, INPUT); //
digitalWrite(scl, HIGH); //
sda_read=digitalRead(sda);//
delay(delay_time); // ACKNOWLEDGEMENT
digitalWrite(scl, LOW); //
delay(delay_time); //
/***************** WORD ADDRESS 2 STARTS HERE ******************/
pinMode(sda, OUTPUT);
for(i=5;i<13;i++)
{
digitalWrite(sda, binary_of_Memory_byte_address[i]); //
delay(delay_time); //
digitalWrite(scl, HIGH); //
delay(delay_time); // 1 MSB
digitalWrite(scl, LOW); //
delay(delay_time); //
}
/***************** WORD ADDRESS 2 ENDS HERE ******************/
pinMode(sda, INPUT);
digitalWrite(scl, HIGH); //
delay(delay_time); //
sda_read=digitalRead(sda);// ACKNOWLEDGEMENT
delay(delay_time); //
digitalWrite(scl, LOW); //
delay(delay_time); //
pinMode(sda, OUTPUT);
digitalWrite(sda, HIGH); //
delay(delay_time); //
digitalWrite(scl, HIGH); //
delay(delay_time); //
digitalWrite(sda, LOW); // START
delay(delay_time); //
digitalWrite(scl, LOW); //
delay(delay_time); //
/***************** DEVICE ADDRESS STARTS HERE ******************/
digitalWrite(sda, HIGH); //
delay(delay_time); //
digitalWrite(scl, HIGH); //
delay(delay_time); // 1 MSB
digitalWrite(scl, LOW); //
delay(delay_time); //
digitalWrite(sda, LOW); //
delay(delay_time); //
digitalWrite(scl, HIGH); //
delay(delay_time); // 2
digitalWrite(scl, LOW); //
delay(delay_time); //
digitalWrite(sda, HIGH); //
delay(delay_time); //
digitalWrite(scl, HIGH); //
delay(delay_time); // 3
digitalWrite(scl, LOW); //
delay(delay_time); //
digitalWrite(sda, LOW); //
delay(delay_time); //
digitalWrite(scl, HIGH); //
delay(delay_time); // 4
digitalWrite(scl, LOW); //
delay(delay_time); //
digitalWrite(sda, binary_of_IC_number[0]); //
delay(delay_time); //
digitalWrite(scl, HIGH); //
delay(delay_time); // 5
digitalWrite(scl, LOW); //
delay(delay_time); //
digitalWrite(sda, binary_of_IC_number[1]); //
delay(delay_time); //
digitalWrite(scl, HIGH); //
delay(delay_time); // 6
digitalWrite(scl, LOW); //
delay(delay_time); //
digitalWrite(sda, binary_of_IC_number[2]); //
delay(delay_time); //
digitalWrite(scl, HIGH); //
delay(delay_time); // 7
digitalWrite(scl, LOW); //
delay(delay_time); //
digitalWrite(sda, HIGH); //
delay(delay_time); //
digitalWrite(scl, HIGH); //
delay(delay_time); // 8 LSB
digitalWrite(scl, LOW); //
delay(delay_time); //
/***************** DEVICE ADDRESS ENDS HERE ******************/
pinMode(sda, INPUT); //
delay(delay_time); //
digitalWrite(scl, HIGH); //
delay(delay_time); //
sda_read=digitalRead(sda);// ACKNOWLEDGEMENT
delay(delay_time); //
digitalWrite(scl, LOW); //
delay(delay_time); //
/***************** DATA STARTS HERE ******************/
for(j=0;j<8;j++)
{
digitalWrite(scl, HIGH); //
delay(delay_time); //
sda_read=digitalRead(sda);// 1 MSB
Serial.print(sda_read); //
data_read = data_read + sda_read * power(2,7-j);
digitalWrite(scl, LOW); //
delay(delay_time); //
}
/***************** DATA ENDS HERE ******************/
pinMode(sda, OUTPUT); //
digitalWrite(sda, LOW); //
delay(delay_time); //
digitalWrite(scl, HIGH); // STOP
delay(delay_time); //
digitalWrite(sda, HIGH); //
delay(delay_time); //
delay(100);
//Serial.println(" ");
return(data_read);
}
// the loop function runs over and over again forever
void loop()
{
int data;
// Number of the 24C64 IC from which data to be read
int IC_number = 0; // In the range 0 - 7
// Data read from specified memory of 24C64
data = read_from_24C64(IC_number, Memory_byte_address);
//Serial.println(data);
Memory_byte_address = Memory_byte_address + 1;
if (Memory_byte_address > 8191)
exit(0);
}
Programma staan nog wel stappen, voor een 2de en 3de 24C64, echter het lukte mij niet om die code eruit te halen.
Wederom hartstikke bedankt voor jullie input.
henri62
1-st law of Henri: De wet van behoud van ellende. 2-nd law of Henri: Ellende komt nooit alleen.
Als je hier code post, kun je de [ code ] [ / code ] er omheen zetten. Dan is het netjes geformatteerd (wel de spaties er tussen uit halen). Of direct het knopje "code" invoegen gebruiken zit links naast het Ohm teken.
P.S. Hoe ben je aan dat password tooltje gekomen? Vaak zit in dat soort spul een virus en ben ik er huiverig voor om dat zomaar ergens vandaan te plukken.
Arco
Special Member
Arco - "Simplicity is a prerequisite for reliability" - hard-, firm-, en software ontwikkeling: www.arcovox.com
En code geoptimaliseerd met als doel:
- zo snel mogelijk uitlezen
..
De 24C64 (8KB) kon dan worden gedumpt in 840 seconden
Dat is dramatisch slecht; bijna een kwartier om zo'n mini-geheugentje uit te lezen...
(mijn programmer doet 't in 2 seconden!)
Arco, heb je dan ook een Arduino ?
Of een andere programmer ?
Tooltje heb ik van :
http://files.elektroda.net/160088,s7-200_unlock.html
[Bericht gewijzigd door ed1973 op (39%)]