bash: écrire représentation binaire de l'entier de fichier

J'ai un fichier avec des données binaires et j'ai besoin de remplacer quelques octets dans une certaine position. Je suis venu avec la suite directe de bash à l'offset et de me montrer qu'il a trouvé l'endroit que je veux:

dd bs=1 if=file iseek=24 conv=block cbs=2 | hexdump

Maintenant, utiliser "fichier" en tant que sortie:

echo anInteger | dd bs=1 of=hextest.txt oseek=24 conv=block cbs=2

Cela semble fonctionner très bien, je peux passer en revue les modifications apportées à un éditeur hexadécimal. Problème est, "anInteger" sera écrit que la représentation ASCII de l'entier (ce qui est logique) mais j'ai besoin d'écrire la représentation binaire.

Je veux utiliser bash pour cela et le script doit s'exécuter sur autant d'ordinateurs que possible (je ne sais pas si le système cible aura python ou que ce soit installé).

Comment dois-je dire à la commande pour convertir l'entrée binaire (éventuellement à partir d'un hex)?

Vous souhaiterez peut-être utiliser xdelta pour cela - c'est assez commun qu'il peut être "universel" pour vous.
Pas sûr de ce que tu veux dire par "xdelta". Il n'y a pas de commande sur ma coquille...
xxd -r est conçu à cet effet
Oui. Voir stackoverflow.com/a/8199163/219324.

OriginalL'auteur Max Leske | 2010-04-30

10

Vous pouvez utiliser de l'écho à émettre spécifiques des octets à l'aide hexadécimal ou octal. Par exemple:
```
echo -n -e \\x30 
```
sera d'impression ascii 0 (0x30)

(-n retirer de fuite saut de ligne)

Cela semble fonctionner. Je vais essayer de le comprendre et de poster mes résultats.
echo est inversement proportionnelle à la non-compatibles-pour l'exemple ci-dessus, certaines implémentations, il suffit d'imprimer -e \x30, ce qui n'est pas ce que vous voulez.
Bizarre, n'aurait pas pensé. Heureusement, le script est déjà en cours d'exécution sans problèmes.
pourquoi, oh pourquoi, n'est-ce pas là une façon simple de le faire avec des nombres décimaux? Je suis à la conversion à l'hex de première echo -ne \\x$(printf '%x' 65) sûrement, il y a une meilleure façon...?
Je suggère l'utilisation de printf au lieu de echo -n -e: printf \\x30

OriginalL'auteur cs80
14

printf est plus portable que echo. Cette fonction prend un nombre entier décimal et les sorties d'un octet avec la valeur:
```
echobyte () {
    if (( $1 >= 0 && $1 <= 255 ))
    then
        printf "\\x$(printf "%x" $1)"
    else
        printf "Invalid value\n" >&2
        return 1
    fi
}

$ echobyte 97
a
$ for i in {0..15}; do echobyte $i; done | hd
00000000  00 01 02 03 04 05 06 07  08 09 0a 0b 0c 0d 0e 0f  |................|
00000010
```
Sweet! Mais comme vous pouvez le voir dans ma réponse ci-dessous, ce serait sans doute exagéré. Encore, bon à savoir.
Si vous connaissez le nombre entier(s) à l'avance, vous pouvez simplifier un peu les choses, par exemple printf "\x30"
C'est vrai, voir la OP réponse de. Cependant, le but de cette fonction est la polyvalence.

OriginalL'auteur Dennis Williamson
6

xxd est la meilleure façon de faire. xxd -r infile outfile prendra ascii hex-valeur en infile de patch outfile, et vous pouvez spécifier la position spécifique dans infile: 1FE:55AA

OriginalL'auteur juzejian
5

Travaillé comme un régal. J'ai utilisé le code suivant pour remplacer 4 octets octet 24 en little endian avec deux entiers (1032 et 1920). Le code de ne pas tronquer le fichier.
```
echo -e \\x08\\x04\\x80\\x07 | dd of=<file> obs=1 oseek=24 conv=block,notrunc cbs=4
```
Merci encore.

OriginalL'auteur Max Leske
0

Si vous êtes prêt à appuyer sur la colombie-britannique (ce qui est assez fréquent)
```
echo -e "ibase=16\n obase=2 \n A1" | bc -q
```
pourrait aider.

Je l'ai essayé. Votre code sera de retour un binaire qui sera écrit dans le fichier en tant que représentation ASCII de ce binaire. Belle pensée bien, merci.

OriginalL'auteur nc3b
0

Vous pourriez mettre l'entrée souhaitée dans un fichier et utiliser le "si=" option de dd pour insérer exactement l'entrée que vous désirez.

J'ai pensé à ça, mais je ne veux pas utiliser un fichier supplémentaire pour 4 octets.

OriginalL'auteur WhirlWind

J'ai une fonction pour ce faire:

# number representation from 0 to 255 (one char long)
function chr() { printf "\$(printf '%03o' "$1")" ; return 0 ; }
# from 0 to 65535 (two char long)
function word_litleendian() { chr $(($1 / 256)) ; chr $(($1 % 256)) ; return 0 ; }
function word_bigendian() { chr $(($1 % 256)) ; chr $(($1 / 256)) ; return 0 ; }
# from 0 to 4294967295 (four char long)
function dword_litleendian() { word_lilteendian $(($1 / 65536)) ; word_litleendian $(($1 % 65536)) ; return 0 ; }
function dword_bigendian() { word_bigendian $(($1 / 65536)) ; word_bigendian $(($1 % 65536)) ; return 0 ; }

Vous pouvez utiliser de la tuyauterie ou de redirection pour récupérer le résultat.

OriginalL'auteur Adam

Avec bash, "printf" a "-v" option, et tout de la coquille a l'aide d'opérateurs logiques.

Donc, ici, est plus simple formulaire en bash :

int2bin() {
  local i=$1
  local f
  printf -v f '\\x%02x\\x%02x\\x%02x\\x%02x' $((i&255)) $((i >> 8 & 255)) $((i >> 16 & 255)) $((i >> 24 & 255))
  printf "$f"
}

OriginalL'auteur Vouze

Dans mon cas, j'avais besoin d'aller d'un point décimal argument de la réelle non signé de 16 bits big endian valeur. Ce n'est probablement pas le moyen le plus efficace, mais il fonctionne:

# $1 is whatever number (0 to 65535) the caller specifies
DECVAL=$1
HEXSTR=`printf "%04x" "$DECVAL"`
BYTEONE=`echo -n "$HEXSTR" | cut -c 1-2`
BYTETWO=`echo -n "$HEXSTR" | cut -c 3-4`
echo -ne "\x$BYTEONE\x$BYTETWO" | dd of="$FILENAME" bs=1 seek=$((0xdeadbeef)) conv=notrunc

OriginalL'auteur Ray Foulk

Vous devez vous connecter pour publier un commentaire.