PureBasic

Code : Tout sélectionner

 repeat $-$$
load a byte from $$+%-1
store byte a xor c at $$+%-1
end repeat

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")

Code : Tout sélectionner

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

! public fix ppublic

CompilerIf
! ...
! Partie 2a
! ...
CompilerElse
! ...
! Partie 2b
! ...
! CompilerEndIf

Code : Tout sélectionner

! public fix ppublic

Code : Tout sélectionner

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

! public fix ppublic

CompilerIf
! ...
! Partie 2a
! ...
CompilerElse
! ...
! Partie 2b
! ...
! CompilerEndIf

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

Code : Tout sélectionner

!@@:

Code : Tout sélectionner

!@@:
!jmp b@

Code : Tout sélectionner

Repeat: Forever

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")

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$)

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

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$)