Beiträge von Yjuq

Hey, ich hab mir mal die Mühe gemacht und dein Skript ein wenig umgeschrieben sodass es effizienter und einfacher zu handhaben ist. Die Variablen hab ich jetzt ein wenig umbenannt weil ich's so besser lesen konnte xD

Kannst sie ja auch wieder selber umbenennen. Sind ja nicht so viele...

Hi, ich habe das Skript jetzt nicht ausgeführt sondern nur in den Code geguckt. (Bin zu faul bei meiner Bambusleitung mir die Bass.dll runter zu laden ^^)

Ist die FPS Anzeige richtig?
Soweit ich weiß steht FPS für Frames per Second oder so ähnlich. Müsste so korrekt sein. (Obwohl ich persönlich auf den Gebrauch von AdlibRegister verzichten würde...)

Uuund wie findet ihr meinen Schreibstil?
Nagut, jeder hat einen eigenen mit der Zeit entwickelt. Solange man den Code leicht verfolgen kann ist dieser also nicht schlecht. Alles abdere hängt an den persönlichen Vorzügen ab. Ich beispielsweise setze vor jeder Variable noch einen Präfix. Dann unterteile ich meinen Code in sinnvolle Codeabschnitte und mache dies sehr deutlich (Benutze das + Zeichen zum trennen):

; ++++++++++ +++++++++ ++++++++ +++++++ +++++ ++++ +++ ++ +

Zudem setze ich nach und vor einen Mathematischen Operator immer ein Leerzeichen. Da gibts aber auch wieder eine ausnahme wo ich das nicht mache...
(Könnte ich stundenlang drüber schreiben ^^)

Dann brauchst du einen Algorithmus der deine Zahlen verschlüsselt und dieser in verschlüsselter Form verrechnen kann.
Alle mir bekannten Algorithmen zur Verschlüsselung eignen sich nicht dafür.
Da bleibt dir nichts anderes übrig als dir selber was auszudenken.

Gegenfrage: Welchen Sinn soll das haben?
Da kannst du die Zahlen auch gleich im "entschlüsselten Zustand" verrechnen.

1252? --- Ist der Codepage für den US-ASCII (bzw. ASCII) nicht 20127?

>> Naja, du musst den Zeichensatz entweder ändern (Keine Ahnung wie das geht) oder die einzelnen Werte manuel ändern.
Dafür Zeichen für Zeichen durchgehen und durch den richtigen Wert ersetzen. Bzw. Nur die Werte die du benötigst.

Das wundert mich...
Die Konsolenausgabe kann ich ja noch verstehen.
Aber bei _ArrayDisplay()?

Zeig mal dein Skript bitte, ich habe folgendes verwendet und via Run('"code.exe" "ä" "ö" "ü" "Ä" "Ö" "Ü"') aufgerufen:

#Region ;**** Directives created by AutoIt3Wrapper_GUI ****
#AutoIt3Wrapper_Change2CUI=y
#EndRegion ;**** Directives created by AutoIt3Wrapper_GUI ****

#include <Array.au3>
ConsoleWrite($CMDLineRaw & @CRLF)
_ArrayDisplay($CMDLine)

Die Konsole verwendet einen anderen Zeichensatz. Da musst du die Werte jeweils für jedes Zeichen ändern.

Ah, super
Vielen dank!

Hey, ich grabe den Thread mal aus weil ich nicht weiter komme
Habe in einer Variable einen String gespeichert und möchte diesen zurück geben.
Leider hat bisher nichts geholfen. Habe sämtliche Datentypen probiert und auch eine Struktur verwendet.
Alles erfolglos...

Bisher habe ich hier folgendes:

Extern "Windows-MS"


	Function back As ZString Ptr Export
		Dim As String s = "ABC"
		Return StrPtr(s)
	End Function

End Extern

$ret = DllCall('code.dll', 'str', 'back')[0]
ConsoleWrite($ret & @CRLF)

Als Rückgabewert erhalte ich immer ein "Ä". Ich weiß nicht mehr weiter
Ich möchte aber auch nicht eine weitere Variable ByRef übergeben.
Das möchte ich sogut wie es geht vermeiden.

Hat jemand vielleicht eine Idee?

Soa, es hat ein wenig gedauert bis ich den Algorithmus (den Mars bereits gepostet hat) verstanden habe. Ich möchte diesen an dieser Stelle einmal erklären damit andere das nachvollziehen können.

Erst einmal der Code:

Was macht der Algorithmus nun genau?
Er liest jedes Zeichen einzeln aus und verarbeitet diesen in Bit Ebene. Später wird ein String zurück gegeben, welcher intern nun die richtige Bit Reihenfolge für die eingegebene Dezimalzahl besitz. Die einzelnen Bits können somit durch bereits vorgestellte Funktionen in 4 Byte Blöcken (Beispielsweise) ausgegeben werden. Die Zahl 65 ist Beispielsweise als String ein „A“ und intern ist die 65 als 01000001. Und genauso konvertiert der Algorithmus die gesamte Dezimalzahl im String.

Wir wissen ja, dass ein Byte 265 Zustände speichern kann. Wenn wir Werte darüber nutzen wollen, müssen wir ein weiteres Byte hinzunehmen. Bei größeren Werten brauchen wir noch mehr Bytes usw. Dies kann man sich nun zu nutzen machen und die Dezimalzahl Ziffer für Ziffer bearbeiten. Das hat den Vorteil dass man auf die nativen Rechenbefehle von AutoIt zugreifen kann (+, -, *, /).

Nehmen wir einmal an, wir hätten die Zahl „12345“ die wir nun in Binärer Form ausgegeben haben wollten. Zuerst bearbeiten wir logischerweise die Ziffer „1“. Im Dualsystem handelt es sich dabei um die Zahl „00000001“. Wir brauchen also ein Byte um diese 1 zu speichern. Also speichern wir beispielsweise in einem Array im Index [0] nun die Zahl 1. (Wir nehmen einfach mal an, jedes Array Element kann nur 1 Byte speichern.) Nun kommt die nächste Ziffer „2“ heran. Was machen wir nun damit? Im Dezimalsystem würden wir (um 2 hinter die 1 zu hängen) zuerst die 1 mit 10 multiplizieren und danach mit 2 addieren. So kommen wir schon bereits auf die 12. Im Array [0] kann man nun die 1 mit der 12 ersetzen. Das gleiche gilt ebenso für die 3. Wir haben im Element [0] nun die Zahl 123 stehen.

Nun kommt der eigentliche Trick bei diesem Algorithmus. Da wir nur auf 256 Zustände beschränkt sind, müssen wir das ein wenig aufteilen damit die Zahl „1234“ gespeichert werden kann. Dazu brauchen wir erst einmal ein weiteres Element in unseren Array. Wir haben also nun folgenden Arrayaufbau: ([0] = 123; [1] = 0)

Die Zahl „1234“ entspricht im Dualsystem die Zahl „0000 0100 1101 0010“. Wenn wir nun die beiden Bytes aufteilen, enthält unser Array nun die Zahlen ([0] = 210; [1] = 4). Aber wie kommt es dazu? Da wir pro Byte 256 Zustände speichern können, wird nun die Zahl „1234“ durch „256“ dividiert. Wir erhalten nun abgerundet (!) „4“. Damit wäre eine Zahl geklärt. Was ist aber nun mit der anderen Zahl „210“? Dieser erhalten wir wenn wir eine Module Rechnung mit 256 durchführen. Oder anders gesagt: 1234 - 256 * 4 = 210

Nun kommt die letzte Ziffer hinzu. Allerdings ist es hier ein wenig anders. Da das Element [0] jetzt 210 enthält, wird nun diese Zahl verwendet. Also: 210 * 10 + 5 = 2105

Weil diese Zahl auch wieder zu groß ist, erhalten wir folgende 2 Bytes: „0000 1000“ und „0011 1001“. In Element [0] wird nun die der LowByte gespeichert. Dieser beträgt [0] = 57. Das andere Byte wird nun mit zum nächsten Element [1] mitgenommen. Hier wieder die gleiche Rechnung: 4 * 10 + 8 = 48.

Unser Array enthält nun die Elemente ([0] = 57; [1] = 48) und intern sind nun folgende Dualzahlen gespeichert:
[0] = 0011 1001
[1] = 0011 0000

Rückwerts gelesen ergibt dies „0011000000111001“ und entspricht der Zahl „12345“ im Dualsystem.

Ich habe zur Vereinfachung immer mit einem Byte gerechnet. Um den Algorithmus effektiver zu machen sollten 4 Zeichen jeweils extrahiert werden. Jeder moderne PC kann locker 32 Bit gleichzeitig bearbeiten. Man muss nur ein wenig umdenken.

Ich hoffe es war einigermaßen verständlich.

Oh ha,... Wenn ich mir mal deine Funktion _Licensegenerator() anschaue. O.o
Das kann man wunderbar auf 15 Zeilen kürzen. :o

FileDelete('Keys.txt')
_Licensegenerator(100) ; 100 Keys generieren

Func _Licensegenerator($iKeys, $z1 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', $z2 = '0123456789')
$z1 = StringSplit($z1, '')
$z2 = StringSplit($z2, '')
For $i = 1 To $iKeys
$Serial = ''
For $n = 1 To 16
$Serial &= (Random(0, 1, 1)) ? ($z1[Random(1, $z1[0], 1)]) : ($z1[Random(1, $z2[0], 1)])
If Not Mod($n, 4) And $n <> 16 Then $Serial &= '-'
Next
FileWrite('Keys.txt', $Serial & @CRLF)
Next
EndFunc

Man kann es mit einer Callback-Funktion regeln.
Seit der AutoIt Version 3.3.9.5 (Beta) lassen sich solche relativ einfach in Form von Variablen erstellen:

Global $f[] = [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9]

For $i = 0 To UBound($f) -1
$b = Random(0, 1, 1)

If Not $b Then $f[$i](Random(0, 9, 1))
Next

Func f0($x)
ConsoleWrite('f0 -> ' & $x & @CRLF)
EndFunc

Func f1($x)
ConsoleWrite('f1 -> ' & $x & @CRLF)
EndFunc

Func f2($x)
ConsoleWrite('f2 -> ' & $x & @CRLF)
EndFunc

Func f3($x)
ConsoleWrite('f3 -> ' & $x & @CRLF)
EndFunc

Func f4($x)
ConsoleWrite('f4 -> ' & $x & @CRLF)
EndFunc

Func f5($x)
ConsoleWrite('f5 -> ' & $x & @CRLF)
EndFunc

Func f6($x)
ConsoleWrite('f6 -> ' & $x & @CRLF)
EndFunc

Func f7($x)
ConsoleWrite('f7 -> ' & $x & @CRLF)
EndFunc

Func f8($x)
ConsoleWrite('f8 -> ' & $x & @CRLF)
EndFunc

Func f9($x)
ConsoleWrite('f9 -> ' & $x & @CRLF)
EndFunc

Gleiches würde aber auch mit der Call Funktion funktionieren nur mit dem Unterschied, dass die Funktionsnamen als Strings gespeichert werden müssen.

a href="/Beispiel/\d+">(\V+)</a>
Dies sucht ja (fast) alles zwischen a href="/Beispiel/\d+"> und </a> .
Kann es sein dass im IE11 irgendwo ganz unten im Quelltext noch ein "</a>" zu finden ist?
Der Quantifier ist nämlich gierig und sucht soviel wie möglich.
Versuch mal folgendes: a href="/Beispiel/\d+">(\V+?)</a>
(Hab das jetzt nicht getestet)

Naja, wie ich ja einen Post vorher gezeigt habe, kann man eine > 64 Bit Zahl in mehrere Blöcke aufteilen. Damit würdest du dann die gesamte Zahl in ein Strukturen Array (oder wie auch immer) unterbringen. Das Problem ist halt, dass man vorab die Zahlen dividieren und subtrahieren muss. Was anderes fällt mir derzeitig leider nicht ein. Ich könnte mir vorstellen wenn man das in FreeBASIC so machen würde (mit Multithreading), dass es ab einer bestimmten Zahl tatsächlich einen Geschwindigkeit Schub anstelle von anderen Algorithmen bringen würde.

Das ist aber auch verzwickt

Hmn,...
Vielleicht muss man ein wenig anders denken...
Ich weiß nicht ob das hier irgendwie hilft, aber man kann jede Dualzahl (oder auch Blöcke davon) mit Potenzen in Dezimaler Form schreiben. Vielleicht kann man die Dezimalzahl ja vorerst so aufteilen und dann Blockweise die Dualzahl erstellen. Bis 64/32 Bit schafft das der Computer ja mit Integers statt Strings zu rechnen wodurch bereits vorgestellte Funktionen brauchbar werden.

1234567890 (Dec) <=> (Dual) 01001001100101100000001011010010

01001001 10010110 00000010 11010010
73*256^3 + 150*256^2 + 2*256^1 + 210*256^0

Du hast mich auf eine Idee gebracht. Hätte da einen Ansatz um die Dezimalzahl tatsächlich Ziffer für Ziffer durchzugehen. Allerdings flimmert dieser Gedanke in einer Ecke meines Gehirns herum. Ich muss erst einmal ein wenig herum testen. (Mein Bauch sagt mir dass ich auf den richtigen Weg bin ^^)

Wenn ich dann was hab lass ich es dich wissen.

Hey, ich hab das Thread nur so halb überflogen. Ich habe das gleiche Problem.
Es wird also derzeitig nach einer schnellen Lösung gesucht um jede Dezimalzahl (in Form eines Strings) in das Dualsystem umzurechnen?

Ich hatte bisher das hier (wobei du mir auch geholfen hast xD) um dies zu erledigen:

Ist mir aber auch zu langsam, bei ca. 4100 Zeichen dauert es schon etwa 25 Sekunden...
Wenn mir was Gescheites einfällt sag ich Bescheid.

alpines:

Zitat von UEZ

Da ich relativ oft Binär Strings verwende, um Bilder, Sounds, etc. direkt vom Speicher zu lesen, habe ich kleines Tool dazu geschrieben, das eine Datei in einen Base64 String umwandelt und gleich als Funktion bereit stellt.

Soweit ich das verstanden habe im verlinken Thread wird der Binärcode komprimiert. Die komprimierte Datei (in diesem Fall die verlinkte *.mp3 File) gilt es nun direkt vom Speicher abzuspielen. Wollte ich einmal nur erwähnt haben.

|> Ich selber habe noch keine Lösung und werde mich erst Morgen mit dem Problem befassen. Gute Nacht!

€dit: Ah, beim kurzen überfliegen des Threads sind mir ein paar Beispiele von UEZ entgegen geflogen: https://www.autoit.de/index.php?page=Thread&postID=237809#post237809
Damit sollte es eigentlich wunderbar funktionieren.

Zitat

Gibt es noch weitere Arten zu verschlüsseln? Habt ihr dafür Beispiele parat?

Ich hatte mal vor einiger Zeit ein Tool geschrieben zum verschlüsseln von Daten.
Die entsprechende Funktion die das bewerktstelligt lässt sich einfach per Copy & Paste in jedes beliebige Skript einfügen.
Sie ist auch relativ sicher weil der Text sich nicht durch die Anzahl der Buchstaben entziffern lässt.
Jedoch hat sie auch eine Schwachstelle,... Es ist möglich Teilstrings zu entziffern...
Aber man muss erst einmal erkennen dass es sich tatsächlich um Teilstrings handelt.
(Je länger der Text & Passwort deso sicherer der verschlüsselte Text)
Schau mal hier: https://www.autoit.de/index.php?page=Thread&threadID=42412

Zitat

Allerdings habe ich die Größe 2x vergeben.
Dies würde ich gerne vermeiden.

Dann verwende doch stattdessen eine Konstante damit du später im Skript nicht beide Werte ändern musst o.o
Ansonsten würde mir keine andere Möglichkeit einfallen... Allerhöchstens etwas ähnliches was aber auf's selbe hinaus läuft:

#region ;************ Includes ************
#include <Array.au3>
#endregion ;************ Includes ************
Global $aTest[5]
Global $aCopy = $aTest
_ArrayDisplay($aTest, 1)

_test1()
_test2()

_test1()
_test2()

Func _test1()
$aTest = $aCopy ;Array wieder auf die Ursprungsgröße zurücksetzen
_ArrayDisplay($aTest, 2)
$aTest[2] = Random(1, 100, 1)
$aTest[4] = Random(1, 100, 1)
_ArrayAdd($aTest, Random(200, 300, 1))
_ArrayDisplay($aTest, 3)
EndFunc ;==>_test1

Func _test2()
ConsoleWrite($aTest[2] & @CRLF)
ConsoleWrite($aTest[4] & @CRLF & @CRLF)
EndFunc ;==>_test2

Vorrausgesetzt dass sich die Bilder im Dateiformat nicht unterschieden und tatsächlich nur die Bezeichnung anders ist, lassen sich alle Bilder via "FileRead" lesen und dann vergleichen. Dabei musst du logischerweise nur prüfen, ob der Inhalt der gleiche ist. In etwa so:

$sPic1 = FileRead('Picture1.png')
$sPic2 = FileRead('Picture2.png')
If $sPic1 == $sPic2 Then MsgBox(0, 'Erfolg', 'Bild 1 entspricht Bild 2')