Conversion hexa/texte en binaire

SPH · Message par **SPH** » mer. 20/sept./2006 18:12

Cpl.Bator a écrit :
je ne comprend pas ta reaction SPH...
d'ailleurs je te trouve étrange en ce moment, le MP que tu m'as envoyer sans bonjour ni au revoir ni le pourquoi du comment , juste une question... m'a paru assez bizarre.

@bator :
Probablement parce que je suis le plus grand PIRATE de TOUS LES TEMPS : HAHHAHAHAHHAHAHAHHAAHAHAHAHAHHAHAHAHHAA

... ouf, ca, c'est fait...

SPH · Message par **SPH** » mer. 20/sept./2006 19:26

4.7 fois plus rapide et 2.2 fois moins lourd :

Code : Tout sélectionner

#src=0 
#dst=1 
Word1.w
Word2.w
Word3.w
Word4.w
Word5.w
Word6.w
Word7.w
Word8.w
Byte1.b
Byte2.b
Byte3.b
LWord1.l
LWord2.l
LWord3.l
LWord4.l

;;;;;;;;
source$=OpenFileRequester("Fichier à convertir","*.*","*.*",1)
destin$=SaveFileRequester("Sauver sous","SPH.hex","*.*",1) 

;;;;;;;;
If ReadFile(#src, source$)
lg = Lof(#src) 
Else
MessageRequester("Erreur", "Fichier impossible à lire...")
End
EndIf
;;;;;;;;
If lg=0
MessageRequester("Inutilité", "Votre fichier est vide !")
End
EndIf
;;;;;;;;
If CreateFile(#dst, destin$)
Else
MessageRequester("Erreur", "Fichier impossible à créer...")
End
EndIf
;;;;;;;;


reste = lg%12
paquet = lg/12


temps = GetTickCount_() 


While paquet>0
Lecture1.l = ReadLong(#src)
Lecture2.l = ReadLong(#src)
Lecture3.l = ReadLong(#src)

!XOR      edx,edx

!MOV      dword eax,[v_Lecture1]
!MOV      dx,ax
!SHL      edx,4
!SHR      dx,2
!SHR      dl,2
!ADD      dx,8481
!MOV      word[v_Word1], dx

!SHR      eax,16
!MOV      dx,ax
!SHL      edx,4


!SHR      dx,2
!SHR      dl,2
!ADD      dx,8481
!MOV      word[v_Word2], dx

!MOV      dword eax,[v_Lecture2]
!MOV      dx,ax
!SHL      edx,4
!SHR      dx,2
!SHR      dl,2
!ADD      dx,8481
!MOV      word[v_Word3], dx

!SHR      edx,14
!SHR      dl,2
!ADD      dx,8481

!MOV      word[v_Word4], dx

!XOR      edx,edx

!SHR      eax,16
!MOV      dx,ax
!SHL      edx,4
!SHR      dx,2
!SHR      dl,2
!ADD      dx,8481
!MOV      word[v_Word5], dx

!MOV      dword eax,[v_Lecture3]
!MOV      dx,ax
!SHL      edx,4
!SHR      dx,2
!SHR      dl,2
!ADD      dx,8481
!MOV      word[v_Word6], dx

!SHR      eax,16
!MOV      dx,ax
!SHL      edx,4
!SHR      dx,2
!SHR      dl,2
!ADD      dx,8481
!MOV      word[v_Word7], dx

!SHR      edx,14
!SHR      dl,2
!ADD      dx,8481
!MOV      word[v_Word8], dx

WriteWord(#dst,Word1) 
WriteWord(#dst,Word2) 
WriteWord(#dst,Word3) 
WriteWord(#dst,Word4)
WriteWord(#dst,Word5)
WriteWord(#dst,Word6)
WriteWord(#dst,Word7)
WriteWord(#dst,Word8)

paquet-1
Wend

;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;

While reste>=3
Byte1.b = ReadByte(#src)
Byte2.b = ReadByte(#src)
Byte3.b = ReadByte(#src)

!XOR      eax,eax

!MOV      byte al,[v_Byte1]
!MOV      byte ah,[v_Byte2]

!SHL      eax,4
!SHR      ax,2
!SHR      al,2
!ADD      ax,8481
!MOV      word[v_Word1], ax

!MOV      byte ah,[v_Byte3]
!SHR      eax,6
!SHR      al,2
!ADD      ax,8481
!MOV      word[v_Word2], ax

WriteWord(#dst,Word1) 
WriteWord(#dst,Word2) 

reste-3
Wend

;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;

While reste>0
Byte1.b = ReadByte(#src)

!XOR      eax,eax

!MOV      byte al,[v_Byte1]

!SHL      ax,4
!SHR      al,4
!ADD      ax,8481
!MOV      word[v_Word1], ax

WriteWord(#dst,Word1) 

reste-1
Wend


CloseFile(#src)
CloseFile(#dst)

MessageRequester("Etat du programme", "Conversion finie " +Str( GetTickCount_()-temps )+" ms")

andrebernard · Message par **andrebernard** » jeu. 21/sept./2006 11:47

Bonjour

Pour SPH, d'abord j'ai 2 neurones et non pas trois(VIRGULE) et de plus je t'ai deja repondu a ce sujet 8 post plus haut.
Peut etre n'a tu pas daigner tous les lire ....
Je n'y reviendrais donc pas ...

Je rejoins completement CPL.Bator que je remercie au passage de son soutiens, que tu sois le + gd prirate du monde(VIRGULE) ne prive pas de la politesse(VIRGULE) ni du bon français.

Apparement vu ton niveau(VIRGULE) je pense que tu devais secher les cours de français pour te consacrer à l'informatique.

En tout cas bravo pour ce code (VIRGULE) c'est de balle.

Tu es donc à demi pardonné.

Un question(VIRGULE) je pense que d'ailleur tu devais l'attendre(VIRGULE) pourrais tu creer le meme code pour faire machine arriere ????

Je te remercie de ta competence(VIRGULE) et comme tu peux le voir mon nouveau post ne contiens aucune virgule qui gachent comme tu le fais si bien remarqué de la place.

Bonne journée à tous

PS:

Est que le plus grand pirate du monde pourrait aussi me donner un coup de main sur un post auquel je n'ai pas eu beaucoup de réponses positives

http://purebasic.forum-gratuit.com/viewtopic.php?t=5634

Merci d'avance

Patrick88 · Message par **Patrick88** » jeu. 21/sept./2006 14:28

pour info, ce programme me sert à cela par exemple :

Code : Tout sélectionner

;{  = Structure de fichier PARADOX 
; Header				2048 bytes 
; 	$0000 - $0057 = ALL PARADOX -> fixed field locations 
;		$0058 - $0077 = PARADOX 4+ 	-> Data File Header ( only for .DB data and .Xnn index files )
; Data bloc 0
; Data bloc 1
; Data bloc 2
; ...
; Data bloc n
; This hi-byte to lo-byte arrangement only applies to the user data in the table
;} Evething uses the normal low-byte to hi-byte format

;{ début du fichier : IZCODP03.DB = $0000 - $0057
;       0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F 
; 0000 6B,00,00,08,00,02,21,00, 00,00,03,00,03,00,01,00, 
; 0010 02,00,AD,00,00,00,5C,7F, EF,6B,EC,E7,EF,6B,00,00, 
; 0020 00,06,00,01,00,00,FF,00, FF,B7,00,00,00,9A,76,00, 
; 0030 6E,88,EF,6B,62,88,EF,6B, 00,0C,03,00,00,00,1F,0F, 
; 0040 00,00,00,00,00,00,00,00, 00,00,00,00,00,00,00,00, 
; 0050 00,E5,01,00,00,00,20,00 
;}
;{ 0000 - 6B,00 = integer     recordSize                                              
;                                                               
;  This is the size of a user record in this table.             
;                                                               
;  For primary index files, each "record" is actually the       
;  field Or fields in the index, plus three integers which      
;  are Not referenced in the header.                            
;                                                               
;  Secondary index files also have additional fields, but       
;} these are listed in the header.                              
;{ 0002 - 00,08 = integer     headerSize (always $0800)                               
;                                                               
;  You can change headerSize, And move the Data blocks          
;  accordingly, To create larger Or smaller table headers.      
;  Borland's TUTILITY program would flag an error, but          
;  Paradox, the Borland Database Engine And the Paradox         
;} Engine will all still work With these tables.                
;{ 0004 - 00 = byte        fileType                                                
;                                                               
;     0 = this is an indexed .DB Data file                      
;     1 = this is a primary index .PX file                      
;     2 = this is a non-indexed .DB Data file                   
;     3 = this is a non-incrementing secondary index .Xnn file  
;     4 = this is a secondary index .Ynn file (inc Or non-inc)  
;     5 = this is an incrementing secondary index .Xnn file     
;     6 = this is a non-incrementing secondary index .XGn file  
;     7 = this is a secondary index .YGn file (inc Or non inc)  
;}    8 = this is an incrementing secondary index .XGn file     
;{ 0005 - 02 = byte        maxTableSize                                            
;                                                               
;  This is the "maximum table size" determined when this        
;  table was created.  It really indicates the size of each     
;  block of records in the Data section of the table.           
;                                                               
;     1 =   64M    (block size = $0400 bytes)                   
;     2 =  128M    (block size = $0800 bytes)                   
;     3 =  192M    (block size = $0C00 bytes)                   
;}    4 =  256M    (block size = $1000 bytes)                   
;{ 0006 - 21,00,00,00 = longint     numRecords                                              
;} This is the number of records in this file.                  
;{ 000A - 03,00 = word        nextBlock                                               
;                                                               
;  I'm not certain what this really is, but it seems to be      
;  the same As fileBlocks unless there is an empty block in     
;} the table.                                                   
;{ 000C - 03,00 = word        fileBlocks                                              
;                                                               
;  This is the number of Data blocks in the file.               
;} (Each "block" is a cluster of records.)                      
;{ 000E - 01,00 = word        firstBlock                                              
;                                                               
;} Always 1 unless the table is empty.                          
;{ 0010 - 02,00 = word        lastBlock                                               
;       
etc etc

Anonyme · Message par **Anonyme** » jeu. 21/sept./2006 15:04

cpl Bator, pourrais tu créer un nouveau post sur "parsing, langage interprété"

c'est un sujet qui m'intéresse, et ça serait plus facile à suivre

patrick

http://purebasic.forum-gratuit.com/viewtopic.php?t=5641

@++

SPH · Message par **SPH** » jeu. 21/sept./2006 15:53

andrebernard a écrit :j'ai 2 neurones et non pas trois(VIRGULE) et...
que tu sois le + gd prirate du monde(VIRGULE) ne prive pas de la politesse(VIRGULE) ni du bon français.
Apparement vu ton niveau(VIRGULE) je pense que tu devais secher les cours de français pour te consacrer à l'informatique.
En tout cas bravo pour ce code (VIRGULE) c'est de balle.
Tu es donc à demi pardonné.
Un question(VIRGULE) je pense que d'ailleur tu devais l'attendre(VIRGULE) pourrais tu creer le meme code pour faire machine arriere ????

Je suis desolé de constater que ce n'est pas 3, ni 2, mais peut etre 1 seul neurone qui t'oblige a penser que quand je parlais de virer tes virgules, tu croyais que je parlais des virgules de tes phrases. Hors, pour t'aider a gagner 1/3 de place, je te disais de virer ces foutues virgules du code que te propose brossden...
La, si tu ne captes toujours pas, je renonce...

Anonyme · Message par **Anonyme** » jeu. 21/sept./2006 17:00

tu sais SPH, il y a des manières de s'adresser au gens, c'est pas parce que l'on est tous derrière et protégé par un écran qu'il faut manqué de respect aux gens.

andrebernard · Message par **andrebernard** » ven. 22/sept./2006 6:59

Pour SPH

Ayai, j'ai compris .......il faut dire que je les avais viré du debut les virgules, tu as raison ça marche aussi.

Je voyais vraiment pas pourquoi tu t'en prenait à mon écriture.

Tu sais la langue française a ses subtilités et ce n'est pas comme la prog, raccourcir les phrases n'ameliore pas le "CODE" de la comprehension.

Ta phrase etait trop courte et a double sens en remplaçant "ces virgules" par "les virgules du code" il n'y aurait pas eu de quiproquo.

Notre société est de plus en plus agressive, il n'est pas rare de te faire insulter alors que tu es dans tes droits.
De ce fait on est toujours sur la défensive, peut etre ai-je reagi un peu vite, comment pouvais-je imaginer que cette phrase quelque peu agressive etait une main tendue.

Je pense que je n'ai pas été le seul a comprendre comme ça, alors de la à dire que tous ceux qui ont mal compris ta phrase mal exprimée sont des bourrins ......

Merci a cpl.bator, grace à toi je vois que je ne suis pas le seul à penser que la politesse n'est pas une futilité.

Bref, c'est pas grave, tu remonte dans mon estime, (tu n'etait pas beaucoup descendu, il faut dire) tu m'avais épaté par ton code, alors si en plus tu est un "pirate gentleman" ça ne gache rien.

Pour les questions que je t'avais posés peut tu me venir en aide ????

Je les reformule:

1/ Aurais tu un code qui fait l'inverse donc de codé à binaire.

2/ Au passage pourrait tu montrer ou est le passage à l'hexa, si on ne veut pas coder et juste obtenir un hexa txt comme avait proposer le code de brossden du depart.

3/ Saurais tu qui peut m'aider en reseau pour ce post

http://purebasic.forum-gratuit.com/viewtopic.php?t=5634

Encore mille merci à tous
Vive le FORUM

brossden · Message par **brossden** » ven. 22/sept./2006 8:41

SHP, je n'ai pas bien compris l'utilité de ton programme ... Quand je l'utilise j'obtiens une suite de caractères Ascii mais je ne reconnais pas les valeurs hexa attendu par du cahier des charges. En ce qui concerne les virgules elles ne sont là que pour respecter ce même cahier des charges.
Pour conclure je serai assez impressionné que tu m'expliques, excusez moi que tu nous expliques pourquoi un fichier de 104Ko se retrouve converti en fichier de 278 Ko ce qui reviendrait à dire que chaque octet est converti sur plus de deux caractères mais moins de trois ?????? (2.65 exactement si je prends le nombre exact des octets de chacun des deux fichiers).

Explique je suis tout ouie ![/u]

SPH · Message par **SPH** » ven. 22/sept./2006 9:53

brossden a écrit :SPH, je n'ai pas bien compris l'utilité de ton programme ... Quand je l'utilise j'obtiens une suite de caractères Ascii mais je ne reconnais pas les valeurs hexa attendu par du cahier des charges. En ce qui concerne les virgules elles ne sont là que pour respecter ce même cahier des charges.
Pour conclure je serai assez impressionné que tu m'expliques, excusez moi que tu nous expliques pourquoi un fichier de 104Ko se retrouve converti en fichier de 278 Ko ce qui reviendrait à dire que chaque octet est converti sur plus de deux caractères mais moins de trois ?????? (2.65 exactement si je prends le nombre exact des octets de chacun des deux fichiers).

Explique je suis tout ouie ![/u]

Hmmm, je ne savais pas qu'il y avait un cahier des charges. L'idée que j'avais retenu de tous ces codes etait de coder sur 6 bits un quelconque fichier. 6 bits; donc 64 caracteres differents. Et en prenant la liste ASCII, j'ai fait un +33 pour commencer mes 64 caracteres possible a partir de '!'.

Je pensais que le principal etait de savoir relire des quelconques données...

En tout cas, il y a une gigantesque perte de place; ce qui gonffle le fichier transformé... De plus, c'est servir sur un plateau doré le fichier que l'on veux soit disant protéger du regard exterieur......

brossden · Message par **brossden** » ven. 22/sept./2006 14:47

J'entend par cahier des charges, la demande de la personne qui a écrit le post initial, le minimum c'est de répondre à sa question non ?

Désolé mais il n'a jamais été question de convertir le fichier bin en fichier 6 bits.
Une explication t'es peut être necessaire.

Le but du logiciel est d'ouvrir un fichier quelconque, de lire le premier octet en temps que valeur décimale, de le convertir en valeur hexa, c'est à dire 00 en hexa pour 0 en dec, 0A en hexa pour 10 en dec pour finir FF en hexa pour 255. Puis de lire le second octet et executer la même logique, et ainsi de suite jusqu'à la fin de ce fichier. Ala fin ecrire le fichier converti sur le disque dur.
Le fichier converti ne comporte que des mots de deux caractères pouvant être de 0 à 9 ou de A à F séparés par une virgule qui, il est vrai en dehors de la facilité de lecture n'apporte rien au niveau informatique si ce n'est une taille de 33% supérieure.

La demande etait de traduire un fichier binaire en hexa et si possible de faire le contraire.
Ce que je vois c'est que soit tu ne sais pas lire, soit tu pisses de la ligne pour le plaisir et le résultat importe peu !

L'assembleur c'est bien quoique incompréhensible pas la majorité des participant ici. Je te rappelle que tu es dans la partie du forum réservée aux débutants.

SPH · Message par **SPH** » ven. 22/sept./2006 16:48

Bonne chance a vous deux pour ce projet

Anonyme · Message par **Anonyme** » ven. 22/sept./2006 16:48

Donc si j'ai bien compris, le but est de convertir n'importe quel fichier en Hexa de cette forme:

00,FF,0A,25,etc...

puis de le remettre a ca forme originale ? c'est ca ?
Si c'est ca, j'ai un code que je viens de faire

andrebernard · Message par **andrebernard** » ven. 22/sept./2006 18:53

Bonjour

Oui Cpl.bator c'est encore moi.

J'ai ouvert cette rubrique car j'avais trouvé un super code de patrick88 pour transformé un binaire en hexa.

Et j'ai pensé m'en servir pour faire un super codage indecodable que DOBRO m'a tout de suite décodé.
Donc comme le dit BrossDen on est bien chez les debutant, comme tu peut le voir.

Par contre, j'ai rien compris, ni au code, ni a la reaction de SPH, mais il faut bien avouer que informatiquement parlant, je n'ai pas pu controler si son code marche puisqu'il n'a pas proposé la methode de retour, mais on doit bien avouer que son code c'est de la balle.....

N'y connaissant rien en assembleur (evidement ), je ne savais pas que la vitesse pouvais etre si differente entre le pure et l'assembleur.

Car j'avais beaucoup de gros fichiers à crypter, donc il est vrai que la rapidité est devenu un chalenge.

Sur ce, est arrivé un quiproquo ridicule, pour une phrase trop courte de francais, la sauce a monté, et on peut reconnaitre que si SPH a l'air d'etre un crack en prog, il manque un peu de "vaseline" dans ses post.

On peut dire tout a fait la meme chose a quelqu'un, sans le critiquer.
Moi j'etais super content du code que brossden a gentiment proposé.

Maintenant, peut on optimiser ce dernier pour approcher l'assembleur ????? je ne pense pas ....

Enfin bref, je pense que SPH est un peu véxé, c'est le retour de manivelle de Brossden.
C'est dommage on fait partie de la meme communauté et meme si je viens de naitre, on a la meme passion et on est pas si nombreux.
Si on se sert pas les coudes ........

Bon, on aura peut etre jamais ce fameux retour en arriere, ou bien le meme que le super code de brossden (aller/retour) mais en assembleur.

Pour ma part, je suis tres fier de vous tous, j'aimerais vous arriver a la cheville, et peut etre qu'a ce moment la, moi aussi j'aurais quelques acces de pretention comme certain de ces membres.
Apres tout quand on est bon on y a un peu droit non ???

Ce qui est insupportable, c'est la pretention des incapables....

Vala, vala.

C'etait donc un sujet animé.....

Merci sincerement a vous tous (meme SPH)
Vous etes genial, que deviendrais-je sans vous.

Anonyme · Message par **Anonyme** » ven. 22/sept./2006 19:11

Bon, je met du code.

Pour convertir n'importe quel fichier en hexa :

Code : Tout sélectionner

File$ = OpenFileRequester("OPEN ANY FILE","","*.*",0)

OpenFile(0,File$)

While Eof(0)=0 : Fichier$=Fichier$+   Hex(ReadByte(0))+","      : Wend

CloseFile(0)

File$ = SaveFileRequester("SAVE HEXA FILE","","",0)


OpenFile(0,File$)
WriteData(0,@Fichier$,Len(Fichier$))
CloseFile(0)

Voila pour l'inverse :

Code : Tout sélectionner

Procedure.l Hex2Dec(h$)
  h$=UCase(h$)
  For r=1 To Len(h$)
    d<<4 : a$=Mid(h$,r,1)
    If Asc(a$)>60
      d+Asc(a$)-55
    Else
      d+Asc(a$)-48
    EndIf
  Next
  ProcedureReturn d
EndProcedure


File$   = OpenFileRequester("OPEN HEXA FILE","","*.*",0)
Output$ = SaveFileRequester("SELECT OUTPUT","","",0)


OpenFile(0,File$)
OpenFile(1,Output$)

While Eof(0)=0 : Fichier$=Fichier$+ReadString(0) : Wend

  For i = 1 To  CountString(Fichier$,",")
    Output$ = Output$ + Str(Hex2Dec(StringField(Fichier$,i,",")))
    WriteByte(1,Hex2Dec(StringField(Fichier$,i,",")))
  Next i
CloseFile(0)
CloseFile(1)

Tu peut avec ca, mettre un exe en hexa et vice versa, par contre c'est long en lecture / ecriture , mais sa peut s'arranger en changeant la taille du buffer d'ecriture et de lecture je crois.

Tiens, decode ca :

43,6F,75,63,6F,75,21,

(utilise le prog plus haut)

@++

[/quote]