Eigene (billig) Codierung Decodieren

  • VB.NET

Es gibt 26 Antworten in diesem Thema. Der letzte Beitrag () ist von BiedermannS.

    Eigene (billig) Codierung Decodieren

    aus langeweile habe ich eine fun codierung geschrieben :


    VB.NET-Quellcode

    1. Public Class Form1
    2. Dim Platzhalter as string = ""
    3. Dim Multiplier As Integer
    4. Dim XepMultiplier As Integer
    7. Public Function Multiply()
    8. Dim X As String
    9. Dim Y As Integer
    10. Dim Z As Integer = 20166
    11. Dim Result As Integer
    13. Try
    15. For Each i As Char In TextBox1.Text
    16. Y = AscEncode(i.ToString)
    17. XepMultiplier = PassortTextBox.TextLength + CInt(Val(PassortTextBox.Text))
    18. Multiplier = CInt(Val(PassortTextBox.Text)) + 66
    19. Result = Y * XepMultiplier
    20. Result = Result + (Z * Multiplier)
    24. X = Result.ToString
    25. PlatzHalter &= X
    27. Next
    29. TextBox1.Text = PlatzHalter
    30. Return True
    32. Catch ex As Exception
    34. MsgBox(ex.ToString)
    35. Return False
    37. End Try


    Das funktioniert (für den gammel) recht gut und es kommen gute ergebnisse zurück.

    Beispiel Zu codierender text : Test | Passwort : 2012
    Ergebnis : 20124197147641971476419714764197550841971476419714764197147641973492419714764197147641971476419775244197147641971476419714764197550841971476419714764197147641979540419714764197147641971476419714764197147641971476419714764197954041971476419714764197147641973492

    wie ihr seht nicht sehr professionell, doch das muss es nicht da ich das nur benutzen werde um private nachrichten zu verschlüsseln, aber darum gehts nicht sondern:

    ich versuche schon seit 2 stundes eine decodier-funktion zu schreiben o_O

    Ich weis net wieso ich kriege es einfach nicht hin ! Ich dachte mir wenn ich ne gesammte umkehr von dem shit(also von hinten anfangen und anstatt + ein - und anstatt * ein /) mache würde es klappen - fehlanzeige

    Hoffe es kann mir einer hier helfen. sonst codiere ich meine mails und kann sie net zurück kodieren :/



    Vielleicht habe ich ja auch einen fehler in der kodieren funktion - ich weis es nicht - bitte helft mir ;(

    Edit: Code überarbeitet (danke fürs fehler aufzeigen). und sry wenns vorher hässlig aussah, paar sachen beim kopieren verrutscht

    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „Routess“ ()

    erstmal soltest du den code richtig einrücken (echt nervig zu lesen)
    und dann soltest du den VB6 mist da raus machen
    und am ende kanste auch mal denken ob du nicht eine normale codiersprache nimst ??? anstadt selber was zu machen

    Billig ist das Format deines Postes:
    2 Anweisungen in einer Zeile
    keine Einrückung usw.

    zum Code:
    lager das Ganze in eine Klasse aus

    zum Decrypt:
    Alles in Umgekehrter Reihenfolge machen

    Da du aber anscheinend die Zeichenanzahl des Originaltext für die "Verschlüsselung" verwendest, kannst du natürlich das Ganze nicht mehr entschlüsseln, da die Länge des Original Text verloren geht.

    Wenn ich Zeit habe, werd ich das mal ein wenig überarbeiten....
    SWYgeW91IGNhbiByZWFkIHRoaXMsIHlvdSdyZSBhIGdlZWsgOkQ=

    Weil einfach, einfach zu einfach ist! :D

    Routess schrieb:

    Das funktioniert (für den gammel) recht gut

    Nein, da funzt NIX!

    VB.NET-Quellcode

    1. Public Function CryptTheShit()
    2. Dim X As String
    3. Dim Y As Integer
    4. Dim Z As Integer = 20166
    5. Dim Result As Integer
    6. Try
    7. For Each i As Char In TextBox1.Text
    8. Y = AscEncode(i.ToString)
    9. XepMultiplier = PasswordTextBoxLenght.Text + CInt(Val(PasswordTextBox.Text)) ' password darf nur aus zahlen bestehen
    10. Multiplier = TextBox1.TextLength ' in Texbox 1 kommt der zu verschlüsselnde string
    11. Result = Y * XepMultiplier
    12. Result = Result + (Z * Multiplier)
    13. X = Result.ToString
    14. TextBox1.Text = X
    15. Next
    16. Return True
    17. Catch ex As Exception
    18. MsgBox(ex.ToString)
    19. Return False
    20. End Try
    21. End Function


    Du machst ne Schleife über den Inhalt von Textbox1. Und am Ende der Schleife setzt du Textbox1.Text auf irgendeinen Schmonz. Mit diesem Schmonz arbeitest du dann weiter. Egal was also rauskommt, DEKODIEREN läßt sich das nie, denn der "Kryptotext" steht in keinerlei Zusammenhang mehr mit dem Plaintext ... !!!

    Also wenn ich das ohne die textlänge des original textes mache dann sollte es gehn ja ?

    Edit: okay habe jetzt den code überarbeitet - hoffe ihr könnt mir jetzt beim decodieren helfen. Bitte sagt nicht einfach nur - probiers rückwärts - das hab ich schon lange und verzweifelt getan und bin zu nix gekommen :/

    Den Neuen Code werde ich in dem ersten post bearbeiten

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Routess“ ()

    Routess schrieb:

    dann sollte es gehn ja ?

    Ja klar. Das was ich weiter oben geschrieben habe, war ja nur so dahingesagt ...
    Mal abgesehen davon, dass das zuvor gesagte nur EIN Fehler von mehreren in deinem Code ist!

    Überleg dir bitte ERST, WAS du WIE machen willst und schreibe DANACH den passenden Code.
    Als Übung eine eigene Verschlüsselung bauen ist sicherlich ok, aber dann sollte man auch verstehen, was man tut!

    Es ist sowieso nicht zu empfehlen, eine eigene "Verschlüsselung" zu implementieren, da diese meist nicht die Ausreichende Sicherheit bieten (Außer man ist ein Mathematik Genie)

    Bei einer guten Verschlüsselung sind mehrere Dinge wichtig.

    Erstens: Eine Verschlüsselung ist nur dann richtig gut, wenn die Funktionsweise bekannt ist und diese trotzdem nicht geknackt werden kann. (Mit normalen Mitteln in einem realistischen Zeitraum)

    Zweitens: Diffusion. Man darf nicht auf den Klartext schließen können ohne das Passwort zu kennen. (siehe Cryptoanalyse)

    Drittens: Bruteforceangriffe sollten so gut wie möglich erschwert werden.

    usw.

    Zum Thema Cryptographie kann man Stundenlang was erzählen und hat noch immer nur einen Bruchteil davon durch. Darum, einfach den Profis überlassen, oder ein paar Jahre exzessiv Mathematik studieren und einen richtigen Algorithmus erstellen...



    Hier ein kleiner Algorithmus (welcher leider auch nicht druckbare Zeichen ausgibt):
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Option Strict On
    2. Module Module1
    3. ''' <summary>
    4. ''' Verschlüsselt 10 Zufallszeichenfolgen zu je 150 Zeichen mit zwei Zufallspasswörtern und entschlüsselt diese wieder
    5. ''' </summary>
    6. ''' <remarks></remarks>
    7. Sub Main()
    8. For i = 1 To 10
    9. Dim myString As String = textgenerator(150)
    10. Dim mypasswd As String = textgenerator(8)
    11. Console.WriteLine(i)
    12. Console.WriteLine("Text:" & vbCrLf & myString & vbCrLf)
    13. Console.WriteLine("Passwort:" & vbCrLf & mypasswd & vbCrLf)
    14. Console.WriteLine(crypt(myString, mypasswd) & vbCrLf)
    15. Console.WriteLine(crypt(crypt(myString, mypasswd), mypasswd) & vbCrLf)
    16. mypasswd = textgenerator(14)
    17. Console.WriteLine("Text:" & vbCrLf & myString & vbCrLf)
    18. Console.WriteLine("Passwort:" & vbCrLf & mypasswd & vbCrLf)
    19. Console.WriteLine(crypt(myString, mypasswd) & vbCrLf)
    20. Console.WriteLine(crypt(crypt(myString, mypasswd), mypasswd) & vbCrLf)
    21. Console.ReadLine()
    22. Console.Clear()
    23. Next
    25. End Sub
    27. ''' <summary>
    28. ''' Generiert ZufallsText
    29. ''' </summary>
    30. ''' <param name="CharCount"></param>
    31. ''' <returns></returns>
    32. ''' <remarks></remarks>
    33. Function textgenerator(ByVal CharCount As Integer) As String
    34. Dim rnd As New Random(Now.Millisecond)
    35. Dim sb As New System.Text.StringBuilder(CharCount)
    36. For i = 1 To CharCount
    37. Dim done As Boolean = False
    38. Do Until done
    39. Dim current As Integer = rnd.Next(64, 123)
    40. If current <= 90 OrElse current >= 65 OrElse current >= 97 OrElse current <= 122 Then
    41. sb.Append(Chr(current))
    42. done = True
    43. End If
    44. Loop
    45. Next
    46. Return sb.ToString
    47. End Function
    49. ''' <summary>
    50. ''' Verschlüsselt einen Text mit einem Passwort oder entschlüsselt diesen
    51. ''' </summary>
    52. ''' <param name="text"></param>
    53. ''' <param name="pwd"></param>
    54. ''' <returns></returns>
    55. ''' <remarks></remarks>
    56. Function crypt(ByVal text As String, ByVal pwd As String) As String
    57. Dim lPwd As String = String.Empty
    58. If text.Length < pwd.Length Then
    59. lPwd = cutpwd(text, pwd)
    60. ElseIf text.Length > pwd.Length Then
    61. lPwd = getpwd(text, pwd)
    62. lPwd = cutpwd(lPwd, String.Concat(lPwd.ToArray.Reverse()) & lPwd)
    63. Else
    64. lPwd = pwd
    65. lPwd = cutpwd(lPwd, lPwd & String.Concat(lPwd.ToArray.Reverse()))
    66. End If
    68. Dim retval As String = String.Empty
    69. Array.Reverse(lPwd.ToArray)
    70. For i = 0 To text.Length - 1
    71. retval &= Chr(Asc(text.Substring(i, 1)) Xor Asc(lPwd.Substring(i, 1)))
    72. Next
    73. Return retval
    74. End Function
    76. ''' <summary>
    77. ''' verlängert das passwort, damit es die gleiche länge wie das passwort hat
    78. ''' </summary>
    79. ''' <param name="text"></param>
    80. ''' <param name="pwd"></param>
    81. ''' <returns></returns>
    82. ''' <remarks></remarks>
    83. Function getpwd(ByVal text As String, ByVal pwd As String) As String
    84. If pwd.Length < text.Length Then
    85. pwd &= pwd
    86. Return getpwd(text, pwd)
    87. Else
    88. Return pwd.Substring(0, text.Length)
    89. End If
    90. End Function
    92. ''' <summary>
    93. ''' verkürzt das passwort, damit es die gleiche länge wie das passwort hat
    94. ''' und ändert es ab damit keine gleichheiten mit dem text bestehen können
    95. ''' </summary>
    96. ''' <param name="text"></param>
    97. ''' <param name="pwd"></param>
    98. ''' <returns></returns>
    99. ''' <remarks></remarks>
    100. Function cutpwd(ByVal text As String, ByVal pwd As String) As String
    101. Dim pwchars As New System.Text.StringBuilder
    102. Dim count As Integer = 0
    103. For i = 0 To pwd.Length - 1 Step 2
    104. If i + 1 < pwd.Length - 1 Then
    105. pwchars.Append(Chr((Asc(pwd(i)) + 96) Xor (Asc(pwd(i + 1)) - 60)))
    106. Else
    107. pwchars.Append(pwd(i))
    108. End If
    109. Next
    110. If text.Length < pwchars.Length Then
    111. Return cutpwd(text, pwchars.ToString)
    112. Else
    113. Return pwchars.ToString
    114. End If
    115. End Function
    116. End Module


    Im Großen und Ganzen bringe ich den Key auf die selbe Länge die einzelnen Buchstaben des Keys außerhalb des lesbaren Bereichs und verknüpfe diese danach über XOR mit dem Original Text.
    XOR ist eine der einfachsten Verschlüsselungen die es gibt und ist noch lange nicht sicher.

    Dieser Code ist nur Anschauungsmaterial, bitte nicht zur Verschlüsselung wichtiger Daten einsetzen!! Dafür gibt es weit besser geeignete Librarys!!
    SWYgeW91IGNhbiByZWFkIHRoaXMsIHlvdSdyZSBhIGdlZWsgOkQ=

    Weil einfach, einfach zu einfach ist! :D

    Routess schrieb:

    ich hab den code etwas verändert

    Aber ein funktionierende Umkehrfunktion hast du immer noch nicht, gell? Vermutlich macht das deinen Algorithmus dann zum sichersten denkbaren Crypto-Algo ...

    btw:

    Quellcode

    1. 201241971476419714764197147641975508419714764197147641971476419734924197147641971

    fällt dir was auf?

    Quellcode

    1. 2
    2. 01241971
    3. 47641971
    4. 47641971
    5. 47641975
    6. 50841971
    7. 47641971
    8. 47641971
    9. 47641973
    10. 49241971
    11. 47641971


    NORMALERWEISE ist der Output eines guten Crypto-Algos ziemlich "zufällig". Sieht dein Output auch nur ansatzweise zufällig aus?

    wenn ich mir das Ergebnis so ansehe, könnte man höchstwahrscheinlich den Algo sogar über eine Gleichungsfunktion wieder auflösen, was dann noch unsicherer ist, als sogar bisher angenommen

    Uns fehlt die Variable "Anzahl Zeichen", diese durch einsetzen durchspielen und warten, bis was rauskommt, was nach einem Ergebnis aussieht!

    Edit:
    Geschätzte Rechner Zeit: 0,001 Sek

    :)

    Nicht nur das, die Ausgabe des Algos verläuft meistens in 7er Blöcken, Aber hin und wieder hat der letzte Block eine andere Ziffernzahl (vl auch bei anderen Blöcken).

    Solange das nicht Konsistent ist, kannst du keinen einheitlichen algo schreiben der das entschlüsselt.

    Überhaupt besteht eine zu große Chance, dass mit zwei verschiedenen Passwörtern das selbe Ergebnis erreicht wird da du nur die Länge und die Asci codes des pwds miteinander multiplizierst bzw. addierst...

    Das nächste: Lass mal einen 250 Zeichen Text verschlüsseln mit nem 10 stellen Passwort, dann stößt du sogar mit int64 schnell an deine Grenzen.


    Und nun nochmal:
    Schreib ganz oben:
    Option Strict On

    Schreib deinen Algorithmus als Shared Methode in eine externe Klasse, dann brauchen wir nicht extra deine Winform nachbauen um den Code zu testen.

    Und auf jeden Fall weg von den großen Zahlen, damit machst du dir nur ne zusätzliche Fehlerquelle.

    Btw.: Man schreibt keinen Crypto-Algorithmus nur mit den Grundrechnungsarten, die verändern das ganze zu wenig.


    Hast du dir meinen Code schon angesehen?
    SWYgeW91IGNhbiByZWFkIHRoaXMsIHlvdSdyZSBhIGdlZWsgOkQ=

    Weil einfach, einfach zu einfach ist! :D

    VanDerLars schrieb:

    Uns fehlt die Variable "Anzahl Zeichen",


    Die "Multiplikatoren" in der Schleife sind konstant, Feedback ist nicht, dadurch haben wir eine Abbildung 1:1 ...

    Abgeändert wegen Textboxen und ein paar Fehler rausgenommen (Platzhalter wird nicht zurückgesetzt!)

    VB.NET-Quellcode

    1. Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
    3. Dim s As String
    4. Multiply("AAAA", "2012", s)
    5. Debug.Print(s)
    7. End Sub
    9. Public Function Multiply(ByVal txt As String, pwd As String, ByRef output As String) As Boolean
    11. Dim Platzhalter As String = ""
    12. Dim Multiplier As Integer
    13. Dim XepMultiplier As Integer
    15. Dim X As String
    16. Dim Y As Integer
    17. Dim Z As Integer = 20166
    18. Dim Result As Integer
    20. Try
    22. For Each i As Char In txt
    23. Y = Convert.ToInt32(i)
    24. XepMultiplier = pwd.Length + CInt(Val(pwd))
    25. Multiplier = CInt(Val(pwd)) + 66
    26. Result = Y * XepMultiplier
    27. Result = Result + (Z * Multiplier)
    28. X = Result.ToString
    29. Platzhalter &= X & " "
    31. Next
    33. output = Platzhalter
    34. Return True
    36. Catch ex As Exception
    38. MsgBox(ex.ToString)
    39. Return False
    41. End Try
    43. End Function


    Output (für AAAA mit 2012):
    42035988 42035988 42035988 42035988
    Ergo: LOL ;)

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „picoflop“ ()

    VB.NET-Quellcode

    1. For Each i As Char In TextBox1.Text
    2. Y = AscEncode(i.ToString)
    3. XepMultiplier = PassortTextBox.TextLength + CInt(Val(PassortTextBox.Text))
    4. Multiplier = CInt(Val(PassortTextBox.Text)) + 66
    5. Result = Y * XepMultiplier
    6. Result = Result + (Z * Multiplier)
    7. Next


    Ist in einem Term aufgelöst folgendes:

    VB.NET-Quellcode

    1. For Each i As Char In TextBox1.Text
    2. Result = (((AscEncode(i.ToString)) * (LängePasswort + CInt(Val(PasswortText)))) + (20166 * CInt(Val(Passworttext)) + 66))
    3. Next


    LängePasswort wird einfach von 1 bis unendlich durchprobiert

    Val(PasswortText) ist eine zweite undefinierte Variable, welche immer pro eingesetzte Variable "LängePasswort" eingesetzt wird.

    Das in einer schleife von LängePasswort 0 bis unendlich und darin eine Schleife Val(PasswortText) von 0 bis unendlich

    dürfte relativ schnell gehen den Algo zu knacken (theoretisch)!!!

    @VanDerLars: sieht aus als ob du dich schon etwas mit Cryptographie beschäftigt hast ^^

    Da immer Blöcke von einer gewissen Zeichenlänge aus nur einem Zeichen generiert werden (mit einer statischen Methode) Lässt sich das ganze wohl auch relativ einfach über die Entropie der Blöcke bestimmen
    SWYgeW91IGNhbiByZWFkIHRoaXMsIHlvdSdyZSBhIGdlZWsgOkQ=

    Weil einfach, einfach zu einfach ist! :D

    Nö, ich kann nur logisch denken und ich hab damals in der Schule gut aufgepasst^^

    Ein Typ in den USA hat mal Obamas Passwort bei Facebook & Co. nur durch rumprobieren genackt!

    Die Blöcke über einen logischen Zusammenhang auseinander zunehmen, dürfte wohl einen weit schwierigeren Algorithmus erfordern!

    Naja, Knacken von Algorithmen macht man nur teilautomatisiert.

    Also würde, falls jemand das Ganze Knacken möchte, sowieso derjenige sich das vorher genau ansehen um dann den Analyseprozess dementsprechend anzupassen...


    Das mit Obama ist mir neu, aber sein Passwort war sicher sowas wie "IamPresident", weil sonst wirds extrem schwierig. :D
    SWYgeW91IGNhbiByZWFkIHRoaXMsIHlvdSdyZSBhIGdlZWsgOkQ=

    Weil einfach, einfach zu einfach ist! :D

Facebook
Telefonspende