Leer un dispositivo de bloque e ioctl

N = capacidad_bytes / S
inicio_bytes = LBA × S
longitud_bytes = k × S

Antes de formar los productos:
    capacidad_bytes debe ser múltiplo de S en este contrato
    LBA < N
    1 ≤ k ≤ N − LBA

Último LBA de una partición: inicio + cantidad − 1
Cantidad desde límites inclusivos: último − primero + 1

# Primeros 512 bytes: firma y registros MBR.
dd if=mbr512.img bs=512 count=1 iflag=fullblock status=none | od -Ax -tx1
# LBA 1 con sector logico de 512 bytes.
dd if=gpt512.img bs=512 skip=1 count=1 iflag=fullblock status=none | od -Ax -tx1
# LBA 1 con sector logico de 4096 bytes.
dd if=gpt4096.img bs=4096 skip=1 count=1 iflag=fullblock status=none | od -Ax -tx1

#define _POSIX_C_SOURCE 200809L
#define _FILE_OFFSET_BITS 64
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <linux/fs.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdint.h>
#include <inttypes.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>

_Static_assert(sizeof(off_t) >= 8, "Se requieren offsets de al menos 64 bits");
_Static_assert(sizeof(uint64_t) == 8, "BLKGETSIZE64 requiere ocho bytes");
static int decimal(const char *s, uint64_t *valor)
{
    uint64_t n = 0;
    if (!*s) return -1;
    for (; *s; ++s) {
        if (*s < '0' || *s > '9') return -1;
        unsigned d = (unsigned)(*s - '0');
        if (n > (UINT64_MAX - d) / 10) return -1;
        n = n * 10 + d;
    }
    *valor = n; return 0;
}
int main(int argc, char **argv)
{
    int imagen = argc > 1 && !strcmp(argv[1], "imagen");
    int bloque = argc > 1 && !strcmp(argv[1], "bloque");
    uint64_t lba = 0, declarado = 0;
    if ((!imagen && !bloque) || (imagen && argc != 5) || (bloque && argc != 4) ||
        (imagen && (decimal(argv[3], &declarado) ||
         (declarado != 512 && declarado != 4096))) ||
        decimal(argv[imagen ? 4 : 3], &lba)) {
        fprintf(stderr, "Uso: %s imagen ruta 512|4096 LBA | bloque ruta LBA\n", argv[0]);
        return 2;
    }
    int fd = open(argv[2], O_RDONLY | O_CLOEXEC | O_NOFOLLOW | O_NONBLOCK);
    if (fd == -1) { perror("open"); return 1; }
    struct stat st;
    if (fstat(fd, &st)) { perror("fstat"); close(fd); return 1; }
    uint64_t capacidad;
    int logico = (int)declarado, fisico = 0;
    if (imagen) {
        if (!S_ISREG(st.st_mode) || st.st_size < 0) {
            fprintf(stderr, "Se requiere imagen regular\n"); close(fd); return 1;
        }
        capacidad = (uint64_t)st.st_size;
    } else {
        if (!S_ISBLK(st.st_mode)) {
            fprintf(stderr, "Se requiere dispositivo de bloque\n"); close(fd); return 1;
        }
        if (ioctl(fd, BLKSSZGET, &logico) == -1 ||
            ioctl(fd, BLKPBSZGET, &fisico) == -1 ||
            ioctl(fd, BLKGETSIZE64, &capacidad) == -1) {
            perror("ioctl de consulta"); close(fd); return 1;
        }
        if (fisico < logico || logico <= 0 || fisico % logico != 0) {
            fprintf(stderr, "Geometria fisica incoherente\n"); close(fd); return 1;
        }
    }
    if ((logico != 512 && logico != 4096) || capacidad == 0 ||
        capacidad % (uint64_t)logico != 0 || lba >= capacidad / (uint64_t)logico) {
        fprintf(stderr, "Geometria no admitida o LBA fuera de rango\n"); close(fd); return 1;
    }
    uint64_t offset = lba * (uint64_t)logico;
    if (offset > (uint64_t)INT64_MAX - ((uint64_t)logico - 1)) {
        fprintf(stderr, "La lectura excede los offsets admitidos\n"); close(fd); return 1;
    }
    unsigned char buffer[4096];
    size_t usados = 0, pedido = logico == 512 ? 512u : 4096u;
    while (usados < pedido) {
        size_t faltan = pedido - usados;
        if (usados >= sizeof buffer || faltan > sizeof buffer || faltan > sizeof buffer - usados) {
            fprintf(stderr, "Limite interno de buffer invalido\n"); close(fd); return 1;
        }
        ssize_t n = pread(fd, buffer + usados, faltan, (off_t)(offset + usados));
        if (n > 0) {
            if ((size_t)n > faltan) {
                fprintf(stderr, "Retorno de lectura fuera de contrato\n"); close(fd); return 1;
            }
            usados += (size_t)n;
        }
        else if (n < 0 && errno == EINTR) continue;
        else {
            if (n == 0) fprintf(stderr, "Fin prematuro de la region\n");
            else perror("pread");
            close(fd); return 1;
        }
    }
    if (close(fd)) { perror("close"); return 1; }
    printf("SECTOR_LOGICO=%d\n", logico);
    if (imagen) puts("SECTOR_FISICO=NA"); else printf("SECTOR_FISICO=%d\n", fisico);
    printf("CAPACIDAD=%" PRIu64 "\nLBA=%" PRIu64 "\nOFFSET=%" PRIu64 "\nHEX=",
           capacidad, lba, offset);
    for (size_t i = 0; i < pedido; ++i) printf("%02X", (unsigned)buffer[i]);
    putchar('\n');
    if (fflush(stdout) == EOF) { perror("stdout"); return 1; }
    return 0;
}

import argparse
import json
import os
import stat
import struct
import sys
import uuid
import zlib

class NoSoportado(Exception):
    pass

def examinar(ruta, s):
    fd = os.open(ruta, os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK)
    with os.fdopen(fd, 'rb') as f:
        st = os.fstat(f.fileno())
        if not stat.S_ISREG(st.st_mode) or st.st_size < 2 * s or st.st_size % s:
            raise ValueError('Se requiere imagen regular, estable y con sectores completos')
        n = st.st_size // s
        def leer(offset, cantidad):
            if offset < 0 or cantidad < 0 or offset > st.st_size or cantidad > st.st_size - offset:
                raise ValueError('Region fuera de la imagen')
            f.seek(offset)
            b = f.read(cantidad)
            if len(b) != cantidad:
                raise ValueError('Lectura truncada')
            return b
        def sin_solapamientos(partes):
            ordenadas = sorted(partes, key=lambda p: p['inicio'])
            for a, b in zip(ordenadas, ordenadas[1:]):
                if b['inicio'] <= a['fin']:
                    raise ValueError('Particiones superpuestas')
        mbr = leer(0, 512)
        if mbr[510:512] != b'\x55\xaa':
            raise ValueError('Firma MBR ausente')
        registros = []
        for i in range(4):
            e = mbr[446 + 16 * i:462 + 16 * i]
            inicio, cantidad = struct.unpack_from('<II', e, 8)
            if e[0] not in (0, 0x80):
                raise ValueError('Indicador de arranque MBR invalido')
            if not e[4]:
                if inicio or cantidad:
                    raise ValueError('Entrada MBR vacia con rango no nulo')
                continue
            registros.append((i + 1, e[4], inicio, cantidad, e[0]))
        protector = [r for r in registros if r[1] == 0xEE]
        if not protector:
            partes = []
            for i, tipo, inicio, cantidad, arranque in registros:
                if tipo in (0x05, 0x0F, 0x85):
                    raise NoSoportado('MBR extendido: falta implementar la cadena EBR')
                if inicio < 1 or inicio >= n or not cantidad or cantidad > n - inicio:
                    raise ValueError('Rango MBR invalido')
                partes.append(dict(indice=i, tipo=f'{tipo:02X}', inicio=inicio,
                                   fin=inicio + cantidad - 1, sectores=cantidad,
                                   arranque=arranque == 0x80))
            sin_solapamientos(partes)
            return dict(formato='MBR', sector=s, particiones=partes)
        if len(registros) != 1 or protector[0][0] != 1:
            raise NoSoportado('MBR hibrido o protector fuera del subconjunto')
        _, _, inicio, cantidad, arranque = protector[0]
        if inicio != 1 or cantidad != min(n - 1, 0xFFFFFFFF) or arranque != 0:
            raise ValueError('Rango o indicador del MBR protector invalido')
        h = leer(s, s)
        if h[:8] != b'EFI PART':
            raise ValueError('Firma GPT primaria ausente')
        revision, tamano, crc_h, reservado = struct.unpack_from('<IIII', h, 8)
        if revision != 0x10000 or tamano != 92:
            raise NoSoportado('Se admite revision 1.0 y cabecera de 92 bytes')
        if reservado:
            raise ValueError('Campo reservado GPT no nulo')
        copia = bytearray(h[:tamano])
        copia[16:20] = bytes(4)
        if zlib.crc32(copia) != crc_h:
            raise ValueError('CRC32 de cabecera primaria incorrecto')
        propia, respaldo, primero, ultimo = struct.unpack_from('<QQQQ', h, 24)
        tabla, cuenta, ancho, crc_e = struct.unpack_from('<QIII', h, 72)
        if cuenta != 128 or ancho != 128:
            raise NoSoportado('Se admiten 128 entradas de 128 bytes')
        bloques_tabla = (cuenta * ancho + s - 1) // s
        if (propia != 1 or respaldo != n - 1 or primero > ultimo or
            tabla < 2 or tabla > primero or bloques_tabla > primero - tabla or
            respaldo <= bloques_tabla or ultimo >= respaldo - bloques_tabla or
            h[56:72] == bytes(16)):
            raise ValueError('Geometria GPT primaria incoherente')
        entradas = leer(tabla * s, cuenta * ancho)
        if zlib.crc32(entradas) != crc_e:
            raise ValueError('CRC32 de entradas primarias incorrecto')
        partes, identidades = [], set()
        for i in range(cuenta):
            e = entradas[i * ancho:(i + 1) * ancho]
            if e[:16] == bytes(16):
                continue
            a, b = struct.unpack_from('<QQ', e, 32)
            identidad = str(uuid.UUID(bytes_le=e[16:32]))
            if (a < primero or b > ultimo or b < a or
                e[16:32] == bytes(16) or identidad in identidades):
                raise ValueError('Entrada GPT fuera de rango o identidad duplicada')
            identidades.add(identidad)
            nombre = e[56:128].decode('utf-16-le').split('\0', 1)[0]
            partes.append(dict(indice=i + 1, inicio=a, fin=b, sectores=b - a + 1,
                               tipo_guid=str(uuid.UUID(bytes_le=e[:16])),
                               uuid=identidad, nombre=nombre))
        sin_solapamientos(partes)
        return dict(formato='GPT', sector=s, particiones=partes,
                    crc_cabecera='OK', crc_entradas='OK', respaldo='NO_VERIFICADO')

def main():
    p = argparse.ArgumentParser(description='MBR y GPT primaria en imagen regular')
    p.add_argument('imagen')
    p.add_argument('sector', type=int, choices=(512, 4096))
    a = p.parse_args()
    try:
        resultado = examinar(a.imagen, a.sector)
    except NoSoportado as e:
        print('No soportado: ' + str(e), file=sys.stderr); return 3
    except (OSError, ValueError, struct.error) as e:
        print('Error: ' + str(e), file=sys.stderr); return 1
    print(json.dumps(resultado, ensure_ascii=True, indent=2))
    return 0

if __name__ == '__main__':
    raise SystemExit(main())

from pathlib import Path
import os
import struct
import uuid
import zlib

casos = [('mbr512.img', 512, False), ('gpt512.img', 512, True),
         ('gpt4096.img', 4096, True)]
if any(os.path.lexists(nombre) for nombre, _, _ in casos):
    raise SystemExit('Ya existe una ruta de salida; usa un directorio nuevo')

for nombre, s, gpt in casos:
    capacidad = 64 * 1024 * 1024
    n, inicio, cantidad = capacidad // s, 1048576 // s, 4194304 // s
    mbr = bytearray(512)
    mbr[510:512] = b'\x55\xaa'
    mbr[450] = 0xEE if gpt else 0x83
    struct.pack_into('<II', mbr, 454, 1 if gpt else inicio,
                     min(n - 1, 0xFFFFFFFF) if gpt else cantidad)
    if gpt:
        mbr[447:450] = b'\x00\x02\x00'
        mbr[451:454] = b'\xff\xff\xff'
    with Path(nombre).open('xb') as f:
        f.truncate(capacidad)
        f.write(mbr)
        if gpt:
            entradas = bytearray(128 * 128)
            entradas[:16] = uuid.UUID('11111111-2222-3333-4444-555555555555').bytes_le
            entradas[16:32] = uuid.UUID('aaaaaaaa-bbbb-4ccc-8ddd-eeeeeeeeeeee').bytes_le
            struct.pack_into('<QQQ', entradas, 32, inicio, inicio + cantidad - 1, 0)
            texto = 'datos46'.encode('utf-16-le')
            entradas[56:56 + len(texto)] = texto
            bloques = len(entradas) // s
            tabla_respaldo = n - 1 - bloques
            def cabecera(propia, otra, tabla):
                h = bytearray(s)
                h[:8] = b'EFI PART'
                struct.pack_into('<IIIIQQQQ', h, 8, 0x10000, 92, 0, 0,
                                 propia, otra, 2 + bloques, tabla_respaldo - 1)
                h[56:72] = uuid.UUID('01234567-89ab-cdef-0123-456789abcdef').bytes_le
                struct.pack_into('<QIII', h, 72, tabla, 128, 128, zlib.crc32(entradas))
                struct.pack_into('<I', h, 16, zlib.crc32(h[:92]))
                return h
            for offset, b in ((2 * s, entradas), (tabla_respaldo * s, entradas),
                              (s, cabecera(1, n - 1, 2)),
                              ((n - 1) * s, cabecera(n - 1, 1, tabla_respaldo))):
                f.seek(offset)
                f.write(b)
    print(nombre, 'sector=', s, 'inicio=', inicio, 'sectores=', cantidad)

mkdir laboratorio46
cd laboratorio46
# Guardar leer-bloque.c, examinar-tabla.py y crear-imagenes46.py.
cc -std=c11 -O2 -Wall -Wextra -Wpedantic leer-bloque.c -o leer-bloque
python3 crear-imagenes46.py
./leer-bloque imagen mbr512.img 512 0
./leer-bloque imagen gpt512.img 512 1
./leer-bloque imagen gpt4096.img 4096 1
python3 examinar-tabla.py mbr512.img 512
python3 examinar-tabla.py gpt512.img 512
python3 examinar-tabla.py gpt4096.img 4096

(
set -euo pipefail
loop46=''
liberar46() {
    if [[ -n "$loop46" ]]; then sudo losetup --detach "$loop46"; fi
}
trap liberar46 EXIT
loop46=$(sudo losetup --find --show --read-only --nooverlap --sector-size 4096 gpt4096.img)
printf 'Loop de laboratorio: %s\n' "$loop46"
sudo blockdev --getss "$loop46"
sudo blockdev --getpbsz "$loop46"
sudo blockdev --getsize64 "$loop46"
sudo ./leer-bloque bloque "$loop46" 1
)

python3 - <<'PY'
from pathlib import Path
from tempfile import TemporaryDirectory
import hashlib
import json
import shutil
import struct
import subprocess
import zlib

lector = str(Path('leer-bloque').resolve())
analizador = str(Path('examinar-tabla.py').resolve())
def ejecutar(args, estado=0):
    r = subprocess.run(args, capture_output=True, text=True)
    assert r.returncode == estado, (args, r.returncode, r.stderr)
    return r.stdout
def sha(p):
    h = hashlib.sha256()
    with p.open('rb') as f:
        for b in iter(lambda: f.read(1048576), b''): h.update(b)
    return h.digest()
casos = [(Path('mbr512.img'), 512, 'MBR'), (Path('gpt512.img'), 512, 'GPT'),
         (Path('gpt4096.img'), 4096, 'GPT')]
antes = {p: sha(p) for p, _, _ in casos}
for p, s, formato in casos:
    n = p.stat().st_size // s
    for lba in (0, 1, n - 1):
        salida = ejecutar([lector, 'imagen', str(p), str(s), str(lba)])
        campos = dict(linea.split('=', 1) for linea in salida.splitlines())
        with p.open('rb') as f:
            f.seek(lba * s); esperado = f.read(s)
        assert bytes.fromhex(campos['HEX']) == esperado
        assert int(campos['OFFSET']) == lba * s
    r = json.loads(ejecutar(['python3', analizador, str(p), str(s)]))
    assert r['formato'] == formato and len(r['particiones']) == 1
    parte = r['particiones'][0]
    assert parte['inicio'] * s == 1048576
    assert parte['sectores'] * s == 4194304
    if formato == 'GPT':
        assert r['crc_cabecera'] == r['crc_entradas'] == 'OK'
        assert r['respaldo'] == 'NO_VERIFICADO'
    ejecutar([lector, 'imagen', str(p), str(s), str(n)], 1)
ejecutar([lector, 'imagen', 'mbr512.img', '512', '-1'], 2)
ejecutar([lector, 'imagen', 'mbr512.img', '512', '18446744073709551616'], 2)
ejecutar([lector, 'bloque', 'mbr512.img', '0'], 1)
ejecutar(['python3', analizador, 'gpt4096.img', '512'], 1)
with TemporaryDirectory(prefix='tabla46-') as d:
    base = Path(d)
    def alterada(nombre, offset, datos):
        p = base / nombre
        shutil.copyfile('gpt512.img', p)
        with p.open('r+b') as f: f.seek(offset); f.write(datos)
        return p
    p = alterada('cabecera.img', 512 + 56, bytes(16))
    ejecutar(['python3', analizador, str(p), '512'], 1)
    p = alterada('entrada.img', 1024 + 56, b'X')
    ejecutar(['python3', analizador, str(p), '512'], 1)
    p = alterada('respaldo.img', 64 * 1024 * 1024 - 512, b'BAD PART')
    r = json.loads(ejecutar(['python3', analizador, str(p), '512']))
    assert r['respaldo'] == 'NO_VERIFICADO'
    # CRC correcto con geometria invalida debe fallar por otra razon.
    p = alterada('rango.img', 512 + 40, struct.pack('<Q', 0))
    with p.open('r+b') as f:
        f.seek(512); h = bytearray(f.read(92)); h[16:20] = bytes(4)
        struct.pack_into('<I', h, 16, zlib.crc32(h))
        f.seek(512); f.write(h)
    ejecutar(['python3', analizador, str(p), '512'], 1)
    p = base / 'corta.img'; p.write_bytes(bytes(513))
    ejecutar([lector, 'imagen', str(p), '512', '0'], 1)
    p = base / 'extendida.img'
    shutil.copyfile('mbr512.img', p)
    with p.open('r+b') as f: f.seek(450); f.write(b'\x05')
    ejecutar(['python3', analizador, str(p), '512'], 3)
    p = alterada('mas-entradas.img', 512 + 80, struct.pack('<I', 256))
    with p.open('r+b') as f:
        f.seek(512); h = bytearray(f.read(92)); h[16:20] = bytes(4)
        struct.pack_into('<I', h, 16, zlib.crc32(h))
        f.seek(512); f.write(h)
    ejecutar(['python3', analizador, str(p), '512'], 3)
for p, _, _ in casos: assert sha(p) == antes[p]
print('OK: bytes, unidades, CRC, geometria y consultas sin modificar originales')
PY