cryptage ameliorable

[SPH]

chryptage a ameliorer

Code : Tout sélectionner

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;  lettre par lettre : c'est nul  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;    :cry: 
Global txt$, txt2$, key.w

txt$="ßðµæàüæµðûµðóóðáµàûµ÷úáµøôùãðüùùôûáµ´"

Procedure dec_enc(txt$,key.w)
  txt2$=""
  For i=1 To Len(txt$)
    a=Asc(Mid(txt$,i,1))
    a!key
  txt2$+Chr(a)
Next
Debug txt2$
EndProcedure

dec_enc(txt$,149)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;  existe t'il une methode radicale pour X-oriser des blocs 64 bits par 64 bits ?? ;;;;;;;;;;;;;;    :twisted: 

txt1$="Salut la compagnie, ceci est un texte de 37 lettres"
mdp$="brouillage par XOr generé sur txt1$!!!!!!!!!!!!!!!!"


Debug Len(txt1$)
Debug Len(mdp$)

Debug txt1$!mdp$  ; ;    le bonheur ici si ca marchait!!

[SPH]

Mon code "XOrise" chaque lettre.

Avez vous une methode pour XOriser une chaine de caracteres en une seule fois ?

Thx

[venom]

Salut sph.

Je ne suis pas sûr ordinateur pour essayer, mais j'ai demandé a GPT il m'a sortie ça :

Code : Tout sélectionner

Procedure.s XOR64(txt$, key$)
  Protected result$, i, blockTxt.q, blockKey.q

  If Len(txt$) <> Len(key$)
    Debug "Erreur : La clé et le texte doivent avoir la même longueur"
    ProcedureReturn ""
  EndIf
  
  For i = 1 To Len(txt$) Step 8
    blockTxt = PeekQ(@txt$ + i - 1)   ; Récupère un bloc de 8 octets du texte
    blockKey = PeekQ(@key$ + i - 1)   ; Récupère un bloc de 8 octets de la clé
    PokeQ(@result$ + i - 1, blockTxt ! blockKey)  ; Stocke le résultat XORisé
  Next
  
  ProcedureReturn result$
EndProcedure

txt1$ = "Salut la compagnie, ceci est un texte de 37 lettres "
mdp$  = "brouillage par XOr generé sur txt1$!!!!!!!!!!!!!!!!"

Debug XOR64(txt1$, mdp$)  ; Chiffre le texte
Debug XOR64(XOR64(txt1$, mdp$), mdp$)  ; Déchiffre

Je ne sais pas si c'est vraiment optimisé

Explication :

Une solution radicale est d'utiliser des opérations XOR sur des entiers 64 bits (Quad en PureBasic) pour traiter les données par blocs de 8 octets.

Blocs de 64 bits : On traite les données par tranches de 8 octets (Quad = 64 bits).
PeekQ & PokeQ : Ils permettent de manipuler les octets directement en mémoire, ce qui est plus rapide.
Double application de XOR : Chiffrer, puis appliquer à nouveau la clé redonne le texte original.
C'est une méthode beaucoup plus efficace que le traitement caractère par caractère. Elle améliore la performance tout en gardant la simplicité du XOR.

Vous si ça fonctionne et ça te convient







@++

[Mindphazer]

Déjà, il faut enlever l'espace final de txt1$, sinon la chaîne et la clé n'ont pas le même nombre de caractères.

Et le résultat, c'est une erreur "L'adresse spécifiée est nulle" sur le PokeQ()

ChatGPT a encore des progrès à faire

[venom]

ChatGPT a encore des progrès à faire

Oui j'en doute pas. C'est pour ça que j'ai précisé que je n'ai pas compiler.
Mais ça peut "mâcher" le travail pour sph






@++

[SPH]

Oui, on peux XOriser avec un byte (8 bits), mais aussi avec 16, 32 ou 64 bits d'un coup.
D'ailleurs, j'utilise des Quads XOr mais il y a un "mais" : il peux y avoir un reste.

Par exemple, un message de 136 bits. Ca fait 2 quads (128 bits) + 1 octet (non XOirsé par un Quad).

--

En fait, je me demandais si il n'y avait pas une methode pour copier les 136 bits d'un coup tout en les XOrisant !