Décortiquer un Quad en octets

[SPH]

Salut,

je cherche a trouver les 8 octets constituant un quad mais la, je sèche...

debug de code (lol) :

Code : Tout sélectionner

q.q=10011254555
Dim octets.b(8)
; je ne sais pas continuer

[Zorro]

bin$ te permet de transformer ton quad en chaine$ binaire ...

a partir de là , tu utilises les fonction String pour recuperer tes segments
ensuite tu reconvertis en ce que tu veux

[SPH]

Bonne idée, j'essaye

[Zorro]

code:

Code : Tout sélectionner

;***********************************************
;Titre  :*separation_du_binaire
;Auteur  : Dobro
;Date  :26/07/2019
;Heure  :12:47:49
;Version Purebasic :  PureBasic 5.70 LTS (Windows - x86)
;Version de l'editeur :EPB PHOENIX V2.68
; Libairies necessaire : Aucune 
;***********************************************


q.q=65536*65536*365214+15422141

; en Binaire ça donne :
binaire.s=rset(bin(q.q,#PB_Quad   ),64,"0")
debug binaire.s
debug "longueur ="+ str(len(binaire.s))
; on va separer en octet : 

Dim octets.b(8)
calldebugger
For i=1 to 64   step 8
		octet.s = mid(binaire.s,i,8)  ; on est obligé d'utiliser Rset() pour forcer a garder les "00" en debut de segment eventuel on format , du coup l'octet 00000001  donnera bien "00000001" et pas "1"
		octets.b(i/8)=val("%"+octet.s) ; chaque segment est transformé en octets
		resultat.s=resultat.s+octet.s+"-"
Next i

debug "Les segments sont:" +resultat.s

debug "chaque segment transformés en octet decimal donne les valeurs "

for i=7  to 0 step -1
		segment.s=StringField(resultat.s,i+1,"-")
		debug "octet "+str(i+1)+"="+ segment.s +" ce qui donne :"+str(octets.b(i))+" en decimal "
Next i
;Epb

[Ar-S]

On a pas arrêté dans parlé dans nos histoires recentes de stegano.

Tiré de l'exemble "Bin" de la doc (encore):

Code : Tout sélectionner

  Debug Bin(32) ; Affichera "100000"
  Debug Bin(1024*1024*1024*1024) ; Affichera "10000000000000000000000000000000000000000"

Note: Si des zéros supplémentaires sont nécessaires pour formater correctement le texte, il est possible d'utiliser RSet(). 

  Debug RSet(Bin(32), 16, "0") ; Affichera "0000000000100000"

[G-Rom]

Code : Tout sélectionner

quad.q=10011254555
*pointer = @quad


Debug PeekB(*pointer)
Debug PeekB(*pointer + 1)
Debug PeekB(*pointer + 2)
Debug PeekB(*pointer + 3)
Debug PeekB(*pointer + 4)
Debug PeekB(*pointer + 5)
Debug PeekB(*pointer + 6)
Debug PeekB(*pointer + 7)


Dim Bytes.b(8)
CopyMemory(@quad,@Bytes(0),8)

Debug ""
Debug Bytes(0)
Debug Bytes(1)
Debug Bytes(2)
Debug Bytes(3)
Debug Bytes(4)
Debug Bytes(5)
Debug Bytes(6)
Debug Bytes(7)

[Zorro]

va pas nous le noyer avec tes pointeurs toi

[SPH]

Plus simple :

Code : Tout sélectionner

q.q=65536*65536*365214+15422141
Dim tableau.b(8)

quad$=(RSet(Bin(q),64,"0"))
For i=1 To 8
  tableau(i)=Val("%"+Mid(quad$,i*8-7,8))
  Debug tableau(i)
Next

[G-Rom]

va pas nous le noyer avec tes pointeurs toi

Heu, j'ai mis deux solutions, la base quoi...

Plus simple :

Code : Tout sélectionner

q.q=65536*65536*365214+15422141
Dim tableau.b(8)

quad$=(RSet(Bin(q),64,"0"))
For i=1 To 8
  tableau(i)=Val("%"+Mid(quad$,i*8-7,8))
  Debug tableau(i)
Next

plus simple que ? :

tableau(i)=Val("%"+Mid(quad$,i*8-7,8))

CopyMemory(@quad,@Bytes(0),8)

Perso, passer par des strings & fonctions intermédiaire , c'est cradingue , mais c'est que mon avis
un simple copie de mémoire suffit à caster ton quad en tableau de bytes.

[SPH]

CopyMemory(@quad,@Bytes(0),8)

Perso, passer par des strings & fonctions intermédiaire , c'est cradingue , mais c'est que mon avis
un simple copie de mémoire suffit à caster ton quad en tableau de bytes.

J'aimerais avoir ton talent mais jusqu'a present, je ne sais pas du tout me servir des pointeurs...

[Zorro]

j'ai corrigé mon code, qui etait completement foireux (je code plus ça commence a se voir )

@SPH c'est quand meme le code basé sur les pointeurs qui reste le plus "simple"

tu peux voir les pointeurs comme des variables , du point de vue utilisation c'est kif kif !!

simplement un pointeur est en fait l"adresse d'une variables

mais niveau utilisateur , que tu fasse a=10 ou *a=10 c'est pareil ..

mon code n'avais pas pour but d'etre optimisé, mais au contraire de bien detailler expres

[Zorro]

@SPH

voila comment marche un pointeur :

Code : Tout sélectionner

Calldebugger
a=10
*b=100

debug a

debug *b

; sinon tu peux aussi utiliser un pointeur pour stocker une adresse

*b=@a  ; je stock l'adresse de a dans le pointeur b 


debug "voici l'adresse de la variable  a :"+str(*b)

; je peux acceder au contenu de l'adresse de 'a' stocké dans le pointeur en faisant :

debug "voici le contenu de l'adresse du pointeur *b  => "+str(peekL(*b)) 
debug " ce qui renvoi bien la valeur mise dans a !!"
debug "rappel a="+str(a)

[G-Rom]

CopyMemory(@quad,@Bytes(0),8)

Perso, passer par des strings & fonctions intermédiaire , c'est cradingue , mais c'est que mon avis
un simple copie de mémoire suffit à caster ton quad en tableau de bytes.

J'aimerais avoir ton talent mais jusqu'a present, je ne sais pas du tout me servir des pointeurs...

C'est pas une question de "talent", tu poses une question, je te donne une réponse simple , si tu ne comprend pas la commande , tu appuis sur F1.

[Ollivier]

Ça marche pas ça?

Code : Tout sélectionner

Structure Meli
   StructureUnion
      A.A[8]
      Q.Q
   EndStructureUnion
EndStructure

Define X.Meli     ; plus souple: *x.Meli = AllocateStructure(Meli)

X\Q = $0100010001000100 ; le quad dans sa splendeur

For I = 0 To 7 ; chaque octet de 0 à 7
   Debug X\A[I]
Next

[crisot]

Il suffit de décaler/masquer pour récupérer les 8 bits que l'on souhaite, ça ne prend que quelques cycles et ne fait aucune opération mémoire (autre que le stockage dans le tableau évidement).

Code : Tout sélectionner

quad.q=10011254555

Dim oct.a(7)

For i=0 To 7
  oct(i)=(quad >> (i<<3)) & $ff
  debug oct(i)
Next

Les deux méthodes de g-rom sont très bien aussi.