/* Chrysalide - Outil d'analyse de fichiers binaires * leb128.c - support des valeurs encodées au format LEB128. * * Copyright (C) 2010-2018 Cyrille Bagard * * This file is part of Chrysalide. * * Chrysalide is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 3 of the License, or * (at your option) any later version. * * Chrysalide is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Chrysalide. If not, see . */ #include "leb128.h" #include "io.h" /****************************************************************************** * * * Paramètres : target = lieu d'enregistrement de la lecture. [OUT] * * data = flux de données à analyser. * * pos = position courante dans ce flux. [OUT] * * len = taille totale des données à analyser. * * * * Description : Lit un nombre non signé encodé au format LEB128. * * * * Retour : Bilan de l'opération : true en cas de succès, false sinon. * * * * Remarques : - * * * ******************************************************************************/ bool read_uleb128(uleb128_t *target, const bin_t *data, phys_t *pos, phys_t len) { int shift; /* Décalage à appliquer */ phys_t i; /* Boucle de parcours */ shift = 0; *target = 0; for (i = 0; i < 8; i++) { /* On évite les débordements... */ if (*pos >= len) return false; *target |= (data[*pos] & 0x7f) << shift; shift += 7; (*pos)++; if ((data[*pos - 1] & 0x80) == 0x00) break; } return (i < 8); } /****************************************************************************** * * * Paramètres : target = lieu d'enregistrement de la lecture. [OUT] * * data = flux de données à analyser. * * pos = position courante dans ce flux. [OUT] * * len = taille totale des données à analyser. * * * * Description : Lit un nombre signé encodé au format LEB128. * * * * Retour : Bilan de l'opération : true en cas de succès, false sinon. * * * * Remarques : - * * * ******************************************************************************/ bool read_leb128(leb128_t *target, const bin_t *data, phys_t *pos, phys_t len) { int shift; /* Décalage à appliquer */ phys_t i; /* Boucle de parcours */ shift = 0; *target = 0; for (i = 0; i < 8; i++) { /* On évite les débordements... */ if (*pos >= len) return false; *target |= (data[*pos] & 0x7f) << shift; shift += 7; if ((data[(*pos)++] & 0x80) == 0x00) break; } if (shift < (8 * sizeof(int64_t)) && (data[*pos - 1] & 0x40) == 0x40) *target |= - (1 << shift); return (i < 8); } /****************************************************************************** * * * Paramètres : value = valeur à constituer. [OUT] * * fd = flux ouvert en lecture à consulter. * * * * Description : Restaure un nombre non signé encodé au format LEB128. * * * * Retour : Bilan de l'opération : true en cas de succès, false sinon. * * * * Remarques : - * * * ******************************************************************************/ bool load_uleb128(uleb128_t *value, int fd) { bool result; /* Bilan à retourner */ unsigned int shift; /* Décalage à appliquer */ uint8_t byte; /* Octet à transposer */ result = true; *value = 0; shift = 0; while (true) { /* Encodage sur trop d'octets ? */ if (shift > (7 * sizeof(uleb128_t))) { result = false; break; } result = safe_read(fd, &byte, sizeof(uint8_t)); if (!result) break; *value |= ((byte & 0x7f) << shift); if ((byte & 0x80) == 0x00) break; shift += 7; } return result; } /****************************************************************************** * * * Paramètres : value = valeur à consigner. * * fd = flux ouvert en écriture. * * * * Description : Sauvegarde un nombre non signé encodé au format LEB128. * * * * Retour : Bilan de l'opération : true en cas de succès, false sinon. * * * * Remarques : - * * * ******************************************************************************/ bool store_uleb128(const uleb128_t *value, int fd) { bool result; /* Bilan à retourner */ uleb128_t tmp; /* Valeur modifiable */ uint8_t byte; /* Octet à transposer */ tmp = *value; do { byte = (tmp & 0x7f); tmp >>= 7; if (tmp != 0) byte |= 0x80; result = safe_write(fd, &byte, sizeof(uint8_t)); } while (result && tmp != 0); return result; } /****************************************************************************** * * * Paramètres : value = valeur à consigner. * * pbuf = tampon de données à constituer. [OUT] * * * * Description : Encode un nombre non signé encodé au format LEB128. * * * * Retour : Bilan de l'opération : true en cas de succès, false sinon. * * * * Remarques : - * * * ******************************************************************************/ bool pack_uleb128(const uleb128_t *value, packed_buffer_t *pbuf) { bool result; /* Bilan à retourner */ uleb128_t tmp; /* Valeur modifiable */ uint8_t byte; /* Octet à transposer */ tmp = *value; do { byte = (tmp & 0x7f); tmp >>= 7; if (tmp != 0) byte |= 0x80; result = extend_packed_buffer(pbuf, &byte, sizeof(uint8_t), false); } while (result && tmp != 0); return result; } /****************************************************************************** * * * Paramètres : value = valeur à consigner. * * pbuf = tampon de données à constituer. [OUT] * * * * Description : Encode un nombre signé encodé au format LEB128. * * * * Retour : Bilan de l'opération : true en cas de succès, false sinon. * * * * Remarques : - * * * ******************************************************************************/ bool pack_leb128(const leb128_t *value, packed_buffer_t *pbuf) { bool result; /* Bilan à retourner */ uleb128_t tmp; /* Valeur modifiable */ bool more; /* Poursuite des traitements */ bool negative; /* Nature de la valeur */ uint8_t byte; /* Octet à transposer */ tmp = *value; more = true; negative = (*value < 0); while (more) { byte = (tmp & 0x7f); tmp >>= 7; /** * Propagation forcée du bit de signe pour les implémentations de * décalage basées sur une opération logique et non arithmétique. */ if (negative) tmp |= (~0llu << (LEB128_BITS_COUNT - 7)); /** * Le bit de signe n'est pas le bit de poids fort ici : * On travaille sur 7 bits, donc le masque est 0x40 ! */ if ((tmp == 0 && (byte & 0x40) == 0x00) || (tmp == -1 && (byte & 0x40) == 0x40)) more = false; else byte |= 0x80; result = extend_packed_buffer(pbuf, &byte, sizeof(uint8_t), false); } return result; } /****************************************************************************** * * * Paramètres : value = valeur à constituer. [OUT] * * pbuf = tampon de données à consulter. * * * * Description : Décode un nombre non signé encodé au format LEB128. * * * * Retour : Bilan de l'opération : true en cas de succès, false sinon. * * * * Remarques : - * * * ******************************************************************************/ bool unpack_uleb128(uleb128_t *value, packed_buffer_t *pbuf) { bool result; /* Bilan à retourner */ unsigned int shift; /* Décalage à appliquer */ uint8_t byte; /* Octet à transposer */ result = true; *value = 0; shift = 0; while (true) { /* Encodage sur trop d'octets ? */ if (shift > (7 * sizeof(uleb128_t))) { result = false; break; } result = extract_packed_buffer(pbuf, &byte, sizeof(uint8_t), false); if (!result) break; *value |= ((byte & 0x7f) << shift); if ((byte & 0x80) == 0x00) break; shift += 7; } return result; } /****************************************************************************** * * * Paramètres : value = valeur à constituer. [OUT] * * pbuf = tampon de données à consulter. * * * * Description : Décode un nombre signé encodé au format LEB128. * * * * Retour : Bilan de l'opération : true en cas de succès, false sinon. * * * * Remarques : - * * * ******************************************************************************/ bool unpack_leb128(leb128_t *value, packed_buffer_t *pbuf) { bool result; /* Bilan à retourner */ unsigned int shift; /* Décalage à appliquer */ uint8_t byte; /* Octet à transposer */ result = true; *value = 0; shift = 0; do { /* Encodage sur trop d'octets ? */ if (shift > (7 * sizeof(leb128_t))) { result = false; break; } result = extract_packed_buffer(pbuf, &byte, sizeof(uint8_t), false); if (!result) break; *value |= ((byte & 0x7f) << shift); shift += 7; } while ((byte & 0x80) == 0x80); /** * Le bit de signe n'est pas le bit de poids fort ici : * On travaille sur 7 bits, donc le masque est 0x40 ! */ if (shift < LEB128_BITS_COUNT && (byte & 0x40) == 0x40) *value |= (~0llu << shift); return result; }