Bitcoin und SHA

Das Bitcoin-Protokoll gilt als sicher. Zu verdanken hat das Protokoll diese Eigenschaft unter anderem einem speziellen Algorithmus. Bitcoin verwendet für den Miningprozess, das Kreieren von Adressen und der Verifikation von Transaktionen eine Sha-256 Funktion. Das Bitcoin-Protokoll nutzt eine doppelte SHA-256 Funktion, was bedeutet, die Funktion wird auf die Ausgabe der Funktion angewandt. SHA-256 findet jedoch auch Anwendung in manchen der meistgenutzten Authentifizierung und Sicherheitsprotokollen wie SSL, TLS, IPsec, SSH und PGP. Auch in Unix und Linux wird der Algorithmus zum hashen von Passwörtern genutzt. Wie der Name vermuten lässt, ist der Output der Funktion 256 Bits lang.

Eine kurze Historie zu SHA-256

SHA-256 wurde 2002 als Reaktion auf erfolgreiche Angriffe auf die SHA-1 Hashfunktionen von der NSA entwickelt und vorgestellt. Auf einer National Institute of Standards and Technology (NIST) Konferenz im Jahr 2005 wurde die Umstellung von SHA-1 auf SHA-2 empfohlen und als Standard etabliert. Im Jahr 2012 wurde Keccak zum SHA-3 Algorithmus gewählt. SHA-256 sowie einige andere Algorithmen der SHA-2 Familie werden vom Bundesamt für Sicherheit in der Informationstechnik (BSI) jedoch immer noch als sicher eingestuft.

Die Eigenschaften von SHA-256

Es gibt 3 Eigenschaften welche den Grundstein des SHA-256 Algorithmus und seiner Sicherheit liefern. Um die nachfolgenden Eigenschaften einzuordnen, hilft es sich zu verdeutlichen, dass 2²⁵⁶ mehr ist als die Anzahl der Atome in dem uns bekannten Universum.

1. Es ist nahezu unmöglich die ursprünglichen Daten aus dem Hashwert zu rekonstruieren. Angenommen dies wäre das Ziel eines Angreifers, so müsste dieser mit einer Exhaustionsmethode (Bute-Force Attack) 2²⁵⁶ Versuche durchführen. Die Anzahl der benötigten Versuche ist schier zu groß, um dies überhaupt in Erwägung zu ziehen.
2. Es ist äußerst unwahrscheinlich zweimal denselben Hashwert zu erhalten, da es 2²⁵⁶ verschiedene Möglichkeiten gibt.
3. Eine minimale Veränderung der Daten verändert den Hashwert so, dass nicht ersichtlich ist, dass der neue Hashwert aus einem ähnlichen Datensatz kreiert wurde.

Beispiel Output der SHA-256 Funktion

Um die Funktionsweise und Punkt 3 zu verdeutlichen ein Nehmen wir die Wörter „Beispiel“ und „Beispiele“.

Der Output der SHA-256 Funktion als Hexadezimal von „Beispiel“ ist: 2071c7736acd16f6cea3727d3b7ecde53f4c2e97b421f3550248e19d7309c636

Der Output der SHA-256 Funktion als Hexadezimal von „Beispiele“ ist: 147790983143d584d88c22ad1a14f128c3d55e3dea3d92ec400e930a04031fb9

Es lässt sich offensichtlich, anhand der Hashwerte, kein Rückschluss auf die Daten ziehen.

SHA Funktionen bilden das Fundament einer Vielzahl von Authentifizierung und Sicherheitsprotokollen.

Auch Blockchain Protokolle wie z.B. Bitcoin nutzen diese und ähnliche Algorithmen, um Sicherheit Ihrer Transaktionen und des Miningprozesses zu gewährleisten. Die SHA-256 Funktion bietet eine optimale Balance zwischen Kollisionsresistenz und Effizienz für das Bitcoin Protokoll. Die Länge der Daten welche gehasht werden ist für die Länge des Outputs irrelevant. Dieser beträgt immer 256 bits. Der 64 Zeichen lange Hexadezimalwert, welcher z.B. einen Block der Bitcoin Blockchain repräsentiert eignet sich somit optimal um zu gewährleisten das die Daten eines Blocks unverändert sind. Jeder Knotenpunkt (Node) kann somit die Integrität eines Blockes validieren. Da eine Blockchain neue Blöcke chronologisch ankettet und der Hash des aktuellen Blocks auf dem vorhergehenden Block basiert, sind Daten unveränderbar auf der Blockchain gespeichert.

Hat Euch dieser Beitrag gefallen? Lasst uns und dem Auto Stable Blocks ein Like da und kommentiert was das Zeug hält!

Der Beitrag SHA-256 und Bitcoin – feat. Stableblocks erschien zuerst auf Informatik Guru.

Beispiel

Wenn wir bspw. einen Zahlenstrahl von 2 bis 100 sieben wollen, so starten wir zunächst mit der 2. Diese wird als Primfaktor erkannt, woraufhin alle Vielfachen gestrichen werden, also 4,6,8,10,12 usw.
Sind alle Vielfachen der 2 eliminiert, fahren wir mit der 3 fort. Also werden 6,9,12,15,18,21 usw. gestrichen. Hierbei können die bereits als Vielfache von 2 identifizierten, also bereits gestrichenen, Zahlen natürlich übersprungen werden. Anschaulich visualisiert sieht das so aus:

Von https://en.wikipedia.org/wiki/de:User:SKopp“ als eigenes Werk im deutschen Wikipedia veröffentlich

Implementierung

Zahlenstrahl

Lasst uns das Ganze nun Step-by-Step als Programm umsetzen.
Hierfür definieren wir als erstes unsere Endzahl, also die Obergrenze des Zahlenstrahls den wir sieben möchten, sowie die Wurzel dieser Zahl. Denn wenn wir die Vielfachen aller Zähler, welche größer als die Wurzel der Zahl sind, eliminiert haben sind alle übrigen Elemente automatisch Primzahlen.

Wie anfänglich gesagt geht es um eine stark vereinfachte und keinesfalls optimierte Variante. Wir „streichen“ also als erstes die 1, damit diese abschließend nicht in der Ausgabe unserer Primfaktoren erscheint:

Durchlauf der potenziellen Primfaktoren

Nun benötigen wir zunächst eines äußere Schleife in der wir alle Potenziellen Primfaktoren, also die Zahlen von 2 bis zur Wurzel unserer Endzahl durchlaufen, gefolgt von einer Prüfung, ob die betreffende Zahl bereits „gestrichen“ wurde:

Streichen der Vielfachen

Ist die Zahl noch nicht als Vielfaches eines vorangegangenen Primfaktors erkannt und somit noch im Rennen, so streichen wir ihre Vielfachen:

Hierbei beginnen wir absichtlich mit dem zweifachen des Primfaktors, sodass dieser selbst in unserem Zahlenstrahl verbleibt.

Ausgabe des gesiebten Zahlenstrahl

Abschließend erfolgt eine Ausgabe aller verbliebenen Zahlen:

Inklusive der Ausgabe aller gefundenen Primzahlen, sowie der benötigten Laufzeit ergibt sich dann folgendes kleine Script:

Optimierungen

Um die Laufzeit und die Speichernutzung zu optimieren gibt es hier nun unterschiedliche Optimierungsansätze. Der erste, einfachste und effektivste wäre es alle geraden Zahlen bereits beim Aufbau des Zahlenstrahls außenvor zu lassen. Bei einem so kleinen Zahlenstrahl wie in unserem Beispiel fällt der Unterschied nicht wirklich auf, wenn man jedoch eine deutlich größere Menge Zahlen sieben möchte, so ist der Unterschied immens. Denn hier gilt die ersten Durchläufe benötigen am längst, da hier, wie oben in der Grafik schön abgebildet ist, die meisten Zahlen gestrichen werden müssen. Mit zunehmendem Fortschritt wird das Streichen der Vielfachen immer schneller und schneller.

Hat Euch dieser Beitrag gefallen? Dann lasst uns doch einen Like auf Facebook oder Instagram da, oder kommentiert einfach direkt hier! Schickt uns gerne Eure Implementierungen oder Verbesserungsvorschläge des Sieb des Eratosthenes. Welche Siebe kennt Ihr noch ? Habt ihr Interesse an einer schematischen Implementierung des Atkins Sieve? Schreibt uns!

Der Beitrag Sieb des Eratosthenes – Primzahlen sieben in PowerShell erschien zuerst auf Informatik Guru.

#Starten der "Stoppuhr" unter Zuhilfenahme der .NET-Klasse system.diagnostics.stopwatch$timetracker = [system.diagnostics.stopwatch]::startNew()

#In $elapsedtime werden die zur Verarbeitung benötigten Sekunden seit dem Start der Stoppuhr geschrieben

#Ausgabe der Laufzeit des Scripts
write-host $timetracker.Elapsed.seconds "Sekunden`t" $timetracker.Elapsed.Milliseconds "Millisekunden"

Als nächstes gehen wir das Hauptproblem an, das Hochzählen der Fibonacci-Reihe.
Die Fibonacci-Reihe ist die unendliche Folge natürlicher Zahlen, beginnend mit 0,1,1, in welcher sich die nächste Zahl immer aus der Summe der beiden vorangegangenen ergibt.
Sie weist einige interessante mathematische Besonderheiten auf und steht in Zusammenhang mit dem Pascalschen Dreieck, sowie dem goldenen Schnitt, aber das ist eine andere Geschichte.

Hierfür benötigen wir einen Ausgangspunkt, sowie drei Variablen. In einer der beiden speichern wir die Summe und tauschen dann die Werte durch vor der nächsten Summenbildung.
Bspw: A = 1; B = 1 => C = 2
Im nächsten Durchlauf wäre es dann: A = 1; B = 2 => C = 3

Um die Operation im Rahmen der Schleife, welche wir benötigen um den Durchlauf zu automatisieren bis zur Grenze von 4.000.000, zu wiederholen müssen wir also die Werte tauschen.
Anhand unseres obenstehenden Beispiels wäre das dann nach dem ersten Durchlauf
A = B; B = C
In Summe ergibt das:

$fibosumme = 1;
$fibonacci1 = 0;
$fibonacci2 = 1;

while($fibosumme -lt 4000000){
    $fibosumme = $fibonacci1 + $fibonacci2;
    $fibonacci1 = $fibonacci2;
    $fibonacci2 = $fibosumme;
}

Zuletzt müssen wir beim hochzählen der Fibonacci-Folge lediglich noch prüfen, ob die nächste gefundene Zahl gerade ist und diese gegebenenfalls aufaddieren.

if($fibosumme % 2 -eq 0){
    $gesamtsumme += $fibosumme;
}

Nun müssen wir das Ganze nur noch zusammensetzen und mit einer Ausgabe versehen, welche uns die Summe präsentiert und die Aufgabe ist gelöst:

Weitere Project Euler-Aufgaben und andere Tutorials und Tipps im Kontext Powershell werden zeitnah folgen.
Apropos folgen, folgt Ihr uns eigentlich schon auf Facebook oder Instagram?
Falls nicht ist jetzt der perfekte Zeitpunkt das nachzuholen.
Gerne könnt Ihr Euch mit Kommentaren hier oder auf einem der Social Media Kanäle mit Ideen, Wünschen oder Kritik einbringen.
Wenn Ihr eine konkrete Frage zu Powershell Scripting oder Programmierung allgemein habt, könnt Ihr diese ebenfalls gerne auf den oben genannten Kanälen stellen wo wir diese gerne aufgreifen und entweder persönlich beantworten oder im Rahmen eines Beitrags thematisieren!

Der Beitrag Project Euler 2 – Powershell Edition erschien zuerst auf Informatik Guru.

Wir starten hier nun erstmal bei Aufgabe 1 von Project Euler in Powershell.
Dafür sehen wir uns zunächst einmal die Problemstellung an die auf der Website ( Euler 1 ) wie folgt beschrieben wird:

If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.
Find the sum of all the multiples of 3 or 5 below 1000.

Wir suchen also die Summe aller Vielfachen von 3 und 5 unter 1000.

Hierfür gibt es nun mehrere Ansätze, da es sich um eine Herangehensweise für Anfänger handeln soll, belassen wir es bei der einfachen Lösung.

Sehen wir uns die Bausteine des Scripts zunächst mal der Reihe nach an:

Zunächst starten wir unter Zuhilfenahme der .NET-Klasse system.diagnostics.stopwatch eine Stoppuhr um die Laufzeit unseres Scripts zu messen. Bei den ersten paar Aufgaben werden wir hier kaum merkliche Unterschiede feststellen mit unterschiedlichen Lösungsvarianten, was sich allerdings mit zunehmender Schwierigkeit und Komplexität der Probleme von Aufgabe zu Aufgabe drastisch ändert.

#Starten der "Stoppuhr" unter Zuhilfenahme der .NET-Klasse system.diagnostics.stopwatch$timetracker = [system.diagnostics.stopwatch]::startNew()

#In $elapsedtime werden die zur Verarbeitung benötigten Sekunden seit dem Start der Stoppuhr geschrieben
$elapsedtime = $timetracker.Elapsed.Seconds

#Ausgabe der Laufzeit des Scripts
write-host "Die Gesamtlaufzeit betrug " $elapsedtime " Sekunden."

Warum haben wir uns hier für eine entliehene .NET-Klasse entschieden anstatt das über ein Powershell-Kommando wie bspw. das CMDlet Measure-Command zu lösen?
Ganz einfach: Aus Gewohnheit und weil bei Measure-Command ohne weiteres pipen die Ausgabe der zu erfolgenden Kommandos nie im stdout, also für uns sichtbar in der Konsolenausgabe landen.

Als nächster Baustein folgt die Schleife mit der wir über die gewünschten Zahlen iterieren, das „Herzstück“ des Scripts. Hierbei initialisieren wir im Schleifenkopf einen Zähler, welcher auch als aktuell zu prüfende Zahl dient. Vorab deklarieren wir eine Summenvariable, in welcher wir gleich die entsprechenden Zahlen aufaddieren werden und weisen dieser den Wert 0 zu.

#Initialisieren der Summenvariable
$Summe = 0

#Kopf der For-Schleife, mit welcher wir die Zahlen von 1 bis 999 durchlaufen
for($zaehler = 1;$zaehler -lt 1000; $zaehler ++){

#Prüfung ob die aktuelle Zahl durch 3 oder 5 teilbar ist
    if($zaehler % 3 -eq 0 -or $zaehler % 5 -eq 0){

#Falls ja, wird die aktuelle Zahl zur bisherigen Summe addiert
        $Summe = $Summe + $zaehler
    }
}

Als letzten Baustein fügen wir abschließend noch eine Ausgabe unseres Ergebnisses hinzu.
Hier verwenden wir des Weiteren den Parameter -NoNewline für das Kommando Write-Host, welcher das automatische Anfügen eines Zeilenumbruches unterbindet. Dadurch können wir die Summe selbst farbig innerhalb der selben Zeile ausgeben wie die vorangestellte Info.
Das ist zwar nicht Teil der Aufgabe, dient aber der Übersichtlichkeit unserer zugegebenermaßen kleinen Ausgabe und wir lernen schonmal einen neuen Parameter kennen.

#Ausgabe der Info bzgl. der Summe
write-host "Die Summe der Vielfachen von 3 oder 5 unter 1000 lautet:`t" -NoNewline  

#Ausgabe der Summe selbst
write-host $Summe -ForegroundColor Yellow

Zusammengesetzt ergibt sich hieraus nun folgendes kleine Script, welches die Problemstellung der Aufgabe 1 von Project Euler erfolgreich absolviert:

Weitere Project Euler-Aufgaben und andere Tutorials und Tipps im Kontext Powershell werden zeitnah folgen.
Apropos folgen, folgt Ihr uns eigentlich schon auf Facebook oder Instagram?
Falls nicht ist jetzt der perfekte Zeitpunkt das nachzuholen.
Gerne könnt Ihr Euch mit Kommentaren hier oder auf einem der Social Media Kanäle mit Ideen, Wünschen oder Kritik einbringen.
Wenn Ihr eine konkrete Frage zu Powershell Scripting oder Programmierung allgemein habt, könnt Ihr diese ebenfalls gerne auf den oben genannten Kanälen stellen wo wir diese gerne aufgreifen und entweder persönlich beantworten oder im Rahmen eines Beitrags thematisieren!

Der Beitrag Project Euler 1 – Powershell Edition erschien zuerst auf Informatik Guru.

Innerhalb der ISE habt ihr, wie ihr es ggf. aus anderen IDEs gewohnt seid, viele Comfort-Funktionen, wie bspw. automatische Vorschläge von Parametern, eine Befehlsübersicht oder bspw. automatisches einfügen von Code-Snippets wenn Ihr STRG + J drückt.
Gerade letzteres kann ich aus meinem Alltag in der Nutzung von Powershell wärmstens empfehlen.

Zur Nutzung der Powershell kann ich alles in allem sagen, dass ich sie für die eierlegende Wollmilchsau der Script- bzw. Programmiersprachen für viele, viele Aufgaben unter Windows halte.

Unabhängig davon ob man nun Betriebssystemaufgaben automatisieren, davon unabhängige Tasks programmieren, einfach etwas rumspielen (bspw. Projekt Euler 😉 ) oder seine Azure Cloud orchestrieren möchte, Powershell hat für unwahrscheinlich viele Ansätze die richtigen Werkzeuge parat.

Zum einen gibt es wahnsinnig viele mitgelieferte sogenannte CMDlets, über welche Ihr euch mit dem Befehl Get-Command einen Überblick verschaffen könnt, zum anderen gibt es reichhaltige Angebote seitens einer stetig wachsenden Community aus Entwicklern.

Ich für meinen Teil arbeite dienstlich viel mit der iTextsharp-Bibliothek, welche unter anderem das automatisierte Auslesen und Befüllen von PDF-Dokumenten ermöglicht um nur ein Beispiel von vielen zu nennen.

In kommenden Block-Beiträgen werden werden wir auf Besonderheiten, Tipps, Kniffe und Code-Beispiele in Powershell eingehen.

Wenn ihr Vorschläge, Eindrücke, Wünsche oder Ideen zum Thema habt, postet diese gerne hier, oder auf einem unserer Social Media Kanäle als Kommentar und bringt euch ein.
Thematisch gilt hier ganz klar:

Der Beitrag Einstieg Powershell – Was ist diese blaue cmd? erschien zuerst auf Informatik Guru.

Each new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with 1 and 2, the first 10 terms will be:

1, 2, 3, 5, 8, 13, 21, 34, 55, 89, …

By considering the terms in the Fibonacci sequence whose values do not exceed four million, find the sum of the even-valued terms.

Wir wollen also die Summe aller geraden Fibonacci-Zahlen unter 4.000.000 finden.

Eine mögliche Lösung kann man in Perl wie folgt umsetzen:

#Aufgabenstellung
#Each new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with 1 and 2, the first 10 terms will be:

#1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...

#By considering the terms in the Fibonacci sequence whose values do not exceed four million, find the sum of the even-valued terms.



#übliche Shebang-Zeile
#!/usr/bin/perl

#Compiler-Flags die übliche Programmierfehler erkennen und aufzeigen
use strict;
use warnings;

#Deklaration der Variablen
my $fiboone = 1;
my $fibotwo = 1;
my $result = 0;
my $sum = 0;
#Schleifenkopf der While-Schleife, welche läuft bis $result, unsere Variable für den Dreieckstausch der Zahlen 4.000.000 erreicht
while($result < 4000000){
  #If-Condition welche überprüft ob der in $result befindliche Wert gerade ist (Modulo 2 = 0)
  if(($result % 2) == 0){
    #Falls ja wird der $result befindliche Wert zur Summe aller bisher gefunden geraden Fibonacci-Zahlen addiert
    $sum += $result;
  }
  #Dreieckstausch der beiden Zahlen-Variablen sowie der Hilfsvariable
  $result = $fiboone + $fibotwo;
  $fibotwo = $fiboone;
  $fiboone = $result;
}
#Ausgabe des Ergebnis
print "\nDas Ergebnis lautet:  $sum";

Dies ist natürlich nur eine mögliche Lösung und sie wurde des Weiteren nicht in Sachen Performance optimiert.
Wenn Ihr Optimierungsvorschläge, oder alternative Lösungen habt, so postet sie doch hier oder lasst sie uns per Mail an senpai@informatik-guru.de zukommen.

Wenn Euch der Beitrag gefallen hat, so kommentiert ihn doch, oder lasst uns ein Like auf Facebook oder ein Follow auf Instagram da.
Gerne könnt Ihr auch unseren Newsletter abbonieren, um immer über die neuesten Entwicklungen des Informatik-Guru auf dem Laufenden gehalten zu werden.

Der Beitrag Project Euler 2 – Perl for beginners erschien zuerst auf Informatik Guru.

Find the sum of all the multiples of 3 or 5 below 1000.

Wir wollen also die Summe aller durch 3 oder 5 teilbaren Zahlen unter 1000 finden.

Eine mögliche Lösung kann man in Perl wie folgt umsetzen:

#übliche Shebang-Zeile
#!/usr/bin/perl

#Compiler-Flags, die übliche Programmierfehler erkennen und aufzeigen
use warnings;
use strict;

#Deklaration eines Zahlenfeldes von 1 bis 999 sowie der Variable, welche wir später für das Errechnen der Summe verwenden
my @zahlenfeld = 1..999;
my $summe = 0;

#Schleifenkopf einer Foreach-Schleife, welche alle Elemente des oben deklarierten Zahlenfeldes durchläuft
foreach(@zahlenfeld){
  #If-Condition, welche True liefert, also ausgelöst wird, wenn die aktuell bearbeitete Zahl weder durch 3 noch durch 5 teilbar ist
  if($_ % 3 != 0 && $_ % 5 != 0){
    #Die aktuelle Zahl als auf "undef" setzen, wonach sie keinen Wert mehr enthält
    $_ = undef;
  } #Ende IF
} #Ende der Schleife

#Schleifenkopf einer Foreach-Schleife, welche alle Elemente des oben deklarierten Zahlenfeldes durchläuft
foreach(@zahlenfeld){
  #If-Condition, welche ausgelöst wird, wenn das aktuelle Element einen Wert enthält, also nicht "undef" ist
  if($_){
    #Hier wird der Summe der aktuelle Wert hinzugefügt
    $summe += $_;
  } #Ende IF
} #Ende der Schleife

#Zum Abschluss eine Ausgabe, welche uns das Ergebnis präsentiert
print "Die Summe aller durch 3 oder 5 teilbaren Zahlen unter 1000 lautet:\n$summe\n";

Wir werden uns bald weiteren projecteuler-Aufgaben annehmen und diese in unterschiedlichen Programmier- und Scriptsprachen lösen.
Gerne könnt Ihr eure Variante der Lösung in den Kommentaren posten.
Falls Ihr eine coole Idee habt, welches Programmierproblem wir hier thematisieren könnten, so lasst uns davon wissen.

Wenn Euch der Beitrag gefallen hat, so kommentiert ihn doch, oder lasst uns ein Like auf Facebook oder ein Follow auf Instagram da.
Gerne könnt Ihr auch unseren Newsletter abbonieren, um immer über die neuesten Entwicklungen des Informatik-Guru auf dem Laufenden gehalten zu werden.

Der Beitrag Project Euler 1 – Perl for beginners erschien zuerst auf Informatik Guru.

Heute befassen wir uns mal mit einem Goodie für die kreativen unter uns.
Die meisten, die bereits im beruflichen Umfeld mit Adobe InDesign gearbeitet haben, kennen das leidige Problem…
Mehrere Indesign-Versionen, mehrere unterschiedliche .indd-Dateien, viele Probleme.
Um den Umgang mit solchen Situationen zu vereinfachen wurde von einem Mitglied unseres Teams in der Vergangenheit untenstehendes Script entwickelt.
Dieses muss per Automator/Skript-Editor unter OS X als Dienst (.scpt) abgespeichert und einem Order als Ordneraktion hinzugefügt werden (Rechtsklick auf den Ordner und dann unter „Dienste“ auf „Ordneraktionen konfigurieren“).
Sobald dies geschehen ist hat man einen selbst gebauten „Hotfolder“, mit welchem es möglich ist, Dateien zu konvertieren.
Hierbei wird das aktuelle CC auf dem eigenen Rechner kurz aufgerufen, mit selbigem wird die Datei, welche man zuvor in den Ordner gelegt hat, geöffnet und als .idml-Datei im selben Verzeichnis wieder gespeichert.
Somit sind alle händischen Konvertierungen und Inkompatiblitätsprobleme hinfällig!

on adding folder items to thisFolder after receiving theItems
     try
         tell application "Finder"
             set theName to name of thisFolder
             set theCount to length of theItems
        repeat with f in theItems
            set work_file to f as alias
            --Den Ordnerpfad des zu verarbeitenden Files finden: 
            set the_container to (container of work_file) as string
            --Den Filename ohne Endung in eine Variable schreiben:
            set the_name to name of work_file
            --Die Endung in eine Variable schreiben:
            set the_extension to name extension of work_file
            --display dialog the_name & the_extension #Debug-Ausgabe um zu testen, ob die Variablen korrekt befuellt sind
            if the_extension is not "" then set the_name to (text 1 thru ((length of the_name) - (length of the_extension) - 1) of the_name)


            if the_extension is not "indd" then exit repeat -- # simulated `continue`




            tell application id "com.adobe.InDesign" -- "Adobe InDesign"
                set «class UIAc» of «class pScr» to «constant elnteNvr»
                open work_file without «class psiw»
                tell document 1
                    «event K2  expt» without «class imot» given «class exft»:«constant eXftidml», «class kfil»:(the_container & the_name & ".idml")
                    «event CoReclos» given «class svop»:no
                end tell
            end tell
        end repeat
    end tell
on error the error_message number the error_number
    set the error_text to "Error: " & the error_number & ". " & the error_message
    -- Im folgende wird eine Subroutine aufgerufen, welche eine Zeile in ein Logfile auf dem Desktop schreibt
    -- Falls das Log bereits existiert, so wird lediglich eine Zeile angefuegt
    my write_error_log(the error_text)
end try

end adding folder items to

on write_error_log(this_error)
    set the error_log to ((path to desktop) as text) & "Script Error Log.txt"
    try
        open for access file the error_log with write permission
        write (this_error & return) to file the error_log starting at eof
        close access file the error_log
    on error
        try
            close access file the error_log
        end try
    end try
end write_error_log

Weitere interessante InDesign Skripte findet Ihr hier: https://indesignscript.de

Falls Euch das Skript genutzt und/oder gefallen hat, so lasst uns doch einen Like auf Facebook, ein Follow auf Instagram oder ein Subscribe für unseren Mail-Newsletter da, um fortwährend über neue, informative und lustige Beiträge vom Informatik-Guru informiert zu werden!

Der Beitrag InDesign-Konvertierung von INDD zu IDML erschien zuerst auf Informatik Guru.