Surnia (LTE) Komplett-Backup (aller 44 Partitionen) der Original-Firmware mit ADB/Fastboot [E 2015][Stock-ROM]

[ooo]

[E 2015][Stock-ROM] Komplett-Backup (aller 44 Partitionen) der Original-Firmware mit ADB/Fastboot (nicht gerootet)

Spoiler: Voraussetzungen

Voraussetzungen

• Unveränderte Original-ROM auf dem Phone - insbesondere nicht gerootet
  (Der Befehl funktioniert aber auch mit verändertem Original-ROM und Custom ROMs, nur hat man dann nicht die Original-ROM gesichert nach der Aktion ...)
• Entwickleroptionen sind aktiviert, USB-Debugging und OEM-Entsperrung sind aktiviert
• Motorola USB-Treiber sind installiert
• ADB und Fastboot sind installiert
• Bootloader ist entsperrt
• Ein zum Phone passendes TWRP Recovery ist als Datei (recovery.img) im Verzeichnis von adb.exe bzw. fastboot.exe.
• Das TWRP Recovery wurde mit fastboot boot recovery.img gestartet - die Verbindung zwischen Phone und Rechner über ADB funktioniert (USB-Daten-Kabel ist verbunden)
• Mindestens 2,5 Gigabyte Platz auf dem Phone und dem Rechner

Die Befehlszeile (es ist wirklich nur eine Zeile ohne Zeilenumbruch)

adb shell "mkdir /sdcard/rom-dump && ls -l /dev/block/platform/soc.0/by-name 2>/dev/null | awk '{ print \"echo ;echo === Backing up partition: \"$6\";dd if=\"$8\" of=/sdcard/rom-dump/\"$6\".0p\"$8 }' | sed -e ' s:0p/dev/block/mmcblk::' | sed -e '/^.*0p4[3,4]$/ s/^/### DONT BACKUP ### /' > /sdcard/rom-dump.sh && source /sdcard/rom-dump.sh && md5sum /sdcard/rom-dump/*.0p* | unix2dos > /sdcard/rom-dump/!md5sums.txt && chown media_rw:media_rw -R /sdcard/rom-dump*" && mkdir .\rom-dump && adb pull -p /sdcard/rom-dump ./rom-dump && adb shell "rm -r /sdcard/rom-dump*"

(Diesen Befehl als eine einzige lange Zeile in einer Windows-Eingabeaufforderung im adb.exe-Verzeichnis mit copy&paste einfügen und mit Enter abschicken, nachdem man das TWRP Recovery gebootet hat.)

Man kann diese Zeile auch in eine Text-Datei (z. B. ROM-Sicherung.bat) kopieren, die im adb.exe-Verzeichnis angelegt wird und sie dann mit Maus-Doppel-Klick aus dem Datei-Manager aus starten (ganz ohne Eingabeaufforderung). - Das TWRP Recovery muss man vorher aber trotzdem über fastboot starten.

Das Ergebnis

Als Ergebnis hat man im aktuellen Verzeichnis auf dem Rechner ein Verzeichnis "rom-dump", in dem alle Partitionen des Phones/der ROM als "raw image"-Dateien abgespeichert sind.
_

Alle nötigen Dateien (adb, fastboot, TWRP Recovery und 4 Windows-Batch-Dateien) findet man als gezipptes Verzeichnis im Anhang

Moto-E-2015-ROM-Vollsicherung.zip

Spoiler: Hintergrund-Infos dazu

Hintergrund-Infos dazu

Ihr habt gerade euer brandneues Moto E 2015 4G/LTE (XT1524) vor euch liegen oder habt mit der Stock-ROM bereits einige Zeit herumgespielt, wollt es jetzt aber endlich rooten und/oder mit einer Custom ROM beflashen?

Prima, aber ...

Die meisten Root- und Flashanleitungen schreiben in einer der ersten Sätze/Anweisungen sinngemäß:

"Bitte dringend ein Backup machen, bevor ihr etwas ändert."

Dabei hüllen sich die Autoren oft regelmäßig in "vornehmes" Schweigen, was gesichert werden soll/kann und wie das überhaupt geht (i. d. R. mit einem Hinweis auf die orginale Firmware, die es aber manchmal eben nicht gibt - so auch bei diesem Phone).

Ich habe das bis jetzt auch so gemacht. - Das möchte ich an dieser Stelle einmalig ändern.

Deswegen beschreibe ich im folgenden Text (exemplarisch anhand eines Moto E 2015) detailliert, wie man sein Phone sichert, wenn es noch im Original-Zustand ist.

Voraussetzungen

Phone:
Ein Motorola Moto E 4G LTE (2. Generation, 2015, XT1524)
Das Phone ist noch nie geflasht/gerootet worden (Orginal Firmware, Stock-ROM)
(oder wurde gerade mit einer originalen Firmware auf den Ursprungszustand zurückgesetzt oder es wurde - im originalen Zustand - ein offizielles OTA-Update installiert)
Der Bootloader ist allerdings entsperrt (Status 3, unlocked) bzw. muss entsperrt werden. - Ohne das geht es leider nicht.

Rechner:
Die Motorola-Treiber sind korrekt installiert (das Phone verbindet sich korrekt)
Fastboot und ADB sind korrekt installiert (das Device wird gefunden - bei der Eingabe von adb devices bzw. fastboot devices in einer Kommando-Zeile am Rechner wird die Serien-Nr. angezeigt)
Ein TWRP Recovery Image (passend für das Phone ) wurde heruntergeladen (recovery.img o. ä.) und liegt im Verzeichnis, in dem auch adb.exe und fastboot.exe sind
_

Schritt 1: Zurücksetzen (Werksreset) über Bootloader/Fastboot Modus

Hinweis: Alle Daten im internen Speicher, alle Apps und Einstellungen gehen dabei verloren.

USB-Kabel abziehen und dann ausschalten
SIM-Karte und SD Card entfernen

[ Volume Up ] und [ Power ] Tasten gleichzeitig drücken > Bootloader Modus
[ Volume Down ] Taste solange kurz nacheinander drücken, bis "Recovery Mode" erscheint, dann [ Power ] Taste
Wenn der liegende Androide mit rotem Dreieck erscheint (man ist dann im Recovery Modus), [ Volume Down ] & [ Power ] Tasten gleichzeitig kurz drücken und schnell wieder loslassen - eventuell wiederholen - bis das Recovery Menü erscheint
[ Volume Down ] Taste solange nacheinander drücken, bis der Eintrag "wipe data/factory reset" markiert ist, danach [ Power ] Taste und mit [ Volume Down ] den Eintrag "Yes -- delete all user data" markieren. Zum Ausführen des Werksreset dann die [ Power ] drücken. und warten, bis gelb "Data wipe complete." erscheint.

Nach dem Werksreset mit der [ Power ] Taste den markierten Eintrag "reboot system now" aufrufen

Nach dem Start im Einrichtungsdialog "Deutsch" auswählen (muss man aber nicht)
W-LAN überspringen, nicht einrichten
Google Account überspringen, nicht einrichten
Keine weiteren Einstellungen vornehmen
Anfrage zur Moto-Migration abbrechen
_

Schritt 2: Vorbereitung für komplettes Backup über ADB shell

Phone und Rechner mit dem USB-Kabel verbinden

Einstellung > Über das Telefon > 7 x auf "Build-Nummer" tippen (das aktiviert den Menü-Punkt "Entwickleroptionen" ein Menü höher)
Einstellung > Entwickleroptionen > OEM-Entsperrung aktivieren > Haken setzen (Wichtig: vor und nach jedem Flashen immer überprüfen!)
Einstellung > Entwickleroptionen > USB-Debugging > Haken setzen (die darauf kurz hintereinander folgenden beiden Abfragen immer zulassen)

Tipp:
Wenn man schon mal hier ist, sollte man sich vor dem Ausschalten auch gleich in "Einstellungen > Über das Telefon" ALLE Werte abnotieren oder Screenshots davon machen, um später zu wissen, was man da eigentlich GENAU ursprünglich installiert hatte (Modell, Android-Version, Baseband-Version, Kernel-Version, Systemversion und Build-Nummer). - Ein Photo vom Bootloader (Fastboot Modus) ist auch extrem nützlich, um zu wissen, welche Bootloader-Version man VOR einem missglückten Flash-Versuch gerade hatte. - Dann hat man es bei einem Super-GAU sehr viel einfacher (z. B. die richtige Firmware zu finden oder Hilfe in Foren zu bekommen).
Diese Dateien (screenshots, Photos, Text-Dateien) kopiert man sich dann in das spätere Verzeichnis der gesicherten ROM auf dem Rechner dazu, damit man (z. B. nach einem halben Jahr noch) alles zusammen hat.
Auch die verwendeten Tools (adb/fastboot/Custom Recovery etc.) sollte man immer in dieses Sicherungs-Verzeichnis mit dazu packen und sich dort für den Ernstfall aufheben.
_

Schritt 3: Backup über ADB shell durchführen

USB-Kabel abziehen und ausschalten

[ Volume Up ] und [ Power ] Tasten gleichzeitig drücken > Bootloader Modus
Phone und Rechner mit dem USB-Kabel verbinden
Auf dem Rechner mit dem Dateiexplorer das Verzeichnis öffnen, in dem ADB/Fastboot (adb.exe, fastboot.exe) installiert wurde
In dieses Verzeichnis das zuvor heruntergeladene TWRP Recovery (recovery.img) hinein kopieren
Nur Windows: In einer freien Fläche in der Datei-Liste eine Umschalt-Taste (Shift-Taste) und die rechte Maus-Taste klicken, dann im Pop-up-Menü den Punkt "Eingabeaufforderung hier öffnen" anklicken, um eine Kommandozeile im Verzeichnis von ADB zu öffnen
(Die Linuxer öffnen stattdessen ein Terminnal und wechseln dort in das Verzeichnis mit dem TWRP Recovery Image)
In der Eingabeaufforderung/Shell jetzt das TWRP Recovery vom Recher aus booten (NICHT flashen) mit

fastboot boot recovery.img

WICHTIG:
Wenn man aus dem TWRP Recovery heraus bootet oder das Phone ausschaltet und es kommt eine Abfrage "Install SuperSU?", dann IMMER mit "Nein" / "No" / [ Do not install ] reagieren.
Auf keinen Fall rooten, da sonst die originale "system"-Partition unwiederbringlich verändert wird. - Und genau die will man ja erstmal sichern ...

(Das Phone startet auf diese Art jetzt ins TWRP Recovery, OHNE das irgendetwas dabei verändert wird. - Das ist der Trick ... In das TWRP Recovery bootet man, weil nur so eine ADB root shell zur Verfügung steht, um alle Partitionen zu sichern (mit Fastboot im Bootloader-Modus geht das nicht.)

Im TWRP Recovery > [ Mount ] > [ Disable MTP ] antippen, um ADB-Verbindungen zwischen Rechner und Phone zuzulassen
(Das ist bei manchen TWRP Recoveries ein Bug.)

In der Kommandozeile am Rechner jetzt folgenden Befehl eingeben:

adb shell

(Damit sind wir jetzt auf dem Phone in einer root shell ("#"-Prompt) und können alle originalen Partitionen sichern. - Testen mit "whoami" (Ausgabe="root"), sonst korrigieren mit "su", neuer Test)

Wie sichert man jetzt eine einzelne Partition oder mehrere/alle Partitionen des Phones, die in TWRP NICHT zur Sicherung angeboten werden?

Dazu muss man zunächst herausfinden, welche Partitionen es gibt und wie diese benannt sind:

(Im Beispiel sind adb.exe und fastboot.exe unter Windows im Verzeichnis D:\ADB\ installiert.)
Am Rechner Eingabeaufforderung (Linux: Terminal/Shell) öffnen, in das adb.exe/fastboot.exe-Verzeichnis wechseln, dort Eingabe:

ls -l /dev/block/

(Das sind übrigens kleine "L" im Befehl ... "ls" = List und "-l" = Long Format)

Ausgabe:

lrwxrwxrwx root  root  1970-01-01 01:00 bootdevice -> /dev/block/platform/soc.0

brw------- root  root  7,  0 1970-01-01 01:00 loop0
brw------- root  root  7,  1 1970-01-01 01:00 loop1
brw------- root  root  7,  2 1970-01-01 01:00 loop2
brw------- root  root  7,  3 1970-01-01 01:00 loop3
brw------- root  root  7,  4 1970-01-01 01:00 loop4
brw------- root  root  7,  5 1970-01-01 01:00 loop5
brw------- root  root  7,  6 1970-01-01 01:00 loop6
brw------- root  root  7,  7 1970-01-01 01:00 loop7

brw------- root  root  179,  0 1970-01-01 01:00 mmcblk0
brw------- root  root  179,  1 1970-01-01 01:00 mmcblk0p1
brw------- root  root  179,  10 1970-01-01 01:00 mmcblk0p10
brw------- root  root  179,  11 1970-01-01 01:00 mmcblk0p11
brw------- root  root  179,  12 1970-01-01 01:00 mmcblk0p12
brw------- root  root  179,  13 1970-01-01 01:00 mmcblk0p13
brw------- root  root  179,  14 1970-01-01 01:00 mmcblk0p14
brw------- root  root  179,  15 1970-01-01 01:00 mmcblk0p15
brw------- root  root  179,  16 1970-01-01 01:00 mmcblk0p16
brw-rw---- root  system  179,  17 2015-02-07 20:05 mmcblk0p17
brw------- root  root  179,  18 1970-01-01 01:00 mmcblk0p18
brw------- root  root  179,  19 1970-01-01 01:00 mmcblk0p19
brw------- root  root  179,  2 1970-01-01 01:00 mmcblk0p2
brw------- system  system  179,  20 1970-01-01 01:00 mmcblk0p20
brw------- root  root  179,  21 2015-02-07 20:06 mmcblk0p21
brw------- root  root  179,  22 1970-01-01 01:00 mmcblk0p22
brw-rw---- root  radio  179,  23 1970-01-01 01:00 mmcblk0p23
brw-rw---- root  radio  179,  24 1970-01-01 01:00 mmcblk0p24
brw------- root  root  179,  25 1970-01-01 01:00 mmcblk0p25
brw------- root  root  179,  26 1970-01-01 01:00 mmcblk0p26
brw------- root  root  179,  27 1970-01-01 01:00 mmcblk0p27
brw-rw---- root  mot_dbvc 179,  28 1970-01-01 01:00 mmcblk0p28
brw------- root  root  179,  29 1970-01-01 01:00 mmcblk0p29
brw------- root  root  179,  3 1970-01-01 01:00 mmcblk0p3
brw------- root  root  179,  30 1970-01-01 01:00 mmcblk0p30
brw------- root  root  179,  31 1970-01-01 01:00 mmcblk0p31
brw------- root  root  259,  0 2015-02-07 20:05 mmcblk0p32
brw------- root  root  259,  1 1970-01-01 01:00 mmcblk0p33
brw------- root  root  259,  2 1970-01-01 01:00 mmcblk0p34
brw------- root  root  259,  3 1970-01-01 01:00 mmcblk0p35
brw------- root  root  259,  4 1970-01-01 01:00 mmcblk0p36
brw------- root  root  259,  5 1970-01-01 01:00 mmcblk0p37
brw------- root  root  259,  6 1970-01-01 01:00 mmcblk0p38
brw------- root  root  259,  7 1970-01-01 01:00 mmcblk0p39
brw------- root  root  179,  4 1970-01-01 01:00 mmcblk0p4
brw------- root  root  259,  8 1970-01-01 01:00 mmcblk0p40
brw------- root  root  259,  9 1970-01-01 01:00 mmcblk0p41
brw------- root  root  259,  10 1970-01-01 01:00 mmcblk0p42
brw------- root  root  259,  11 1970-01-01 01:00 mmcblk0p43
brw------- root  root  259,  12 1970-01-01 01:00 mmcblk0p44
brw------- root  root  179,  5 1970-01-01 01:00 mmcblk0p5
brw------- root  root  179,  6 1970-01-01 01:00 mmcblk0p6
brw------- root  root  179,  7 1970-01-01 01:00 mmcblk0p7
brw-rw---- root  system  179,  8 2015-02-07 20:05 mmcblk0p8
brw------- root  root  179,  9 1970-01-01 01:00 mmcblk0p9

brw------- root  root  179,  32 1970-01-01 01:00 mmcblk0rpmb

drwxr-xr-x root  root  1970-01-01 01:00 platform

brw------- root  root  1,  0 1970-01-01 01:00 ram0
brw------- root  root  1,  1 1970-01-01 01:00 ram1
brw------- root  root  1,  10 1970-01-01 01:00 ram10
brw------- root  root  1,  11 1970-01-01 01:00 ram11
brw------- root  root  1,  12 1970-01-01 01:00 ram12
brw------- root  root  1,  13 1970-01-01 01:00 ram13
brw------- root  root  1,  14 1970-01-01 01:00 ram14
brw------- root  root  1,  15 1970-01-01 01:00 ram15
brw------- root  root  1,  2 1970-01-01 01:00 ram2
brw------- root  root  1,  3 1970-01-01 01:00 ram3
brw------- root  root  1,  4 1970-01-01 01:00 ram4
brw------- root  root  1,  5 1970-01-01 01:00 ram5
brw------- root  root  1,  6 1970-01-01 01:00 ram6
brw------- root  root  1,  7 1970-01-01 01:00 ram7
brw------- root  root  1,  8 1970-01-01 01:00 ram8
brw------- root  root  1,  9 1970-01-01 01:00 ram9

drwx------ root  root  2015-02-07 20:05 vold

brw------- root  root  253,  0 1970-01-01 01:00 zram0

Uns interessieren nur die Einträge mit

mmcblk0p<nnn>​

und

bootdevice -> /dev/block/platform/soc.0​

Die Partitions-"Namen" (z. B. für die Partition "boot") und die Zuordnung zu den Partitions-Nummern (für "boot" wäre das dann der MMC-Block "0p33" = "mmcblk0p33") findet man in der adb root shell so:

ls -l /dev/block/platform/soc.0/by-name/

(Das sind übrigens kleine "L" im Befehl ... "ls" = List und "-l" = Long Format)

Ausgabe

lrwxrwxrwx root  root  1970-01-01 01:00 DDR -> /dev/block/mmcblk0p3
lrwxrwxrwx root  root  1970-01-01 01:00 aboot -> /dev/block/mmcblk0p4
lrwxrwxrwx root  root  1970-01-01 01:00 abootBackup -> /dev/block/mmcblk0p14
lrwxrwxrwx root  root  1970-01-01 01:00 boot -> /dev/block/mmcblk0p33
lrwxrwxrwx root  root  1970-01-01 01:00 cache -> /dev/block/mmcblk0p43
lrwxrwxrwx root  root  1970-01-01 01:00 carrier -> /dev/block/mmcblk0p41
lrwxrwxrwx root  root  1970-01-01 01:00 cid -> /dev/block/mmcblk0p28
lrwxrwxrwx root  root  1970-01-01 01:00 clogo -> /dev/block/mmcblk0p30
lrwxrwxrwx root  root  1970-01-01 01:00 dhob -> /dev/block/mmcblk0p24
lrwxrwxrwx root  root  1970-01-01 01:00 factorytune1 -> /dev/block/mmcblk0p11
lrwxrwxrwx root  root  1970-01-01 01:00 factorytune2 -> /dev/block/mmcblk0p35
lrwxrwxrwx root  root  1970-01-01 01:00 frp -> /dev/block/mmcblk0p20
lrwxrwxrwx root  root  1970-01-01 01:00 fsc -> /dev/block/mmcblk0p26
lrwxrwxrwx root  root  1970-01-01 01:00 fsg -> /dev/block/mmcblk0p25
lrwxrwxrwx root  root  1970-01-01 01:00 hob -> /dev/block/mmcblk0p23
lrwxrwxrwx root  root  1970-01-01 01:00 hyp -> /dev/block/mmcblk0p7
lrwxrwxrwx root  root  1970-01-01 01:00 hypBackup -> /dev/block/mmcblk0p18
lrwxrwxrwx root  root  1970-01-01 01:00 keystore -> /dev/block/mmcblk0p39
lrwxrwxrwx root  root  1970-01-01 01:00 kpan -> /dev/block/mmcblk0p36
lrwxrwxrwx root  root  1970-01-01 01:00 logo -> /dev/block/mmcblk0p29
lrwxrwxrwx root  root  1970-01-01 01:00 logs -> /dev/block/mmcblk0p9
lrwxrwxrwx root  root  1970-01-01 01:00 metadata -> /dev/block/mmcblk0p13
lrwxrwxrwx root  root  1970-01-01 01:00 misc -> /dev/block/mmcblk0p32
lrwxrwxrwx root  root  1970-01-01 01:00 modem -> /dev/block/mmcblk0p1
lrwxrwxrwx root  root  1970-01-01 01:00 modemst1 -> /dev/block/mmcblk0p21
lrwxrwxrwx root  root  1970-01-01 01:00 modemst2 -> /dev/block/mmcblk0p22
lrwxrwxrwx root  root  1970-01-01 01:00 oem -> /dev/block/mmcblk0p40
lrwxrwxrwx root  root  1970-01-01 01:00 padA -> /dev/block/mmcblk0p12
lrwxrwxrwx root  root  1970-01-01 01:00 padB -> /dev/block/mmcblk0p19
lrwxrwxrwx root  root  1970-01-01 01:00 padC -> /dev/block/mmcblk0p37
lrwxrwxrwx root  root  1970-01-01 01:00 persist -> /dev/block/mmcblk0p31
lrwxrwxrwx root  root  1970-01-01 01:00 recovery -> /dev/block/mmcblk0p34
lrwxrwxrwx root  root  1970-01-01 01:00 rpm -> /dev/block/mmcblk0p5
lrwxrwxrwx root  root  1970-01-01 01:00 rpmBackup -> /dev/block/mmcblk0p15
lrwxrwxrwx root  root  1970-01-01 01:00 sbl1 -> /dev/block/mmcblk0p2
lrwxrwxrwx root  root  1970-01-01 01:00 sec -> /dev/block/mmcblk0p10
lrwxrwxrwx root  root  1970-01-01 01:00 sp -> /dev/block/mmcblk0p38
lrwxrwxrwx root  root  1970-01-01 01:00 ssd -> /dev/block/mmcblk0p27
lrwxrwxrwx root  root  1970-01-01 01:00 system -> /dev/block/mmcblk0p42
lrwxrwxrwx root  root  1970-01-01 01:00 tz -> /dev/block/mmcblk0p6
lrwxrwxrwx root  root  1970-01-01 01:00 tzBackup -> /dev/block/mmcblk0p16
lrwxrwxrwx root  root  1970-01-01 01:00 userdata -> /dev/block/mmcblk0p44
lrwxrwxrwx root  root  1970-01-01 01:00 utags -> /dev/block/mmcblk0p8
lrwxrwxrwx root  root  1970-01-01 01:00 utagsBackup -> /dev/block/mmcblk0p17

Aus den so gewonnenen Informationen kann man sich jetzt für genau dieses Phone (mit dieser ROM) mit Leichtigkeit einmalig ein wiederverwendbares Shell-Script erstellen, welches die gewünschten Partitionen mit dem "dd"-Befehl als .img-Dateien zunächst auf den internen Speicher (/sdcard/) sichert:

Aufbau der Befehle:

• dd = disk dump binary ("Programm", macht bit-weise 1:1-Kopien von Partitionen)
• if = "input file" Parameter (die Partition, die gesichert werden soll, wird hier unter GNU/Linux als Eingabe-"Datei" behandelt = source file = Quell-Datei)
• of = "output file" Parameter (der Name der Image-Datei, in die die Partition/deren Inhalt hineingeschrieben werden soll = Ausgabe-Datei = target file = Ziel-Datei)

Um irgendwann später wieder zu erkennen, welches Image auf welche Partition gehört, wird die Ziel-Datei in

<Partitions-Name>.<Speicher-Chip-Nummer>p<Partitions-Nummer>​

benannt.

Man könnte auch noch ein ".img" oder ".dd.img" an den Datei-Namen anhängen, um kenntlich zu machen, dass diese Datei mit dd als Image erzeugt wurde. - Der Name ist aber frei wählbar ("nichtsagenderdateiname.txt" ginge auch), soweit es die Namens-Konventionen zulassen. - Tipp: Keep it simple & straight.

Nur Windows: Die Shell-Script-Datei muss dabei im UNIX-Dateiformat erzeugt und bearbeitet werden, d. h., dass die Zeilenschaltungen entsprechend sein müssen. - Am Besten benutzt man dafür Notepad++ und stellt das über den Menü-Punkt "Edit > EOL Conversions > UNIX/OSX Format" ein, wenn man die Datei anlegt/öffnet.

Jetzt zum Inhalt der zu erstellenden Datei, die das Phone komplett auf den internen Speicher (= interne "SD Card") sichert (außer des internen Speichers selbst und User-Apps/-Einstellungen & System-Einstelllungen natürlich):

Tipp: Wer eine EXTERNE SD Card verwenden möchte, schreibt überall, wo "/sdcard/..." steht, dann "/external_sd/..." hin. - Es sollte dann natürlich eine ausreichend dimensionierte, möglichst leere externe SD Card (z. B. 8 GB) eingesetzt sein, bevor die Datei ausgeführt wird ...

Der Inhalt der fertigen Datei "rom-dump.sh":

###
### ROM dump aller Partitionen von XT1524, Motorola Moto E 4G LTE, 2nd Gen., 2015
###

# Sicherungs-Verzeichnis auf der SD Card anlegen, wenn noch nicht vorhanden - mkdir = make directory = Verzeichnis anlegen
mkdir -p /sdcard/rom-dump/

# Alten Inhalt des Sicherungs-Verzeichnisses löschen, falls vorhanden - rm = remove / -R = Rekursiv
rm -R /sdcard/rom-dump/*

# Jetzt alle Partitionen in das Verzeichnis sichern - dd = disk dump = partition kopieren / if = input file = zu sichernde Partition / of = outfile =  Ausgabedatei
dd if="/dev/block/mmcblk0p1" of="/sdcard/rom-dump/modem.0p1"
dd if="/dev/block/mmcblk0p2" of="/sdcard/rom-dump/sbl1.0p2"
dd if="/dev/block/mmcblk0p3" of="/sdcard/rom-dump/DDR.0p3"
dd if="/dev/block/mmcblk0p4" of="/sdcard/rom-dump/aboot.0p4"
dd if="/dev/block/mmcblk0p5" of="/sdcard/rom-dump/rpm.0p5"
dd if="/dev/block/mmcblk0p6" of="/sdcard/rom-dump/tz.0p6"
dd if="/dev/block/mmcblk0p7" of="/sdcard/rom-dump/hyp.0p7"
dd if="/dev/block/mmcblk0p8" of="/sdcard/rom-dump/utags.0p8"
dd if="/dev/block/mmcblk0p9" of="/sdcard/rom-dump/logs.0p9"
dd if="/dev/block/mmcblk0p10" of="/sdcard/rom-dump/sec.0p10"
dd if="/dev/block/mmcblk0p11" of="/sdcard/rom-dump/factorytune1.0p11"
dd if="/dev/block/mmcblk0p12" of="/sdcard/rom-dump/padA.0p12"
dd if="/dev/block/mmcblk0p13" of="/sdcard/rom-dump/metadata.0p13"
dd if="/dev/block/mmcblk0p14" of="/sdcard/rom-dump/abootBackup.0p14"
dd if="/dev/block/mmcblk0p15" of="/sdcard/rom-dump/rpmBackup.0p15"
dd if="/dev/block/mmcblk0p16" of="/sdcard/rom-dump/tzBackup.0p16"
dd if="/dev/block/mmcblk0p17" of="/sdcard/rom-dump/utagsBackup.0p17"
dd if="/dev/block/mmcblk0p18" of="/sdcard/rom-dump/hypBackup.0p18"
dd if="/dev/block/mmcblk0p19" of="/sdcard/rom-dump/padB.0p19"
dd if="/dev/block/mmcblk0p20" of="/sdcard/rom-dump/frp.0p20"
dd if="/dev/block/mmcblk0p21" of="/sdcard/rom-dump/modemst1.0p21"
dd if="/dev/block/mmcblk0p22" of="/sdcard/rom-dump/modemst2.0p22"
dd if="/dev/block/mmcblk0p23" of="/sdcard/rom-dump/hob.0p23"
dd if="/dev/block/mmcblk0p24" of="/sdcard/rom-dump/dhob.0p24"
dd if="/dev/block/mmcblk0p25" of="/sdcard/rom-dump/fsg.0p25"
dd if="/dev/block/mmcblk0p26" of="/sdcard/rom-dump/fsc.0p26"
dd if="/dev/block/mmcblk0p27" of="/sdcard/rom-dump/ssd.0p27"
dd if="/dev/block/mmcblk0p28" of="/sdcard/rom-dump/cid.0p28"
dd if="/dev/block/mmcblk0p29" of="/sdcard/rom-dump/logo.0p29"
dd if="/dev/block/mmcblk0p30" of="/sdcard/rom-dump/clogo.0p30"
dd if="/dev/block/mmcblk0p31" of="/sdcard/rom-dump/persist.0p31"
dd if="/dev/block/mmcblk0p32" of="/sdcard/rom-dump/misc.0p32"
dd if="/dev/block/mmcblk0p33" of="/sdcard/rom-dump/boot.0p33"
dd if="/dev/block/mmcblk0p34" of="/sdcard/rom-dump/recovery.0p34"
dd if="/dev/block/mmcblk0p35" of="/sdcard/rom-dump/factorytune2.0p35"
dd if="/dev/block/mmcblk0p36" of="/sdcard/rom-dump/kpan.0p36"
dd if="/dev/block/mmcblk0p37" of="/sdcard/rom-dump/padC.0p37"
dd if="/dev/block/mmcblk0p38" of="/sdcard/rom-dump/sp.0p38"
dd if="/dev/block/mmcblk0p39" of="/sdcard/rom-dump/keystore.0p39"
dd if="/dev/block/mmcblk0p40" of="/sdcard/rom-dump/oem.0p40"
dd if="/dev/block/mmcblk0p41" of="/sdcard/rom-dump/carrier.0p41"
dd if="/dev/block/mmcblk0p42" of="/sdcard/rom-dump/system.0p42"

### Die Partitionen "cache" und "userdata" werden nicht benötigt;
### "userdata" enthält auch den Internen Speicher (interne "SD Card"), also "/sdcard/" = "/data/media/0/", auf die wir ja sichern.
### Deswegen sind die beiden Partitionen mit "#" am Zeilenanfang auskommentiert und die Zeilen werden dadurch nicht ausgeführt = nicht gesichert.  - In "cache" ist nur Temporäres.
#dd if="/dev/block/mmcblk0p43" of="/sdcard/rom-dump/cache.0p43"
#dd if="/dev/block/mmcblk0p44" of="/sdcard/rom-dump/userdata.0p44"

# Alle von "root" erzeugten Dateien allgemein sichtbar und bearbeitbar machen (USB-/MTP-Modus und Datei-Manager)
chown media_rw:media_rw -R /sdcard/rom-dump*

(Wichtig hierbei sind vor allem die ungerootete und unveränderte "system"-Partition, sowie "boot" und "recovery". - Ohne eine verfügbare originale Firmware ist man ohne diese Partitionen ziemlich aufgeschmissen ... Für das Moto E 2015 gibt es derzeit - Stand 20.10.2015 - immer noch keine deutsche Firmware ...)

___
Ein weiteres Beispiel für eine andere, minimale Sicherungsdatei (nicht empfohlen):
Nur unvollständige "Essentials" (nur als ein weiteres Beispiel, besser alles , wie oben, sichern):

dd if="/dev/block/mmcblk0p29" of="/sdcard/rom-dump/logo.0p29"
dd if="/dev/block/mmcblk0p33" of="/sdcard/rom-dump/boot.0p33"
dd if="/dev/block/mmcblk0p34" of="/sdcard/rom-dump/recovery.0p34"
dd if="/dev/block/mmcblk0p42" of="/sdcard/rom-dump/system.0p42"

(Mit diesen Partitionen "spielt" man ja am meisten herum, wenn man z. B. Custom ROMs flasht. - Alle anderen sollte man eher in Ruhe lassen ...)
___

Kommandozeile öffnen im Verzeichnis der adb.exe und die Sicherungs-Datei "rom-dump.sh" vom Rechner auf das Phone übertragen (kopieren):

adb push rom-dump.sh /sdcard/

Jetzt führt man die Datei auf dem Phone vom Rechner aus in der Eingabeaufforderung aus, um die Sicherung anzulegen:

adb shell
. /sdcard/rom-dump.sh

(Tipp: Bitte den Rechner und das Phone in Ruhe lassen, keine Tasten drücken, nichts anfassen, bis es fertig durchgelaufen ist. - Es gibt keine "richtige" Fortschrittsanzeige. Insbesondere die ca. 1,7 GB große system-Partition lässt sich Zeit ...)

Nach diesen Aktionen (die ca. 3-5 Minuten ohne große Anzeige/Bewegung dauern - Geduld, es sind über 2 Gigabyte ...) kann man die erzeugten Image-Dateien von der SD Card (vom internen Speicher) auf den Rechner übertragen:

Kommandozeile öffnen im Verzeichnis der adb.exe:

mkdir .\sdcard\rom-dump
adb pull -p /sdcard/rom-dump .\sdcard\rom-dump

Tipp:
Man sollte sowohl auf dem Phone (Interner Speicher = /sdcard/ oder auf der externen SD Card = /external_sd/) als auch auf dem Rechner mindestens 2,5 GB freien Platz haben (besser mehr), weil dieses Backup ca. 2,1 GB groß ist. - Beim Phone (Interner Speicher = "/sdcard/") ist das durch den erfolgten Werksreset bereits gegeben - der interne Speicher von ca. 4,5 bis 5 GB steht also voll zur Verfügung.
Alternatitv kann man natürlich auch das Phone einfach neu starten und das Sicherungs-Verzeichnis "/sdcard/rom-dump/" via USB/MTP-Verbindung auf den Rechner kopieren.

Damit ist die Sicherung der originalen ROM des Phones auf den Rechner erfolgt und man kann auf dem Phone das Verzeichnis "/sdcard/rom-dump/" komplett löschen, um wieder 2 GB Platz zu schaffen.

___

Der Weg zurück zum Original (Back-to-Stock):

Hat man jetzt die Image-Dateien auf dem Rechner im Verzeichnis "rom-dump", welches wiederum im Verzeichnis mit der fastboot.exe gelandet ist (laut dem Beispiel von oben), kann man jederzeit ganz einfach Back-to-Stock mit folgenden Befehlen und benötigt keine originale Firmware dazu:
Eingabeaufforderung am Rechner öffnen, in das Verzeichnis mit fastboot.exe und dem Verzeichnis "rom-dump" mit den gesicherten Image-Dateien wechseln, Phone in den Bootloader starten (fastboot mode), mit USB verbinden und Eingabe:

fastboot flash logo .\rom-dump\logo.0p29
fastboot flash boot .\rom-dump\boot.0p33
fastboot flash recovery .\rom-dump\recovery.0p34
fastboot flash system .\rom-dump\system.0p42

fastboot erase userdata

Vorsicht: Der Befehl in der letzten Zeile (erase) würde auch die data-Partition mit den installierten User-Apps, deren Daten, allen System-Einstellungen UND den Internen Speicher löschen (interne "SD Card") = Werksreset; eine externe SD Card wird übrigens nicht dabei gelöscht.
Wer das vermeiden möchte oder Sicherungen/andere ungesicherte wichige Dateien im internen Speicher hat, lässt den letzten Befehl einfach weg.

Auch diese Befehle kann man sich in eine Windows Batch-Datei oder - bei einer Linux-Box - in ein Linux-Shell-Script schreiben; z. B. Back-To-Stock.bat Text-Datei im adb.exe/fastboot.exe-Verzeichnis anlegen.
Dann kann man mit einem einfachen Mausdoppel-Klick die Datei im Datei-Manager ausführen und einen "Werksreset" machen, um z. B. ein zuvor getestetes Custom ROM "platt" zu machen. - Aber Vorsicht: Die Datei ist dann schnell mal aus Versehen gestartet ...

WARNUNG:
Bis auf "logo", "boot", "recovery" und "system" sollte man es *wirklich* vermeiden, Partitionen zu flashen, es sei denn, man hat echte Probleme und kennt sich sehr gut aus (Brick-Gefahr).
___

Hier noch der kurze Einzeiler, der das alles auf einmal macht - für ganz Eilige

Der Vollständigkeit wegen erst nochmal die Schritte bis zur Eingabe des Befehls:
Überprüfen, ob Einstellung > Entwickleroptionen > USB-Debugging und Einstellung > Entwickleroptionen > OEM-Entsperrung angehakt sind
USB-Kabel entfernen, Phone ausschalten
Phone in den Bootloader (Fastboot Modus) starten mit [ Volume Down ] und [ Power ]
Phone und Rechner mit dem USB-Kabel verbinden
Am Rechner Eingabeaufforderung starten
In das adb.exe-Verzeichnis wechseln (wo auch die recovery.img liegt)
TWRP Recovery starten mit

fastboot boot recovery.img

Im gestarteten TWRP Recovery dann
[ Mount ] > [ Disable MTP ] antippen (falls es bereits auf "Enable MTP" steht, so lassen)

Der Test-Befehl

adb shell whoami

muss "root" ausgeben = root in the shell, bevor man den eigentlichen Befehl benutzt (Das Phone selbst muss/sollte nicht gerootet sein).

Und jetzt der eigentliche Befehl, der das Phone in einem Rutsch komplett auf den Rechner wegsichert:

Sichern ohne unnötige "cache"- und "userdata"-Partition
(Diesen Befehl als eine einzige lange Zeile in einer Eingabeaufforderung im adb.exe-Verzeichnis mit copy&paste einfügen und mit Enter abschicken)

adb shell "mkdir /sdcard/rom-dump && ls -l /dev/block/platform/soc.0/by-name 2>/dev/null | awk '{ print \"echo ;echo === Backing up partition: \"$6\";dd if=\"$8\" of=/sdcard/rom-dump/\"$6\".0p\"$8 }' | sed -e ' s:0p/dev/block/mmcblk::' | sed -e '/^.*0p4[3,4]$/ s/^/### DONT BACKUP ### /' > /sdcard/rom-dump.sh && source /sdcard/rom-dump.sh && md5sum /sdcard/rom-dump/*.0p* | unix2dos > /sdcard/rom-dump/!md5sums.txt && chown media_rw:media_rw -R /sdcard/rom-dump*" && mkdir .\rom-dump && adb pull -p /sdcard/rom-dump ./rom-dump && adb shell "rm -r /sdcard/rom-dump*"

Man kann diese Zeile auch in eine Text-Datei (z. B. ROM-Sicherung.bat) kopieren, die im adb.exe-Verzeichnis angelegt wird und sie dann mit Maus-Doppel-Klick aus dem Datei-Manager aus starten (ganz ohne Eingabeaufforderung). - Das TWRP Recovery muss man vorher aber trotzdem über fastboot starten (s. o.).

Wer "nur" das Shell-Script mit den "dd"-Befehlen zum Sichern generieren lassen und den Rest manuell machen möchte, nimmt den folgenden Befehl, um das Script auf dem Gerät im Internen Speicher anzulegen:
(Diesen Befehl als eine einzige lange Zeile in einer Eingabeaufforderung im adb.exe-Verzeichnis mit copy&paste einfügen und mit Enter abschicken)

adb shell "echo \"mkdir /sdcard/rom-dump\" > /sdcard/rom-dump.sh && ls -l /dev/block/platform/soc.0/by-name 2>/dev/null | awk '{ print \"echo ;echo === Backing up partition: \"$6\";dd if=\"$8\" of=/sdcard/rom-dump/\"$6\".0p\"$8 }' | sed -e ' s:0p/dev/block/mmcblk::' | sed -e '/^.*0p4[3,4]$/ s/^/### DONT BACKUP ### /' | cat >> /sdcard/rom-dump.sh"

(Generiert dann die Datei /sdcard/rom-dump.sh auf dem Phone)

Diese Datei kann dann mit

adb shell "source /sdcard/rom-dump.sh"

ausgeführt werden und legt eine komplette Sicherung im Verzeichnis /sdcard/rom-dump an. - Das dauert eine Weile, also Geduld ...

Diese Dateien kann man sich dann anschließend auf den Rechner holen mit

adb pull -p /sdcard/rom-dump .\rom-dump

Die Dateien liegen dann auf dem Rechner im aktuellen Verzeichnis im Unter-Verzeichnis "rom-dump". - Auch das dauert eine Weile, also Geduld ...

___