Préprocess - Cryptage des chaînes [Exemple factice]

Pour discuter de l'assembleur
Ollivier
Messages : 4190
Inscription : ven. 29/juin/2007 17:50
Localisation : Encore ?
Contact :

Préprocess - Cryptage des chaînes [Exemple factice]

Message par Ollivier »

Code pour crypter les chaînes.

2.2.4. Espaces d'adressage explique ceci:

Code : Tout sélectionner

 repeat $-$$
load a byte from $$+%-1
store byte a xor c at $$+%-1
end repeat
Porte OU eXclusive (En anglais : XOR Gate) a écrit : 1+1=2 impair+impair=pair
1+2=3 impair+pair=impair
2+3=5 pair+impair=impair
3+3=6 pair+pair=pair

Conditionne la non-parité d'une addition.
En effet, une somme est impaire si, exclusivement l'un ou l'autre de ses antécédants est impair.


Ajout 26 Août 2015
[ ! ] firace sur le site EN pointe l'article sur 'load' et 'store'

Ajout 23 Août 2015
/!\ macros 'load' et 'store' non identifiées
Je pense que ce sont des perles conçues par Fred, mais je n'ai demandé aucune confirmation, vu qu'il bosse à fond.

Cryptage /!\ /!\ /!\ FACTICE proche de l'algo
"a" = "b", "b" = "c", "c" = "d", etc... en terme de simplicité



Source : Simple preprocessor for string obfuscation
Auteur du sujet : Keya
Auteur du source : User_Russian

Code : Tout sélectionner

!macro ppublic name{
!if name eq _SYS_StaticStringEnd
!repeat $-_SYS_StaticStringStart
!load zczc from _SYS_StaticStringStart+%-1
!store zczc xor 137 at _SYS_StaticStringStart+%-1
!end repeat
!end if
!public name}
!public fix ppublic
CompilerIf #PB_Compiler_Processor = #PB_Processor_x86
!mov edi,_SYS_StaticStringStart
!mov ecx,_SYS_StaticStringEnd-_SYS_StaticStringStart
!@@:
!xor byte[edi],137
!inc edi
!dec ecx
CompilerElse
!mov rdi,_SYS_StaticStringStart
!mov rcx,_SYS_StaticStringEnd-_SYS_StaticStringStart
!@@:
!xor byte[rdi],137
!inc rdi
!dec rcx
CompilerEndIf
!jnz @b
MessageRequester("test test test", "Find this string in exe file")
Dernière modification par Ollivier le mar. 25/août/2015 23:54, modifié 3 fois.
zaphod_b
Messages : 76
Inscription : mar. 09/déc./2014 20:02

Re: Préprocess - Cryptage des chaînes

Message par zaphod_b »

D'après ce que j'ai compris, la macro est une macro de fasm pas de pb.

Elle code le texte au moment de la compilation de l'exe (le fasm est capable de pre process pas pb).
La deuxième partie du code décode le texte codé au lancement de l'exe.

En mémoire le texte de l'exe est en clair.

C'est un codage xor avec une clé 137
Avatar de l’utilisateur
SPH
Messages : 4726
Inscription : mer. 09/nov./2005 9:53

Re: Préprocess - Cryptage des chaînes

Message par SPH »

zaphod_b a écrit :C'est un codage xor avec une clé 137
Donc, pas securisé du tout quand on le sait :idea:
http://HexaScrabble.com/
!i!i!i!i!i!i!i!i!i!
!i!i!i!i!i!i!
!i!i!i!
//// Informations ////
Intel Core i7 4770 64 bits - GTX 650 Ti
Version de PB : 6.00 - 64 bits
Ollivier
Messages : 4190
Inscription : ven. 29/juin/2007 17:50
Localisation : Encore ?
Contact :

Re: Préprocess - Cryptage des chaînes

Message par Ollivier »

Bonjour zaphod,

déjà merci pour ta participation au punch, et pour ton maintien sur le forum. Merci aussi pour ta réponse tranquille.

Dans le "journal de Mickey" (flatassembler) il y est indiqué dans le sommaire (1ère page):

2.3.3. Macroinstructions

et l'on peut y voir la syntaxe qui correspond parfaitement. Si d'un côté l'on a des info de syntaxe, et de l'autre, un exemple, on va pouvoir observer la macro aussi précisément que les macros habituelles.
Avatar de l’utilisateur
Ar-S
Messages : 9477
Inscription : dim. 09/oct./2005 16:51
Contact :

Re: Préprocess - Cryptage des chaînes

Message par Ar-S »

Le code Fasm permet de ne pas avoir à se prendre le choux avec du prog externe et de l'include. C'est tout de même bien pratique, même si ça reste du cryptage de base, ça permet de planquer ces strings au 1er scriptkiddie doté d'un lecteur hexa.
Je vais le garder précieusement. :P
~~~~Règles du forum ~~~~
⋅.˳˳.⋅ॱ˙˙ॱ⋅.˳Ar-S ˳.⋅ॱ˙˙ॱ⋅.˳˳.⋅
W11x64 PB 6.x
Section HORS SUJET : ICI
LDV MULTIMEDIA : Dépannage informatique & mes Logiciels PB
UPLOAD D'IMAGES : Uploader des images de vos logiciels
Ollivier
Messages : 4190
Inscription : ven. 29/juin/2007 17:50
Localisation : Encore ?
Contact :

Re: Préprocess - Cryptage des chaînes

Message par Ollivier »

L'architecture du code:

Code : Tout sélectionner

! macro ppublic etc{
! ...
! Partie 1
! ...
}

! public fix ppublic

CompilerIf
! ...
! Partie 2a
! ...
CompilerElse
! ...
! Partie 2b
! ...
! CompilerEndIf
Ollivier
Messages : 4190
Inscription : ven. 29/juin/2007 17:50
Localisation : Encore ?
Contact :

Re: Préprocess - Cryptage des chaînes

Message par Ollivier »

En fait, c'est "fix" qui va être "pré-compilé" en 1er (doc flat : rechercher " fix" avec un espace devant, sinon je fais une visite guidée de tous les mots "prefix" et autres avant de trouver "fix")

Code : Tout sélectionner

! public fix ppublic
Tous ce qui invoque "public" est transformé en "ppublic" dans le code grâce à "fix", et "ppublic" c'est la macro de la partie 1.

L'architecture du code:

Code : Tout sélectionner

! macro ppublic etc{
! ...
! Partie 1
! ...
}

! public fix ppublic

CompilerIf
! ...
! Partie 2a
! ...
CompilerElse
! ...
! Partie 2b
! ...
! CompilerEndIf
Donc, pour maîtriser ce code, il est grandement recommandé de vérifier un code ASM commenté avec l'option "/commented" du compilateur. Pour déceler les occurences "public" et savoir ce qu'il font.
Ollivier
Messages : 4190
Inscription : ven. 29/juin/2007 17:50
Localisation : Encore ?
Contact :

Re: Préprocess - Cryptage des chaînes

Message par Ollivier »

Dans l'IDE: avec F1 puis clic [manouel], [process], [RunProgram], on trouve un bel exemple pour gérer le compilateur.

Donc, je l'ai utilisé pour mettre le fichier Assembleur de ce même programme dans le presse-papier.

J'ai mis une sécurité (ligne 2) pour éviter une compilation répétée à l'infini.

Il faut rajouter une option bidon (ex: "pif") dans les paramètres de la ligne de commande (IDE: options compilateur) pour que ça marche.

Donc, en exécutant ce code avec paramètre bidon et en collant ensuite le presse-papier dans un scope vierge (IDE : nouveau), vous avez le listing Asm devant les yeux.

On va chercher public...

(Note : ça me donne un presse-papier plein de points d'interrogation '?' en compilation unicode, si d'autres peuvent confirmer ou infirmer cette anomalie)

Code : Tout sélectionner

				OS.S = "/"
				If CountProgramParameters()
							CopyFile(#PB_Compiler_File, "pifomet")
							Compilateur = RunProgram(#PB_Compiler_Home + "/Compilers/pbcompiler", "pifomet " + OS + "COMMENTED", "", #PB_Program_Open | #PB_Program_Read | #PB_Program_Hide)
							If Compilateur 
									While ProgramRunning(Compilateur)
										If AvailableProgramOutput(Compilateur)
											ReadProgramString(Compilateur)
     									EndIf
   								Wend
    								Err = ProgramExitCode(Compilateur)
    								CloseProgram(Compilateur)
    						EndIf
    						DeleteFile("pifomet", #PB_FileSystem_Force)
    						If Err
    								MessageRequester("Erreur", "")
    						Else
    								Asm.S = #PB_Compiler_Home + "Purebasic.ASM"
		    						Lg = FileSize(Asm)
    								*M = AllocateMemory(Lg)
    								pif = OpenFile(#PB_Any, Asm)
    								If pif
    									ReadData(pif, *M, Lg)
	    								SetClipboardText(PeekS(*M, Lg) )
    								EndIf
    						EndIf
    			EndIf
Ollivier
Messages : 4190
Inscription : ven. 29/juin/2007 17:50
Localisation : Encore ?
Contact :

Re: Préprocess - Cryptage des chaînes

Message par Ollivier »

Ouh toi si tu mets ça, c'est que mon code ne marche pas! Je vérifierai après...

En attendant, j'ai qquechose sur le double symbole bigoudi

Code : Tout sélectionner

!@@:
est expliqué dans le dernier paragraphe de la section 1.2.3. du "journal de mickey".

C'est un label sans nom.
Et b@ (Below bigoudi = bigoudi d'avant) c'est le dernier label sans nom existant avant cette ligne de code.

En gros,

Code : Tout sélectionner

!@@:
!jmp b@
équivaut à

Code : Tout sélectionner

Repeat: Forever
On a 2 conversions XOR (cryptage factice). Le problème c'est que les conversions sont sur 2 couches. L'une gérée par iPB (Parties 2a et 2b, ce qui se situe entre CompilerIf et CompilerEndIf: !jnz etc...), l'autre par FASM. Donc complication!
Ollivier
Messages : 4190
Inscription : ven. 29/juin/2007 17:50
Localisation : Encore ?
Contact :

Re: Préprocess - Cryptage des chaînes

Message par Ollivier »

En espérant que cela soit compréhensible.

Code : Tout sélectionner

;***
; Auteur : User_Russian
; Exemple de cryptage/décryptage automatique
; /!\ L'algo utilisé en exemple est factice
; http://www.purebasic.fr/french/viewtopic.php?f=12&t=15383
; Date : Août 2015
; Commentaire : Olliv
; ***
 
; ***
; Partie 1 / 2 : Cryptage à la compilation
; ***

; Attribution de code supplémentaire à 
; la macro(!) 'public' via
; la macro(!) intermédiaire 'ppublic'
; Objectif : cibler la zone à crypter

!macro ppublic name{

; Code rajouté : Début de rajout

; A-t-on affaire au 'public' de fin de zone?
!if name eq _SYS_StaticStringEnd

; Si c'est le cas, ça tombe bien, ça nous intéresse.

; On démarre une boucle de la taille de la zone concernée
!repeat $-_SYS_StaticStringStart

; Pour chaque octet visité...

; on l'attrape
!load zczc from _SYS_StaticStringStart+%-1

; on le crypte (ici, c'est factice : XOR)
!store zczc xor 137 at _SYS_StaticStringStart+%-1

; octet suivant (rebelote)
!end repeat

; Voilà, c'était le cas. Donc, désormais...
!end if

; Le 'public' original peut être invoqué
!public name}

 ; Code rajouté : Fin de rajout

; Bifurcation vers notre nouvelle macro
 !public fix ppublic

; ***
; Partie 2 / 2 : Décryptage à l'exécution
; ***

; Deux codes respectifs selon l'adressage usuel
CompilerIf #PB_Compiler_Processor = #PB_Processor_x86
 
; 1er cas : Décryptage sur adressage 32 bits

; Repère l'adresse de départ
!mov edi,_SYS_StaticStringStart
; Repère la quantité d'octet
!mov ecx,_SYS_StaticStringEnd-_SYS_StaticStringStart
; Label de début de boucle. Pour chaque octet crypté...
!@@:
!xor byte[edi],137 ; décrypte
!inc edi ; octet suivant
!dec ecx ; compte à rebours

CompilerElse

 ; 2nd cas : Décryptage sur adressage 64 bits

 ; Repère l'adresse de départ

 !mov rdi,_SYS_StaticStringStart
 ; Repère la quantité d'octet
 !mov rcx,_SYS_StaticStringEnd-_SYS_StaticStringStart
 ; Label de début de boucle. Pour chaque octet crypté...
!@@:
!xor byte[rdi],137 ; décrypte 
!inc rdi ; octet suivant 
!dec rcx ; compte à rebours 

CompilerEndIf

; Equivalent du Next (commun aux 2 cas d'adressage)
!jnz @b

MessageRequester("test test test", "Find this string in exe file")
PAPIPP
Messages : 534
Inscription : sam. 23/févr./2008 17:58

Re: Préprocess - Cryptage des chaînes

Message par PAPIPP »

Bonjour à tous
J’ai testé ce prg avec des chaines dans une procédure .
Toutes les chaines sont cryptées dans le fichier *.exe

Voici le schéma des divers opérations exécutées et comprises ente le fichier PB et le fichier *.exe
1 .pb -> (pbcompiler.exe) -> .asm
2. .asm -> (fasm.exe) -> .obj
3. .obj + lib + .userlib + .rc -> (polink.exe) -> .exe / .dll

Voici le code du prg.pb

Code : Tout sélectionner

!macro ppublic name{
!if name eq _SYS_StaticStringEnd
!repeat $-_SYS_StaticStringStart
!load zczc from _SYS_StaticStringStart+%-1
!store zczc xor 137 at _SYS_StaticStringStart+%-1
!end repeat
!end if
!public name}
!public fix ppublic
CompilerIf #PB_Compiler_Processor=#PB_Processor_x86
!mov edi,_SYS_StaticStringStart
!mov ecx,_SYS_StaticStringEnd-_SYS_StaticStringStart
!@@:
!xor byte[edi],137
!inc edi
!dec ecx
CompilerElse
!mov rdi,_SYS_StaticStringStart
!mov rcx,_SYS_StaticStringEnd-_SYS_StaticStringStart
!@@:
!xor byte[rdi],137
!inc rdi
!dec rcx
CompilerEndIf
!jnz @b
Procedure chainecryte(Chainext.s)
  test3$="chaine interne à la procédure"
  MessageRequester("3em test ",test3$+" "+chainext)
EndProcedure 

MessageRequester("test1 test1 test1","Chercher la chaine en *.exe file")
; ***********  2em test pour vérifier si cette chaine est aussi cryptée dans *.exe  **********
TEST$="Bonjour vous étes crypté en *.exe mais décrypté à l'exécution"
MessageRequester("2em test ",test$)
Testext$="Chaine externe à la procédure"
chainecryte(Testext$)
Comme vous pouvez le constater dans le développé partiel ASM ci-dessous toutes le chaines sont comprises entre
_SYS_StaticStringStart
Et
_SYS_StaticStringEnd
Donc elles seront donc toutes cryptées à la compilation

Code partiel du généré asm du prg *pb ci-dessus
public _SYS_StaticStringStart
_SYS_StaticStringStart:
_S3: db " ",0
_S8: db "Chaine externe à la procédure",0
_S7: db "2em test ",0
_S5: db "Chercher la chaine en *.exe file",0
_S4: db "test1 test1 test1",0
_S2: db "3em test ",0
_S1: db "chaine interne à la procédure",0
_S6: db "Bonjour vous étes crypté en *.exe mais décrypté à l'exécution",0
pb_public PB_NullString
db 0
public _SYS_StaticStringEnd
_SYS_StaticStringEnd:
A+
Il est fort peu probable que les mêmes causes ne produisent pas les mêmes effets.(Einstein)
Et en logique positive cela donne.
Il est très fortement probable que les mêmes causes produisent les mêmes effets.
PAPIPP
Messages : 534
Inscription : sam. 23/févr./2008 17:58

Re: Préprocess - Cryptage des chaînes

Message par PAPIPP »

Pour ceux qui veulent voir le généré ASM à partir d’un fichier PB

Voici un prg qui place le fichier *.asm dans notepad.

Code : Tout sélectionner

Procedure.l FindTargetPIDByWindowName(Name.s,Opt.l=0)
  ;Opt option pour obtenir soit le PID soit Handle
  ;opt=O par defaut donne PID
  ;opt=1 donne le Handle
  ; Name est le nom window
  
  Define.l hWnd,Pid
  hWnd=FindWindow_(#Null,Name)
  If hWnd<>0
    GetWindowThreadProcessId_(hWnd,@Pid)
  EndIf
  If opt=0
    ProcedureReturn Pid
  Else
    ProcedureReturn hWnd
  EndIf
EndProcedure
ExamineDesktops()
HAUTEUR_W=DesktopHeight(0)
Largeur_W=DesktopWidth(0)

Nb_param=CountProgramParameters()
If nb_param
  Dim Tparam.s{256}(Nb_param)
  For param=0 To NB_PARAM
    Tparam(param)=ProgramParameter(Param)
  Next
  fichier$=Trim(Tparam(0))
  result$=""
  If Nb_param>1
    result$="*** Il manque très certainement les quotes qui encadrent le nom du fichier ***"+#LF$+#LF$
    For param=0 To NB_PARAM
      result$+Tparam(param)+#LF$
    Next
    ;   result$+#LF$+" exemple de paramètre : "+#LF$+Chr(34)+"Nom entier avec répertoire du proramme PB"+Chr(34)+"   [/notepad]"+#LF$
    result$+#LF$+" exemple de paramètre : "+#LF$+Chr(34)+"Nom entier avec répertoire du proramme PB"+Chr(34)+"  "+#LF$
  EndIf
  If fichier$<>"" And FileSize(fichier$)<0
    result$+#LF$+" Le fichier :"+fichier$+" n'existe pas"
  EndIf
  If result$<>""
    fichier$=""
    MessageRequester("Erreur dans les paramètres passés. ",result$,#PB_MessageRequester_Ok)
    End
  EndIf
EndIf 
; Mesg$=Str(#PB_Compiler_Line)+"  Fichier à convertir"
Mesg$=" Fichier PB  à convertir"
lMesg=Len(Mesg$)
While fichier$=""
  fichier$=OpenFileRequester(Mesg$,"","*.pb;*.pbi",0)
  Mesg$+Space(10)
  If Len(Mesg$)>lmesg+11
    End
  EndIf
Wend

chemin$=GetPathPart(fichier$)
nom_fichier$=Left(GetFilePart(fichier$),Len(GetFilePart(fichier$))-1-Len(GetExtensionPart(fichier$)))
#guil=Chr(34)

;   Debug #PB_Compiler_Home+"/Compilers/pbcompiler"+_s(nom_fichier$)+_s(chemin$)
; ; /DEBUGGER: Enable the debugger
; ; /EXE "Filename": Create an executable To the given filename
; ; /DLL: Create a DLL
; ; /CONSOLE: Create a console executable
; ; /ICON "Filename": ADD an icon To the executable
; ; /RESOURCE "Filename": ADD a resource file (.rc) To the executable
; ; /QUIET: Disable all unnecessary textoutput
; ; /COMMENTED: Produce a commented asm output (PureBasic.asm)
; ; /REASM: Compile the 'PureBasic.asm' file To an executable
; ; /XP: ADD the Windows XP theme support To the executable
; ; /USER: ADD the 'User' hint To the executable (Windows Vista)
; ; /ADMINISTRATOR: ADD the 'Administrator' hint To the executable (Windows Vista)
; ; /INLINEASM: Enable the inline ASM support  ;===>>> N'EXISTE PLUS A PARTIR DE PB520
; ; /RESIDENT "Filename": Create a resident file To the given filename
; ; /IGNORERESIDENT "Filename": ignore the given resident
; ; /LINENUMBERING: Enable line numbering IN the final executable For OnError
; ; /STANDBY: WAIT For external commands (editor, scripts...)
; ; /MMX, /3DNOW, /SSE Or /SSE2: Create a processor specific executable
; ; /DYNAMICCPU: Create a executable containing all processor specific routines
; ; /THREAD: Use thread safe Runtime For strings And general routines
; ; /UNICODE: Use unicode instead ascii For strings management
; ; /PURIFIER: Enable the purifier
; ; /SUBSYSTEM "Name": Use this subsystem To replace a set of internal functions
; ; /CONSTANT Name=Value: Declare a new constant at compile time
; ; /LINKER "ResponsFile": Specify a commands file To be passed To the linker
; ; /CHECK: Check the syntax only, doesn't create/launch the executable
; ;
; ; /LANGUAGE "Language": Uses the specified language For the compiler
; ;
; ; /VERSION: Display the version of the compiler
Debug chemin$+"purebasic.exe"

TAILFIL1=FileSize(chemin$+"purebasic.exe")
If TAILFIL1>0
  DeleteFile(chemin$+"purebasic.exe",#PB_FileSystem_Force)
EndIf
TAILFIL1=FileSize(chemin$+"purebasic.asm")
If TAILFIL1>0
  DeleteFile(chemin$+"purebasic.asm",#PB_FileSystem_Force)
EndIf
TAILFIL2=FileSize(chemin$+nom_fichier$+".asm")
If TAILFIL2>0
  DeleteFile(chemin$+nom_fichier$+".asm",#PB_FileSystem_Force)
EndIf
; If MessageRequester(#PB_Compiler_Home,fichier$,#PB_MessageRequester_YesNo)=#PB_MessageRequester_Yes
;***************************  RECHERCHE _DU _COMPILATEUR   *********************************************
FichierParDefaut$="L:\Program files\"   ; Répertoire et fichier par défaut qui seront affichés
Filtre$+"EXE (*.EXE)|*.exe|"            ; Premier filtre (index = 0)
Filtre$+"Tous les fichiers (*.*)|*.*"   ; Quatrième filtre (index = 1)
Filtre=0                                ; utiliser  par défaut le premier des trois filtres possibles
TITRE$="Donnez le non du compilateur PB que vous désirez utiliser Ex: Pbcompiler.exe"
ltitr=Len(titre$)
BOUC1:
TITRE$+Space(10)
Fichierc$=OpenFileRequester(Titre$,FichierParDefaut$,Filtre$,Filtre)
If FICHIERc$>""
ElseIf Len(titre$)<ltitr+11
  TITRE$+Space(10)
  Goto BOUC1
Else
  MessageRequester("Apès 3 tentatives STOP","STOP STOP STOP")
  End
EndIf
Compilateur=RunProgram(Fichierc$,#guil+fichier$+#guil+" /COMMENTED ",chemin$,#PB_Program_Hide | #PB_Program_Open | #PB_Program_Read)

Sortie$=""
If Compilateur
  While ProgramRunning(Compilateur)
    If AvailableProgramOutput(Compilateur)
      Sortie$+ReadProgramString(Compilateur)+Chr(13)
    EndIf
  Wend
  exit_code=ProgramExitCode(compilateur)
  Sortie$+Chr(13)+Chr(13)
  Sortie$+"Code de retour : "+Str(ProgramExitCode(Compilateur))
  CloseProgram(Compilateur) ; Ferme la connection vers le compilateur
  If FileSize(chemin$+nom_fichier$+".exe")>0
    DeleteFile(chemin$+nom_fichier$+".exe")
  EndIf
  If RenameFile(chemin$+"purebasic.exe",chemin$+nom_fichier$+".exe")
  Else
    SORTIE$+#LFCR$+" Le fichier "+chemin$+"purebasic.exe ne peut être renommé"
  EndIf
  If FileSize(chemin$+nom_fichier$+".asm")>0
    DeleteFile(chemin$+nom_fichier$+".asm")
  EndIf
  PB_COMP_H$=#PB_Compiler_Home
  PB_COMP_H2$=ReplaceString(PB_COMP_H$,"\","_")
  PB_COMP_H$=ReplaceString(PB_COMP_H2$,":","_")
  ;   nom_fichier$=PB_COMP_H$+"_"+nom_fichier$
  If RenameFile(chemin$+"purebasic.asm",chemin$+nom_fichier$+".asm")
  Else
    SORTIE$+#LFCR$+" Le fichier "+chemin$+PB_COMP_H$+"_"+"purebasic.asm ne peut être renommé"
  EndIf
  
  ;     If edit=1
  compil=RunProgram("notepad",chemin$+nom_fichier$+".asm"," ")
  ;********************************************************************************************************************
  ;       RUN_PRG_AL=RunProgram("notepad",GpathAL$+"file_al.txt","")
  Delay(50)
  cpt=0
  file_c$=nom_fichier$+".asm - Bloc-notes"
  While HNDL_BLOC=0 And cpt<100
    cpt+1
    HNDL_BLOC=FindTargetPIDByWindowName(file_c$,1)
    ;       Debug _n( HNDL_BLOC)+_s(file_c$)
    Delay(50)
  Wend
  Delay(100)
  SetWindowPos_(HNDL_BLOC,#HWND_NOTOPMOST,10,10,Largeur_w/3+50,HAUTEUR_W-50,0) ;:
  
  If exit_code<>0
    MessageRequester("Sortie",Sortie$)
  EndIf
EndIf
; EndIf
A+
Il est fort peu probable que les mêmes causes ne produisent pas les mêmes effets.(Einstein)
Et en logique positive cela donne.
Il est très fortement probable que les mêmes causes produisent les mêmes effets.
Ollivier
Messages : 4190
Inscription : ven. 29/juin/2007 17:50
Localisation : Encore ?
Contact :

Re: Préprocess - Cryptage des chaînes

Message par Ollivier »

Merci PAPIPP pour ta participation. Je vais encore passer trois mois à tout comprendre!!!

Bon, par contre, attention: le code de décryptage a le cul nu en début de code dans le fichier exécutable.

Comme le dit Ar-S, ça ajoute une difficulté pour les curieux, mais ça ne les arrête pas! C'est vraiment la simplicité de la mise en place, qui est un plus.
PAPIPP
Messages : 534
Inscription : sam. 23/févr./2008 17:58

Re: Préprocess - Cryptage des chaînes

Message par PAPIPP »

Bonjour à tous
Voici le prg commenté.
L’auteur de ce prg connait parfaitement FASM. Chapeau et bravo pour cet exploit.
Ce prg permet de crypter les chaines de caractères dans l'exécutable *.exe et de les décrypter à l'exécution.

Code : Tout sélectionner

; . Le symbole spécial $, est toujours égal à la valeur de l'adresse courante, tandis que $$ est égal à l'adresse de base de l'espace d'adressage courant
;   L'autre est %, est le nombre de répétitions en cours dans les parties du code qui sont répétées
!macro ppublic name{
!if name eq _SYS_StaticStringEnd
!repeat _SYS_StaticStringEnd-_SYS_StaticStringStart ; on peut remplacer $ par _SYS_StaticStringEnd
; !repeat $-_SYS_StaticStringStart  ;                 Repeat charge % avec la valeur (_SYS_StaticStringEnd-_SYS_StaticStringStart) ou ($-_SYS_StaticStringStart)

; !load zczc from _SYS_StaticStringStart+%-1
; !store zczc xor 137 at _SYS_StaticStringStart+%-1
!load zcza from _SYS_StaticStringStart+%-1  ;       chargement du byte ou de l'octet à l'adresse  _SYS_StaticStringStart+%-1 dans la variable zcza
!store zcza xor 137 at _SYS_StaticStringStart+%-1 ; après xor sur zcza le byte zcza sera envoyé crypté  à la même adresse _SYS_StaticStringStart+%-1
!end repeat ;                                       répète la boucle tant que %  est différent de zéro
!end if
!public name}
!public fix ppublic ; la directive fix oblige la macro ASM  à être exécuté avant l'assemblage donc cryptage des chaines avant l'assemblage
;                      Vous pouvez mettre cette instruction en commentaire et faire un essai vous n'aurez plus qu'un cryptage à l'exécution
;                     la macro FASM  ppublic se termine avec l' accolade droite fermante "}"

;************************************************************************************************************************
; les instructions suivantes servent au décryptage lors de l'exécution (choix suivant que vous êtes sous 32 ou 64 bits)
; il ne reste au moment de l'assemblage passage dans FASM que l'une ou l'autre des parties 32 ou 64 bits
; donc le label @@; sera bien le premier et bon label dans l'instruction !jnz @b (jump si zero dans rcx ou ecx vers le premier label banalisé @@)
; vous pouvez vérifier dans le prg *.asm
CompilerIf #PB_Compiler_Processor=#PB_Processor_x86
!mov edi,_SYS_StaticStringStart
!mov ecx,_SYS_StaticStringEnd-_SYS_StaticStringStart
!@@:
!xor byte[edi],137
!inc edi
!dec ecx
CompilerElse
!mov rdi,_SYS_StaticStringStart
!mov rcx,_SYS_StaticStringEnd-_SYS_StaticStringStart
!@@:
!xor byte[rdi],137
!inc rdi
!dec rcx
CompilerEndIf
!jnz @b
ProcedureDLL chainecryte(Chainext.s)
  test3$="chaine interne à la procédure"
  MessageRequester("3em test ",test3$+" "+chainext)
EndProcedure

MessageRequester("test1 test1 test1","Chercher la chaine en *.exe file")
; ***********  2em test pour vérifier si cette chaine est aussi cryptée dans *.exe  **********
TEST$="Bonjour vous étes crypté en *.exe mais décrypté à l'exécution"
MessageRequester("2em test ",test$)
Testext$="Chaine externe à la procédure"
chainecryte(Testext$)
A+
Dernière modification par PAPIPP le ven. 21/août/2015 9:41, modifié 1 fois.
Il est fort peu probable que les mêmes causes ne produisent pas les mêmes effets.(Einstein)
Et en logique positive cela donne.
Il est très fortement probable que les mêmes causes produisent les mêmes effets.
Ollivier
Messages : 4190
Inscription : ven. 29/juin/2007 17:50
Localisation : Encore ?
Contact :

Re: Préprocess - Cryptage des chaînes

Message par Ollivier »

@PAPIPP

C'est super ça. J'avais hésité à le mettre. Finalement, je ne regrette pas de l'avoir zappé. Vraiment bien que tu aies pu solliciter un habitué.

Ça se voit que c'est quelqu'un de bien: il m'en laisse encore un bout!

Il reste encore les (-1) à asservir à (-2) pour le support UNICODE si détecté nécessaire.

Et puis les acquisitions de 'load' et 'store', savoir leur origine et leur syntaxe.

Je pense que tu te souviens de cette phrase
" 'mer' est dans 'mercredi' "

Ben c'est un des problèmes évoqués dans ce sujet: les macros en FASM peuvent évoluer ainsi aussi. Elle peuvent s'imbriquer par alternance de syntaxe, comme dans cette phrase. Il y a donc deux syntaxes de macros en FASM contre une seule sous iPB.

Il ne faudra pas que j'oublie les numéros des sections dans la doc. ça en fait 2 dans le vent ('$' et syntaxes de macros)

@TazNormand

Il y a un bouton qui s'appelle mp. Peux-tu l'utiliser pour préciser ta demande?
Répondre