ASCII-Wert verändern

[PeterJ]

Bei meinem PACK+AES-Encode Programm, hat mich gestört das der Kontrollblock "unverschlüsselt" im File steht (offset,länge CRCs), da habe ich nach einer einfachen Möglichkeit gesucht in zu "verstecken", AES Encode (128 Bit) funktioniert erst ab einer Länge von 16 Byte.
Deshalb war ich dankbar für die Cäsar Verschlüsselung, die ich hier gefunden habe, sie ist für meine Zwecke völlig ausreichend.
Mit dem Shift Makro kann man die Verschiebung auch noch in Abhängigkeit von der Characterposition durchführen. Damit kann man übrigens auch longs und quads encoden.

Grüße

Peter

Code: Alles auswählen

; ----------------------------------------------------------------------------------------------
; Calculates shift count, CHARPOS: character position to be scrambled 
; ----------------------------------------------------------------------------------------------
Macro shift(charpos)
(charpos+23)*17
EndMacro
Structure Storage 
  xl1.c[0] 
EndStructure
; ----------------------------------------------------------------------------------------------
; Scramble contents of Memory 
; ----------------------------------------------------------------------------------------------
Procedure.l Scramble(*Source, SourceLen, Key$) 
Protected *sptr.Storage,*kptr.Storage,keylen,i,ki
keylen=Len(key$)
*sptr=*Source 
*kptr=@key$ 
For i=0 To SourceLen-1
     ki=i%keylen
     nxl1=*sptr.Storage\xl1[i]
     kxl1=*kptr.Storage\xl1[ki]
     nxl1=(nxl1+kxl1+shift(i))%255
     *sptr.Storage\xl1[i]=nxl1
Next
ProcedureReturn 0 
EndProcedure 
; ----------------------------------------------------------------------------------------------
; Unscaramböe contents of Memory 
; ----------------------------------------------------------------------------------------------
Procedure.l DeScramble(*Source, SourceLen, Key$) 
Protected *sptr.Storage,*kptr.Storage,keylen,i,ki
keylen=Len(key$)
*sptr=*Source 
*kptr=@key$ 
For i=0 To SourceLen-1
     ki=i%keylen
     nxl1=*sptr.Storage\xl1[i]
     kxl1=*kptr.Storage\xl1[ki]
     nxl1=(nxl1-kxl1-shift(i))%255
     If nxl1<0 
        nxl1+255
     EndIf
     *sptr.Storage\xl1[i]=nxl1
Next
ProcedureReturn 0 
EndProcedure 
; ----------------------------------------------------------------------------------------------
; Main Program  
; ----------------------------------------------------------------------------------------------
hideMe$="Rikki Don't Lose That Number"
myKey.s="Steely Dan"
Debug "Original          : <"+hideMe$+">"
Debug "Key                : <" +mykey+">"

Scramble(@hideMe$,Len(hideMe$),Mykey) 
Debug "Scambled      : <"+hideMe$+">"

DeScramble(@hideMe$,Len(hideMe$),Mykey)
Debug "De-Scrambled: <"+hideMe$+">"

[c4s]

Gebrauchbar, danke Peter.

[c4s]

Oh, einen Fehler habe ich trotzdem gefunden. Er führt dazu, dass der Text ab einer gewissen Länge abgeschnitten wird.

Edit2:
Eigentlich ist es offensichtlich, aber manchmal sieht man bekanntlich den Wald vor lauter Bäumen nicht. Der String bekommt auch das 0-Zeichen und wird dadurch abgeschnitten...Es liegt also nur am Beispiel.

[PeterJ]

Ich fürchte es war doch ein Fehler im Coding, nach dem potentielle Characterwerte von 0-255 laufen können, müssen wir die Restdivision natürlich mit 256 durchführen und nicht mit 255! Sonst kann es beim zurückwandeln zu spaßigen Ergebnissen kommen.
Natürlich kann es beim Umwandeln zu x'00' Werten kommen, das ist aber nicht tragisch, da sich die Stringlänge nicht ändert, jedenfalls solange man nicht eine neue LEN() Berechnung durchführt. Auch wenn man den String anzeigt (DEBUG o.ä.) sieht man nur den abgeschnittenen Wert (bis x'00').
Wandelt man ihn zurück wird wieder der volle String übersetzt. Beim Ausgeben in eine Datei ist WriteData zu bevorzugen, da WriteString wieder auf x'00' reagiert.

Code: Alles auswählen

; ----------------------------------------------------------------------------------------------
; Calculates shift count, CHARPOS: character position to be scrambled 
; ----------------------------------------------------------------------------------------------
Macro shift(charpos)
(charpos+23)*17
EndMacro
Structure Storage 
  xl1.c[0] 
EndStructure
; ----------------------------------------------------------------------------------------------
; Scramble contents of Memory 
; ----------------------------------------------------------------------------------------------
Procedure.l Scramble(*Source, SourceLen, Key$) 
Protected *sptr.Storage,*kptr.Storage,keylen,i,ki
keylen=Len(key$)
*sptr=*Source 
*kptr=@key$ 
For i=0 To SourceLen-1
     ki=i%keylen
     nxl1=*sptr.Storage\xl1[i]
     kxl1=*kptr.Storage\xl1[ki]
     nxl1=(nxl1+kxl1+shift(i))%256
     *sptr.Storage\xl1[i]=nxl1
Next
ProcedureReturn 0 
EndProcedure 
; ----------------------------------------------------------------------------------------------
; Unscaramble contents of Memory 
; ----------------------------------------------------------------------------------------------
Procedure.l DeScramble(*Source, SourceLen, Key$) 
Protected *sptr.Storage,*kptr.Storage,keylen,i,ki
keylen=Len(key$)
*sptr=*Source 
*kptr=@key$ 
For i=0 To SourceLen-1
     ki=i%keylen
     nxl1=*sptr.Storage\xl1[i]
     kxl1=*kptr.Storage\xl1[ki]
     nxl1=(nxl1-kxl1-shift(i))%256
     If nxl1<0 
        nxl1+255
     EndIf
     *sptr.Storage\xl1[i]=nxl1
Next
ProcedureReturn 0 
EndProcedure 
; ----------------------------------------------------------------------------------------------
; Main Program  
; ----------------------------------------------------------------------------------------------
hideMe$="Rikki Don't Lose That Number"
myKey.s="Steely Dan"
Debug "Original          : <"+hideMe$+">"
Debug "Key                : <" +mykey+">"

Scramble(@hideMe$,Len(hideMe$),Mykey) 
Debug "Scambled      : <"+hideMe$+">"

DeScramble(@hideMe$,Len(hideMe$),Mykey)
Debug "De-Scrambled: <"+hideMe$+">"

[NicTheQuick]

Ich glaube, wenn felix diesen Thread hier bald liest, wird er total erschlagen sein.
Und da er von einem Cäsar-Chiffre geredet hat, vermute ich auch, dass er nur das Alphabet von A bis Z verschlüsseln will, weswegen aus einem um eins verschobenen Z wieder ein A werden sollte.

[Kaeru Gaman]

da hat Nic irgendwie recht...

die ursprüngliche Frage:

Bisheriges Ergebnis:

Code: Alles auswählen

ascii = Asc(a$)
ascii + 1

also der Kern der Antwort:

Code: Alles auswählen

Work$ = "DIESISTEINTEST"
Key = 12
Out$ = ""
For n=1 To Len(Work$)
  CH = Asc( Mid( Work$, n, 1 ) ) + Key
  If CH > 90
    CH - 26
  EndIf
  Out$ + Chr( CH )
Next
Debug Out$

... und als klassische Konsolen-Spielerei:

Code: Alles auswählen

OpenConsole()
Repeat
  Repeat
    Print("[V]erschluesseln, [E]ntschluessln, [B]eenden? ")
    In$ = Input()
    In$ = UCase(Left(In$,1))
    Work = 0
    If In$ = "V"
      Work = 1
    ElseIf In$ = "E"
      Work = 2
    ElseIf In$ = "B"
      Work = 3
    EndIf
  Until Work > 0
  PrintN("")
  If Work = 1
    ;**************
    PrintN("Bitte den Satz eingeben, der mit Caesar VERschluesselt werden soll.")
    Print(">")
    In$ = Input()

    Work$ = ""
    For n=1 To Len(In$)
      CH = Asc(UCase(Mid(In$,n,1)))
      If CH > 64 And CH < 91
        Work$ + Chr(CH)
      EndIf
    Next

    PrintN("")
    PrintN("Der zu codierende Satz:")
    PrintN(Work$)

    Repeat
      PrintN("")
      Print("Bitte den Caesar-Schluessel eingeben (1-25): ")
      In$ = Input()
      Key = Val(In$)
      If Key < 1 Or  Key > 25
        Key = 0
        PrintN("Schluessel falsch: " + Str(Key) )
      EndIf
    Until Key > 0

    ;**************
    Out$ = ""
    For n=1 To Len(Work$)
      CH = Asc( Mid( Work$, n, 1 ) ) + Key
      If CH > 90
        CH - 26
      EndIf
      Out$ + Chr( CH )
    Next
    ;**************

    PrintN("")
    PrintN("Der mit Caesar VERschluesselte Satz:")
    PrintN(Out$)
    ;**************
  ElseIf Work = 2
    ;**************
    PrintN("Bitte den Satz eingeben, der mit Caesar ENTschluesselt werden soll.")
    Print(">")
    In$ = Input()

    Work$ = ""
    For n=1 To Len(In$)
      CH = Asc(UCase(Mid(In$,n,1)))
      If CH > 64 And CH < 91
        Work$ + Chr(CH)
      EndIf
    Next

    PrintN("")
    PrintN("Der zu decodierende Satz:")
    PrintN(Work$)

    Repeat
      PrintN("")
      Print("Bitte den Caesar-Schluessel eingeben (1-25): ")
      In$ = Input()
      Key = Val(In$)
      If Key < 1 Or  Key > 25
        Key = 0
        PrintN("Schluessel falsch: " + Str(Key) )
      EndIf
    Until Key > 0

    ;**************
    Out$ = ""
    For n=1 To Len(Work$)
      CH = Asc( Mid( Work$, n, 1 ) ) - Key
      If CH < 65
        CH + 26
      EndIf
      Out$ + Chr( CH )
    Next
    ;**************

    PrintN("")
    PrintN("Der mit Caesar ENTschluesselte Satz:")
    PrintN(Out$)
    ;**************
  EndIf
Until Work = 3
PrintN("")
PrintN("Tschuess!")
PrintN("")
Input()

[PeterJ]

Zugegeben, dann nennen wir es halt eine manipulierte Cäsarverschlüsselung.
Das müßte dann die Kleopatrachiffrierung sein, wenn ich mich nicht irre .