Firma v4, verificación y keystores

Antes conviene leer «Esquemas de firma v1, v2 y v3» · «APK Signing Block»

referencia técnica · Actualizado el 15 de noviembre de 2026

1. Qué es y por qué existe

Los esquemas v2 y v3 tienen una propiedad incómoda: para verificarlos hay que haber leído el fichero entero. El digest se calcula sobre todos los bytes, así que el instalador no puede decir «esto es auténtico» hasta que ha recibido el último. Con un APK grande, eso significa esperar a la descarga completa antes de poder ejecutar nada.

¿Cuánto es grande? Más de lo que parece, sobre todo en los juegos. Fíjate en el base.apk, la pieza principal de cada app (un juego es una app con género GAME_*). Entre los juegos de las apps más instaladas de Google Play mide 114,9 MB de mediana, y casi seis de cada diez pasan de 100 MB. En una muestra al azar de Google Play los juegos son más ligeros, con 56,5 MB de mediana. Las apps que no son juegos pesan menos en los dos grupos.

Y el base.apk no es todo. Un juego puede traer además asset packs, paquetes de recursos aparte de cientos de megas. Lo instalado de verdad solo lo conocemos en la muestra al azar, la única con carpetas sacadas con adb: allí la suma de las piezas de un juego mide 81,0 MB de mediana y llega a 4,01 GB. De las más instaladas solo tenemos contenedores con todas las variantes de arquitectura y densidad, y su suma no es lo que se instala. Algunos ejemplos:

  • classic.sigma.solitaire.card.games.klondike.patience.free: un base.apk de 149.778.360 bytes, de un juego grande.
  • com.king.farmheroessaga (6.99.15): un base.apk de 115.085.537 bytes, cerca de la mediana de las más instaladas.
  • com.xd.muffin.gp.global: el asset pack mayor de la muestra al azar, split_install_time_asset_pack.apk, de 3,75 GB.
  • com.igg.android.lordsmobile (2.206): el asset pack mayor de las más instaladas, split_UnityStreamingAssetsPack.apk, de 2,12 GB.

La instalación incremental de Android 11 («glosario») rompe esa espera. La aplicación arranca con una parte del APK transferida, y el resto llega bajo demanda; cada bloque se verifica en el momento en que se lee. Para eso hace falta un digest que se pueda comprobar por trozos sin tener el resto, y eso es justo un árbol de Merkle. Es lo que aporta el esquema v4.

La segunda mitad de la página trata algo distinto pero inseparable: el orden en que el sistema verifica. Con cinco esquemas conviviendo, «¿verifica este APK?» no tiene una sola respuesta. Las reglas de precedencia y de protección contra el downgrade son donde se concentran los errores de implementación, y la «sección 5 · El algoritmo completo de verificación» las recorre en el orden real del código.

2. El fichero .idsig

2.1 Por qué va fuera del APK

El árbol no es pequeño: ronda el 0,8 % del fichero. Sobre 100.000.000 bytes con bloques de 4 KiB ocupa 794.624 bytes, el 0,79 % (la cuenta, nivel a nivel, está en la «sección 3.2 · El tamaño del árbol, comprobado»). Con un APK real sale lo mismo: el base.apk de 149.778.360 bytes de classic.sigma.solitaire.card.games.klondike.patience.free necesita un árbol de 1.187.840 bytes. Para la pieza base mediana va de 57 KB en F-Droid a 610 KB entre las más instaladas de Google Play.

Meterlo dentro del APK Signing Block engordaría el APK para todos los dispositivos. Y hay algo más decisivo: el árbol es un digest del fichero completo, así que meterlo dentro cambiaría el fichero del que se calculó. La solución es un fichero acompañante, <nombre>.apk.idsig, que viaja al lado del APK: adb install --incremental lo consume y el APK instalado no lo contiene.

2.2 Estructura

De V4Signature.java. Todos los campos bytes van con prefijo uint32 de longitud, y todo es little-endian.

Campo Offset Tamaño Tipo Significado
version 0x00 4 uint32 CURRENT_VERSION = 2 en apksig y SUPPORTED_VERSION = 2 en la plataforma. «only version 2 is supported as of now»
hashingInfo length 0x04 4 uint32 Longitud del bloque siguiente
hashingInfo 0x08 var — Ver tabla siguiente
signingInfos length — 4 uint32
signingInfos — var — Ver tabla siguiente. apksig no escribe más de MAX_SIGNING_INFOS_SIZE = 7168 bytes; la plataforma admite INCFS_MAX_SIGNATURE_SIZE = 8096 para hashingInfo y signingInfos juntos: lo que ocupa el primero se descuenta del segundo (V4Signature.readFrom)
verityTree length — 4 uint32 Opcional. Sin él, la firma es stripped
verityTree — var — El árbol de Merkle serializado

hashingInfo:

Campo Offset Tamaño Tipo Significado
hashAlgorithm 0x00 4 uint32 HASHING_ALGORITHM_SHA256 = 1. «only 1 == SHA256 supported»
log2BlockSize 0x04 1 byte LOG2_BLOCK_SIZE_4096_BYTES = 12. «only 12 (block size 4096) supported now»
salt length 0x05 4 uint32 0 en todo lo que produce apksigner. Máximo 32
salt 0x09 var — «used exactly as in fs-verity, 32 bytes max»
rawRootHash length — 4 uint32 32 con SHA-256
rawRootHash — var — «salted digest of the first Merkle tree page»

signingInfo (el primero; detrás puede ir un bloque adicional por cada bloque v3 que no sea el v3.0, con su blockId y su propio signingInfo, «sección 4 · v4 no se sostiene sola»):

Campo Tamaño Tipo Significado
apkDigest var bytes Digest de contenido del APK — el mismo valor que el del bloque v3 o v2
certificate var bytes X.509 en DER
additionalData var bytes «a free-form binary data blob»
publicKey var bytes SubjectPublicKeyInfo en DER, debe corresponder al certificado
signatureAlgorithmId 4 uint32 De la tabla de la «sección 7 de APK Signing Block · Algoritmos de firma»
signature var bytes Firma sobre el signed data

Lo que se firma no es el apkDigest a secas. V4Signature.getSignedData(fileSize, hashingInfo, signingInfo) construye un bloque con el digest y el certificado, y además con el tamaño del fichero y todo el hashingInfo, raíz del árbol incluida. Si se firmara solo la raíz, la firma podría reutilizarse con otro tamaño de fichero.

2.3 Un .idsig real, campo a campo

El muestrario no trae ningún .idsig, así que este lo hemos fabricado: sale de firmar con apksigner una copia de org.fossify.math versión 10 (7.047.681 bytes) con una clave de laboratorio de un solo uso («sección 10.2 · Firmar una copia y verificarla»). Firmada, la copia pasa a 7.176.566 bytes («sección 10.5 · Por qué el APK firmado pesa más»), y el .idsig mide 62.992: 1.552 de cabecera y firma y 61.440 de árbol. Ojo: la raíz, los digests y la huella del certificado que siguen cambian en cada ejecución. Primeros 64 bytes:

00000000: 0200 0000 2d00 0000 0100 0000 0c00 0000  ....-...........
00000010: 0020 0000 00ba fd1c 25f3 1719 954b 4686  . ......%....KF.
00000020: 8bc7 884b be06 d5df b030 269e a329 f86d  ...K.....0&..).m
00000030: 2b38 6993 c6d3 0500 0020 0000 0040 209e  +8i...... ...@ .

Descompuesto:

0x00  02 00 00 00                version = 2
0x04  2d 00 00 00                hashingInfo = 45 bytes
0x08  01 00 00 00                  hashAlgorithm = 1 (SHA-256)
0x0c  0c                           log2BlockSize = 12  → bloque de 4096
0x0d  00 00 00 00                  salt = 0 bytes
0x11  20 00 00 00                  rawRootHash = 32 bytes
0x15  ba fd 1c 25 … 93 c6           bafd1c25f31719954b46868bc7884bbe06d5dfb030269ea329f86d2b386993c6
0x35  d3 05 00 00                signingInfos = 1491 bytes
0x39  20 00 00 00                  apkDigest = 32 bytes
0x3d  40 20 9e c8 …                 40209ec8c81f2cee21dfaa9aaf357e262dbde382c1d929569ee5fb877ad145c4
…
0x60c 00 f0 00 00                verityTree = 61440 bytes

4 + 1 + 4 + 0 + 4 + 32 = 45: el hashingInfo cuadra al byte.

Y el apkDigest no es un número cualquiera. Al modificar un byte de ese mismo APK («sección 10.4 · Comprobar que la firma detecta un cambio de un solo byte»), el error que devuelve apksigner sobre el bloque v3 es:

ERROR: APK Signature Scheme v3 signer #1: APK integrity check failed. CHUNKED_SHA256 digest
mismatch. Expected: <40209ec8c81f2cee21dfaa9aaf357e262dbde382c1d929569ee5fb877ad145c4>, …

Es el mismo valor. El apkDigest del .idsig es el digest de contenido del bloque v3, copiado tal cual. Eso es lo que ata el .idsig a la firma que vive dentro del APK («sección 4 · v4 no se sostiene sola»).

3. El árbol de Merkle y fs-verity

3.1 Cómo se construye

VerityTreeBuilder.java implementa el árbol de fs-verity con CHUNK_SIZE = 4096 y JCA_ALGORITHM = "SHA-256". La documentación del kernel describe el mismo procedimiento:

«The file contents is divided into blocks, where the block size is configurable but is usually 4096 bytes. The end of the last block is zero-padded if needed. Each block is then hashed, producing the first level of hashes. Then, the hashes in this first level are grouped into blocksize-byte blocks (zero-padding the ends as needed) and these blocks are hashed, producing the second level of hashes. This proceeds up the tree until only a single block remains.»

datos del APK, 4096 B por bloque
 ┌────┬────┬────┬────┬────┬────┬────┬─ … ─┬────┐
 │ b0 │ b1 │ b2 │ b3 │ b4 │ b5 │ b6 │     │bn-1│   ← el ultimo, con relleno de ceros
 └─┬──┴─┬──┴─┬──┴─┬──┴─┬──┴─┬──┴─┬──┴─────┴─┬──┘
   ▼    ▼    ▼    ▼    ▼    ▼    ▼          ▼        SHA-256 de cada bloque
 ┌────┬────┬────┬────┬────┬────┬────┬─ … ─┬────┐
 │ h0 │ h1 │ h2 │ h3 │ h4 │ h5 │ h6 │     │hn-1│   nivel 0: 32 B por hash
 └────┴────┴────┴────┴────┴────┴────┴─────┴────┘
       agrupados de nuevo en bloques de 4096 B (128 hashes por bloque)
                       ▼
              ┌────┬────┬─ … ─┐
              │ H0 │ H1 │     │                    nivel 1
              └────┴────┴─────┘
                       ▼
                    ┌────┐
                    │ R  │                          un solo bloque
                    └────┘
                       ▼
              raw root hash = SHA-256 de ese bloque

Aquí está la diferencia con v2 y v3, y es fácil suponerla al revés: el árbol de v4 cubre todos los bytes del fichero, APK Signing Block incluido. No hereda la exclusión del digest de contenido de v2/v3. V4SchemeSigner.generateV4Signature toma el tamaño entero y pasa el DataSource completo:

final long fileSize = apkContent.size();
…
ApkSigningBlockUtils.VerityTreeAndDigest verityContentDigestInfo =
        ApkSigningBlockUtils.computeChunkVerityTreeAndDigest(apkContent);

La sobrecarga que exige alineación —la del IllegalStateException("APK Signing Block size not a multiple of " + CHUNK_SIZE)— la usa computeApkVerityDigest, que sirve al digest VERITY_CHUNKED_SHA256 de v2 y v3, no al árbol de v4. Encaja con la «sección 2.1 · Por qué va fuera del APK» y con la tabla de la 3.2, que parte de los 7.176.566 bytes del fichero firmado entero, no de un tramo recortado.

3.2 El tamaño del árbol, comprobado

calculateLevelOffset da el tamaño de cada nivel: cada uno se redondea al alza a múltiplo de 4096. Sobre el APK firmado de 7.176.566 bytes de la «sección 2.3 · Un .idsig real, campo a campo»:

Nivel Entradas Bytes de hashes Redondeado a 4096
0 (hashes de los datos) ⌈7.176.566 / 4096⌉ = 1.753 1.753 × 32 = 56.096 57.344
1 ⌈56.096 / 4096⌉ = 14 14 × 32 = 448 4.096
Total 61.440

El campo verityTree length del .idsig real vale exactamente 61.440, el 0,86 % del APK. Si escribes tu propia implementación, es un buen test de humo: el tamaño del árbol es determinista y sale solo del tamaño del APK.

Con un APK mayor, el árbol gana un nivel. El base.apk de 149.778.360 bytes de classic.sigma.solitaire.card.games.klondike.patience.free da tres: 1.171.456 + 12.288 + 4.096 = 1.187.840 bytes, el 0,79 %. La cuenta, nivel a nivel: ⌈149.778.360 / 4096⌉ = 36.567 hashes × 32 = 1.170.144 bytes, que redondean a 1.171.456; ⌈1.170.144 / 4096⌉ = 286 hashes × 32 = 9.152, que redondean a 12.288; y 3 hashes × 32 = 96, que redondean a 4.096, un solo bloque.

3.3 Qué comparte con fs-verity y qué no

La documentación de v4 es explícita: el árbol «follows the structure of the fs-verity hash tree exactly (for example, zero-padding the salt and zero-padding the last block)». Tiene que ser así porque en el dispositivo el árbol lo usa el kernel, no la aplicación. En una instalación incremental no se recalcula. adb envía los bloques del árbol que lleva el .idsig junto con los bloques de datos que se van pidiendo, e IncFS verifica cada bloque recibido contra ese árbol y contra la raíz firmada, sin que quien lee el APK lo note. El comentario de VerityTreeBuilder habla de regenerarlo en el dispositivo —«The tree is currently stored only in memory and is never written out. Nevertheless, it is the actual verity tree format on disk, and is supposed to be re-generated on device»—, pero el cliente de adb (incremental_server.cpp) lo lee del .idsig y lo transmite tal cual.

Dos diferencias que conviene tener presentes:

  • fs-verity firma un fsverity_descriptor, no la raíz a secas. El kernel calcula el digest del fichero a partir de una estructura que incluye la raíz y los metadatos, «rather than the root hash alone, to resolve ambiguities in hashing». v4 hace lo análogo con su getSignedData, pero no es la misma estructura byte a byte.
  • La sal. fs-verity la admite y la rellena con ceros «to the closest multiple of the input size of the hash algorithm's compression function». apksigner no la usa: el .idsig generado aquí declara salt length = 0, y el comentario de V4SchemeSigner explica por qué: «Salt has to stay empty for fs-verity compatibility».

4. v4 no se sostiene sola

La especificación lo dice en una línea: «A v4 signature requires a complementary v2 or v3 signature». No es una recomendación, es una precondición que apksig comprueba antes de firmar:

BT=~/Library/Android/sdk/build-tools/37.0.0
$BT/apksigner sign --ks pruebas.jks --ks-key-alias pruebas --ks-pass pass:pruebas \
  --v2-signing-enabled false --v3-signing-enabled false --v4-signing-enabled true \
  --out solo_v4.apk copia.apk
Exception in thread "main" java.lang.IllegalStateException: APK Signature Scheme v4 signing
requires at least v2 or v3 signing to be enabled
	at com.android.apksig.ApkSigner$Builder.build(ApkSigner.java:1923)

copia.apk es la copia de org.fossify.math versión 10 de la «sección 10.2 · Firmar una copia y verificarla». La salida se repitió el 31 de octubre de 2026 con esa copia y es la misma.

Por qué es así. El .idsig es un fichero suelto que cualquiera puede sustituir; nada de lo que viaja dentro del APK lo firma. Si v4 fuese autónoma, un atacante podría entregar un APK cualquiera con un .idsig fabricado con su propia clave, y el sistema no tendría con qué contrastarlo. El anclaje es el apkDigest de la «sección 2.3 · Un .idsig real, campo a campo»: el .idsig copia el digest del bloque v2 o v3, así que verificar v4 obliga a que coincida con el que la clave del desarrollador firmó dentro del APK. v4 aporta la granularidad por bloques; la confianza sigue viniendo de v2/v3.

Para el signingInfo principal, el código elige el digest en ese orden exacto — v3 si existe, v2 si no:

byte[] apkDigest = apkDigests.containsKey(VERSION_APK_SIGNATURE_SCHEME_V3)
        ? apkDigests.get(VERSION_APK_SIGNATURE_SCHEME_V3)
            : apkDigests.get(VERSION_APK_SIGNATURE_SCHEME_V2);

Y no es el único. Una aplicación que rota en v3.1 lleva dos firmas en su .idsig: cuando hay firmante v3.1, generateSignature añade detrás un SigningInfoBlock con blockId = 0x1b93ad61, el digest del bloque v3.1 y la firma de la clave rotada (V4SchemeSigner.java, líneas 217-237). La plataforma elige cuál verificar según el bloque v3 que ha leído del APK, v3BlockId. Con v3.0 usa el signingInfo principal; con v3.1 o v3.2, el bloque con ese identificador, y si falta, Failed to find V4 signature block corresponding to V3 blockId (ApkSignatureSchemeV4Verifier.java, 160-179). En el .idsig del APK de prueba de la «sección 9 de APK Signing Block · El volcador», generado el 18 de octubre de 2026, el signingInfo principal lleva el CHUNKED_SHA256 del bloque v3, firmado con K0, y el bloque 0x1b93ad61, el CHUNKED_SHA512 del v3.1, firmado con K1.

¿Pasa en la práctica? No tenemos ningún .idsig real, así que lo deducimos de los bloques v3.1 de los APK. Es casi cosa de Google Play: lleva bloque v3.1 en torno al 10 % de las apps más instaladas, y apenas un puñado del resto de fuentes; ninguna de F-Droid ni de IzzyOnDroid. Cada una de esas apps llevaría dos signingInfo en su .idsig. Un ejemplo es la Calculadora de Google 9.3 (com.google.android.calculator, base.apk), con v3 para las API 24 a 32 (RSA de 2.048 bits) y v3.1 desde la 33 (RSA de 4.096 bits).

5. El algoritmo completo de verificación

Lo reconstruimos leyendo ApkVerifier.verify() de apksig, la implementación de apksigner y contra la que se compara todo lo demás. Pero ojo: el instalador de Android no la usa. La plataforma verifica con su propia copia, android.util.apk.ApkSignatureVerifier de frameworks/base. Prueba v4, v3 (y dentro de v3, v3.2, v3.1 y v3.0, por ese orden), v2 y v1, y se queda con el primero que encuentra. Tampoco recibe un rango minSdk/maxSdk como el del flujo siguiente, que en apksigner dan --min-sdk-version y --max-sdk-version. Dentro de cada bloque v3 elige el firmante cuyo rango firmado cubre el Build.VERSION.SDK_INT del dispositivo y se salta los demás (ApkSignatureSchemeV3Verifier.java, líneas 357-397 y 593-612, en android-17.0.0_r1). Y no aplica la regla 5 de la «sección 5.2 · Las reglas, en orden»: si hay bloque v2, v1 ni se mira.

5.1 El flujo

bloque presente que novalidaentrada: APK,minSdk,maxSdk,[fichero .idsig]localizar EOCD→ CentralDirectory →Signing Blksi maxSdk >=24, en esteorden:maxSdk >= 37→ bloque v3.20x70e1c89fmaxSdk >= 33→ bloque v3.10x1b93ad61maxSdk >= 28→ bloque v30xf05368c0minSdk < 28 →bloque v20x7109871ao nada halladoantes.idsig dado →esquema v4v3.1 presentesin v3 → errorsi minSdk < 24o nada hallado:verificar v1sobreMETA-INF/si existe laentradastamp-cert-sha256:verificar elsource stamp0x6dff800dsi v1 y v2verificaron:mismo firmanteVERIFICARECHAZO

5.2 Las reglas, en orden

1. De arriba hacia abajo, y el primero que se encuentra manda. El comentario del código: «Android N and newer attempts to verify APKs using the APK Signing Block, which can include v2 and/or v3 signatures. If none is found, it falls back to JAR signature verification. If the signature is found but does not verify, the APK is rejected.»

2. Un esquema superior presente obliga a que valide. Esta es la regla que más se malentiende. No es «prueba v3 y si falla prueba v2». Es «si hay bloque v3, tiene que validar; si no valida, se acabó». En el código, cada esquema termina con:

if (result.containsErrors()) {
    return result;
}

No hay camino de vuelta. La caída a un esquema inferior solo ocurre por ausencia, nunca por fallo.

3. Los inferiores se saltan si un superior ya cubrió el rango. El bloque v2 solo se verifica si minSdkVersion < 28 o si no se encontró nada; v1 solo si minSdkVersion < 24 o si no se encontró nada. De ahí la salida v2: false sobre un APK que sí tiene bloque v2 («sección 9 de Esquemas de firma v1, v2 y v3 · Por qué un APK moderno lleva v1+v2+v3 (y cuándo se puede omitir v1)»).

Y es lo normal. Entre las apps más instaladas de Google Play con minSdkVersion 28 o más y bloque v2, apksigner no llega a comprobar el v2 de nueve de cada diez, porque ya lo cubre el v3. Con v1 pasa lo mismo: en F-Droid, casi todas las apps con minSdkVersion 24 o más y firma v1 llevan además v2 o v3, y su v1 no se comprueba. Un v2 que sí se comprueba, porque no hay v3, es el de moe.henry_zhr.force_dark versión 2 (IzzyOnDroid; 8.295 bytes; minSdkVersion 28 o más).

4. La protección contra el downgrade cierra el hueco. Las reglas 1 a 3 dejarían un ataque obvio: quitar el bloque superior para que el sistema use el inferior, más débil o firmado con otra clave. Cuatro candados cierran esa vía, y los cuatro están firmados:

Candado Dónde vive Qué declara
X-Android-APK-Signed Sección principal del .SF de v1 Lista de esquemas superiores presentes
0xbeeff00d STRIPPING_PROTECTION Atributo del bloque v2 Número del esquema superior presente
0x559f8b02 ROTATION_MIN_SDK_VERSION Atributo del bloque v3 minSdkVersion que debe declarar el v3.1
0xbf940529 / 0x9f06b79c HYBRID_MIN/MAX_SDK_VERSION Atributos de los bloques v3 y v3.1 Rango de SDK que debe declarar el v3.2

Más la regla simétrica sin atributo: un bloque v3.1 sin bloque v3 es un error, V31_BLOCK_FOUND_WITHOUT_V3_BLOCK. La demostración práctica del segundo candado, 0xbeeff00d, está en la «sección 10.3 de Esquemas de firma v1, v2 y v3 · La protección contra el downgrade, demostrada».

En los APK reales los candados están donde dice la tabla (aquí contamos piezas, no apps). El atributo 0xbeeff00d aparece en casi todas las piezas que llevan v2 y v3 (faltan 7, y no hemos mirado por qué) y en ninguna con v2 sin v3. El atributo 0x559f8b02 aparece en todas las piezas con v3.1, y no hay ningún v3.1 sin v3. La cabecera X-Android-APK-Signed figura en casi todas las piezas con .SF, casi siempre con el valor «2, 3»; hay una con «2,3», sin espacio, y falta en 2. Los bloques v3.2 (0x70e1c89f) con sus atributos HYBRID están en 34 piezas de 9 apps de la muestra al azar de Google Play, y solo verifican con un Java que traiga ML-DSA (con Java 25, las 34). Por ejemplo, com.astropeak.congklak: split_config.xxhdpi.apk (41.267 bytes) y split_config.en.apk (45.266 bytes).

5. Si v1 y v2 verifican los dos, los firmantes tienen que coincidir. Un APK con v1 firmado por A y v2 firmado por B se rechaza: cada firmante v1 tiene que estar entre los v2 y al revés (V2_SIG_MISSING, JAR_SIG_MISSING; ApkVerifier.java, líneas 450-494). Los dos solo verifican a la vez cuando el rango pedido abarca plataformas que solo leen v1 y plataformas que leen v2. Eso es lo que protege la regla: que el mismo APK tenga la misma identidad en un Android 6 que en uno moderno. No es una defensa contra quien añade un bloque v2 con su clave a un APK ajeno: un dispositivo moderno lo vería como una aplicación de B, que no actualiza la de A, y la plataforma ni siquiera aplica esta regla.

La regla la conocemos por el código, no por un ejemplo real. En ninguna de las más de 9.000 piezas con v1 y v2 a la vez el firmante v1 es distinto del v2, y apksigner no rechazó ninguna por V2_SIG_MISSING o JAR_SIG_MISSING.

6. targetSandboxVersion > 1 exige APK Signing Block. Desde Android 8.0, un APK que declare android:targetSandboxVersion mayor que 1 y no tenga ningún esquema v2+ se rechaza (NO_SIG_FOR_TARGET_SANDBOX_VERSION).

Esta no la hemos visto en acción: ninguna de las unas 420 apps sin bloque de firma (casi todas de F-Droid) declara targetSandboxVersion, así que no hay contraejemplo ni caso aplicado. Un ejemplo de pieza con solo v1 que no lo declara es pro.rudloff.lineageos_updater_shortcut versión 2 (12.599 bytes). El rechazo lo hace el instalador y no lo hemos probado.

5.3 Qué se verifica del Central Directory y del EOCD

No hay un paso separado: están dentro del digest. Los tramos 3 y 4 de la «sección 6.1 de APK Signing Block · Qué se trocea» son el Central Directory completo y el EOCD, así que cualquier cambio en un nombre, un offset, un tamaño o el número de entradas rompe el digest igual que si se hubiera tocado un .dex.

La única pieza con tratamiento especial es el campo offset of start of central directory del EOCD, sustituido por el tamaño del tramo 1 antes de digerir. Ese campo queda determinado, no libre: su valor correcto se deduce de datos que sí están cubiertos.

Lo que no se verifica en esta capa es la coherencia interna del ZIP: que los Local File Header concuerden con el Central Directory, que no haya nombres duplicados o que no sobren bytes entre entradas. Eso es competencia del lector de ZIP (libziparchive en el dispositivo), y su divergencia con el verificador es la raíz de las dos vulnerabilidades históricas de la «sección 12 de Contenedor ZIP · Nota histórica: Master Key y Janus». Una firma válida no implica un ZIP bien formado.

Los APK reales lo confirman: todas las apps con anomalías en el ZIP verifican igualmente (contamos las anomalías del lector de ZIP en la pieza base de cada app). Son raras en F-Droid (un 1 %) y en Google Play, y más frecuentes en IzzyOnDroid (un 11 %) y en el mercado chino (13 de 100). Casi siempre son bytes antes de la primera entrada; siguen los huecos entre entradas y, en muy pocas apps, un comentario no vacío en el EOCD. No hay ningún nombre duplicado ni ningún bit de cifrado puesto. Ejemplos:

  • moe.henry_zhr.kill_domain_verification versión 4 (IzzyOnDroid; 10.750 bytes): anomalía del lector de ZIP, y apksigner verifica.
  • com.martinmimigames.tinymusicplayer versión 4 (F-Droid e IzzyOnDroid; 16.520 bytes): ídem.
  • Magisk 31000, com.topjohnwu.magisk (IzzyOnDroid; 11.606.088 bytes): comentario del EOCD no vacío.

5.3 bis. Pares del APK Signing Block que el verificador no mira

El APK Signing Block es una lista de pares «identificador, valor». El verificador de la plataforma ignora los pares cuyo identificador no conoce, y por eso se puede añadir información sin romper v2 ni v3. Las tiendas chinas lo aprovechan para marcar el canal por el que se distribuye una app. Casi un tercio de las apps del mercado chino lleva un bloque de canal, de Walle (0x71777777) o de VasDolly (0x881155ff), dos herramientas que ponen ese canal, y todas verifican. Una de las más instaladas de Google Play también lleva el de Walle, y una app del mercado chino guarda el canal como un fichero dentro de META-INF/, sin bloque. Ahí hay además identificadores que ningún código del que disponemos permite identificar, como 0x71717874 (el channelId, que el «documento del bloque de firma» cuenta como canal), 0x71777775 o 0x881155f0. Los llamamos «sin identificar».

Google Play pone el suyo, el frosting (0x2146444e, «sección 8 · El source stamp»). También hay un par 0xfa1cfabe sin identificar en algunas apps de Google Play, que casi siempre mide 200 bytes. Otros pares son relleno de alineación (0x42726577, presente en más del 90 % de las apps de F-Droid, IzzyOnDroid y las más instaladas de Google Play) y la información de dependencias que añade el plugin de Gradle (0x504b4453). Llevar algún par que no es firma ni relleno es raro en F-Droid (2 %) y casi la norma en Google Play (90 % de las más instaladas); las apps del mercado chino que los llevan verifican todas. Ejemplos de canal, todos del mercado chino:

  • cn.ninegame.gamemanager 80506001 (41.648.903 bytes) y com.ifeng.newvideo 73440 (47.696.655 bytes): bloque de canal en el APK Signing Block.
  • com.suning.mobile.ebuy 596 (135.494.589 bytes): el canal va como fichero META-INF/config_channel.txt.

Con v4 hay una consecuencia, deducida de que el árbol cubre el fichero entero («sección 3.1 · Cómo se construye») y no probada: si se añade un par después de generar el .idsig, cambia la raíz del árbol y el .idsig deja de valer.

5.4 Un .idsig que no corresponde: apksigner lo ignora, el instalador no

Con apksigner 0.9 de build-tools 37.0.0, al verificar con --v4-signature-file el org.fossify.math firmado («sección 10.2 · Firmar una copia y verificarla») y pasarle el .idsig de otro APK, la salida es

Verifies
…
Verified using v4 scheme (APK Signature Scheme v4): false

con código de salida 0 y ninguna línea ERROR. El fichero no se descarta: se verifica, falla, y el fallo no cuenta. V4SchemeVerifier apunta el error en el firmante v4, y ApkVerifier.Result.containsErrors() revisa los firmantes v1, v2, v3 y v3.1 y el source stamp, pero no los v4 (ApkVerifier.java, líneas 358-368 y 1765-1822 en android-17.0.0_r1). Solo cuenta lo que se comprueba después, y solo si la firma v4 valida: que su certificado y su apkDigest sean los de v2/v3. De ahí resultados muy distintos según el .idsig:

.idsig Resultado de apksigner verify
De otro APK, el que sale al firmar la misma entrada con otra clave, o con un byte de la raíz, la firma o el árbol alterado Verifies, v4: false, código 0
Válido para estos bytes pero firmado por otra clave (leído en el código; no se pudo reconstruir con apksigner 0.9) DOES NOT VERIFY: «V4 signature and V2/V3 signature have mismatched certificates», código 1
Truncado antes del final de signingInfos (a 8 o a 1.000 bytes) Excepción de Java sin veredicto: NullPointerException en V4Signature$HashingInfo.fromByteArray (o EOFException), código 1
Truncado dentro del árbol de Merkle (a 40.000 bytes) Verifies, v4: true. V4Signature.readBytes devuelve null ante el EOFException y apksig lo trata como un árbol ausente, que no compara; con el árbol completo sí lo compara (V4_SIG_APK_TREE_DID_NOT_VERIFY), y la raíz, siempre

Repetimos las filas primera, tercera y cuarta el 31 de octubre de 2026. El .idsig de otro APK es el de org.fossify.clock versión 10 (9.110.265 bytes), firmado con la misma clave de prueba (el APK firmado mide 9.264.162 bytes y su .idsig, 79.376; el de org.fossify.math, 62.992). Los .idsig truncados salen de head -c 8, head -c 1000 y head -c 40000 sobre el del math. En esta pasada no volvimos a medir el código de salida de las dos últimas filas.

Ni la página de apksigner de developer.android.com —actualizada el 5 de marzo de 2026 y consultada de nuevo el 18 de octubre— ni la ayuda de apksigner verify mencionan --v4-signature-file, que solo está en el código (ApkSignerTool.java, línea 620, en android-17.0.0_r1), así que nada dice si esto es lo previsto.

El instalador de Android no hace lo mismo. En android-17.0.0_r1, ApkSignatureVerifier.verifyV4Signature convierte cualquier excepción que no sea SignatureNotFoundException en INSTALL_PARSE_FAILED_NO_CERTIFICATES («Failed to collect certificates from … using APK Signature Scheme v4», líneas 339-343): una firma v4 que aparece y no valida —digest de fs-verity distinto, firma que no verifica, certificado o apkDigest que no son los de v2/v3— hace fallar la instalación, y un .idsig truncado después de los cuatro bytes de la versión, también. Solo se cae a v3/v2 en silencio cuando no hay firma v4 que leer: ni la tiene el sistema de ficheros incremental ni hay junto al APK un .idsig del que se pueda leer al menos la versión (ApkSignatureSchemeV4Verifier.extractSignature, líneas 76-134).

En la práctica el fallo llega antes. Lo probamos el 25 de septiembre de 2026 en un emulador Android 14 con adb install --incremental, no con piezas del muestrario, y no lo hemos repetido desde entonces (ver «Lo que no hemos podido comprobar», «sección 1 · Qué es y por qué existe»): el .idsig de otro APK hace fallar la instalación con INSTALL_PARSE_FAILED_NOT_APK: … Failed to load asset path, porque el sistema de ficheros incremental comprueba cada bloque contra el árbol del .idsig, el primero ya no pasa y el APK ni siquiera se puede abrir; y uno truncado a 8 bytes lo rechaza adb en el ordenador, con Failed to read data: End of file. Sin --incremental, adb no envía el .idsig y el APK se instala por v2 o v3. Sin probar queda la otra vía, la del .idsig que se escribe en la sesión cuando el dispositivo admite fs-verity.

5.5 Con .idsig, la integridad la pone el árbol

Cuando el instalador encuentra una firma v4, ApkSignatureVerifier.verifyV4Signature no recalcula el digest de contenido de v2/v3 (líneas 250-347 en android-17.0.0_r1). Lee el bloque v3 —o el v2, si no hay v3— con ApkSignatureSchemeV3Verifier.unsafeGetCertsWithoutVerification o ApkSignatureSchemeV2Verifier.verify(apkPath, false), que comprueban las firmas del bloque pero no llaman a verifyIntegrity (ApkSignatureSchemeV3Verifier.java, 120-123 y 319-321; ApkSignatureSchemeV2Verifier.java, 129-133 y 215-217), y se queda con sus certificados, sus digests declarados y su lineage. Ese paso se da con verifyFull, cuando el .idsig trae bloques adicionales o con el flag always_load_past_certs_v4 activo; si no, v2 y v3 ni se leen (268-299). Después verifica la firma v4, y el único digest que devuelve es la raíz del árbol: «digests enforced by IncFS driver and fs-verity» (ApkSignatureSchemeV4Verifier.java, 140-157). Y solo con verifyFull —el de ApkSignatureVerifier.verify; unsafeGetCertsWithoutVerification lo pasa desactivado, 83-96— exige que el certificado v4 sea el de v2/v3 y que su apkDigest esté entre los digests declarados: V4 signature certificate does not match V2/V3 y APK digest in V4 signature does not match V2/V3 (307-332).

En resumen: en una instalación incremental nadie calcula el CHUNKED_SHA256 de v3 sobre el fichero. El apkDigest se compara con el valor que el bloque declara y que la clave del desarrollador firma, y cada bloque de datos lo comprueba IncFS contra el árbol en el momento de leerlo. Por eso importa el anclaje de la «sección 4 · v4 no se sostiene sola»: es lo que ata la raíz del árbol a la firma de v2/v3 sin leer el fichero entero.

5.6 Un conjunto de splits y un contenedor

Una app de Google Play suele llegar como varias piezas: el base.apk y varios splits, APK más pequeños para un idioma, una densidad de pantalla o una arquitectura (ver «AAB, splits y contenedores»). A esas piezas las llamamos aquí un conjunto. La plataforma verifica cada APK por separado y exige que todos los del conjunto compartan paquete, versión y certificado (esto sale del comportamiento del instalador, no lo hemos probado).

Se cumple en los 773 conjuntos medidos (carpetas sacadas con adb, .apkm y .xapk): ninguno mezcla paquetes, versionCode o certificados entre sus piezas. Ninguna app aparece por dos vías con la misma versión (por ejemplo, un .apkm y una carpeta). Y un contenedor no añade garantía sobre las piezas:

  • Los 388 .apkm llevan una firma de JAR propia de APKMirror (META-INF/MANIFEST.MF, APKMIRRO.SF y APKMIRRO.RSA, más info.json, icon.png y APKM_installer.url). Cubre el contenedor, no las piezas, y no la hemos verificado.
  • Los 72 .xapk no llevan firma propia: llevan manifest.json (uno trae además APKComboInstaller.url).
  • Ningún contenedor lleva un .idsig.

Por eso se verifica cada pieza. Ejemplo: la Calculadora de Google 9.3 (com.google.android.calculator, base.apk). Su .apkm lleva META-INF/MANIFEST.MF, APKMIRRO.SF (504 bytes) y APKMIRRO.RSA (1.597 bytes) junto a base.apk y split_config.mdpi.apk.

6. Cadenas de certificados: qué se verifica y qué no

Android no usa una PKI para las firmas de aplicación. No hay CA de confianza ni cadena hasta una raíz, no se consultan CRL ni OCSP y no se mira la caducidad del certificado al instalar. Se verifica la firma, que la clave sea la del certificado del firmante, el digest y la continuidad con la instalación previa o con su lineage. La identidad de la aplicación es el hash de su certificado («sección 1 de Esquemas de firma v1, v2 y v3 · Qué es y por qué existe»). Por eso se compara por el SHA-256 que imprime apksigner verify --print-certs y no por el CN, y por eso un certificado caducado sigue instalando: la validez hasta después del 22 de octubre de 2033 es una regla de Google Play —«If you plan to publish your apps on Google Play, the key you use to sign your app must have a validity period ending after 22 October 2033»—, no de la plataforma.

El nombre del paquete no basta. La misma aplicación puede llevar claves distintas según la tienda. De los paquetes que están a la vez en F-Droid e IzzyOnDroid, casi uno de cada tres lleva otro certificado, y una copia no puede actualizar a la otra. VLC de F-Droid y el de Google Play también tienen certificados distintos. En cambio, Firefox y Brave descargados de la web de su autor llevan el mismo certificado que los de Google Play. La unidad es el paquete (applicationId), y «mismo certificado» quiere decir el mismo SHA-256 del firmante de la pieza base. Ejemplos:

  • ru.tech.imageresizershrinker 251: F-Droid e IzzyOnDroid, mismo certificado (20d7689d…) en ficheros distintos.
  • com.bugsdev2.bookaccio 400: F-Droid e IzzyOnDroid, otro certificado (90aa662b… frente a ba2fdd5e…).
  • Firefox 158 (org.mozilla.firefox): la web de Mozilla y Google Play, mismo certificado (a78b62a5…).
  • org.videolan.vlc 13070206: F-Droid frente a Google Play, otro certificado.

Qué se ve en la práctica. Casi todas las apps llevan un certificado autofirmado, firmado por su propia clave y sin ninguna autoridad por encima. Las únicas excepciones están entre las más instaladas de Google Play, y son pocas: 20 de 658, 3 de ellas con más de un certificado en la cadena. Dos ejemplos de certificado no autofirmado: com.amazon.amazonvideo.livingroom 6.24.12 (base.apk, 5.422.728 bytes) y com.motorola.fmplayer 02.06.0025 (5.914.665 bytes).

Unas pocas apps llevaban el certificado ya caducado el día de la descarga, casi todas de F-Droid e IzzyOnDroid, y esas verifican con apksigner. Ojo: no instalamos nada, así que esto no prueba que un certificado caducado instale, solo que el verificador lo acepta. La regla de 2033 también se nota: no caduca antes ninguna app de la muestra al azar de Google Play, y sí unas pocas de F-Droid e IzzyOnDroid. Y el nombre no identifica: hay 338 certificados distintos con el mismo CN=Android, OU=Android, O=Google Inc..

7. Leer un lineage de rotación

La estructura del lineage, sus capacidades, cómo decide el sistema una actualización y el de Google Keep, volcado y leído con apksigner lineage --print-certs, están en la «sección 5.2 de Esquemas de firma v1, v2 y v3 · El lineage de rotación»; lo que el verificador exige a cada nodo, en la «sección 5.2 de APK Signing Block · Rechazos estructurales y reglas del lineage», y la excepción temporal de ROLLBACK que la guía de v3.2 recomienda durante el despliegue de la firma híbrida, para la clave clásica original, en la «sección 7.4 de Esquemas de firma v1, v2 y v3 · Rotación implícita y ROLLBACK».

La rotación está en uso, sobre todo en Google. Lleva un lineage de al menos dos eslabones el 12 % de las apps más instaladas de Google Play, la mitad de ellas de Google, y 13 de 100 en el mercado chino; en F-Droid e IzzyOnDroid, solo una app en cada una. Lo habitual son dos eslabones; tres, pocas veces. Dos ejemplos de las más instaladas de Google Play: la Calculadora de Google 9.3 (com.google.android.calculator, base.apk), con dos eslabones y rollback en false; y Google Keep 5.26.411.03.97 (com.google.android.keep, base.apk), con tres eslabones. Esa pieza de Keep es la variante para Wear OS: sirve como ejemplo de lineage, no como app de móvil.

8. El source stamp

Un source stamp acredita quién distribuyó el APK, de forma independiente a quién lo firmó. Son dos piezas que tienen que existir a la vez:

  1. Una entrada del ZIP llamada stamp-cert-sha256, en la raíz, con 32 bytes: el SHA-256 del certificado del sello.
  2. Un par 0x6dff800d en el APK Signing Block, con el certificado completo, la firma y sus atributos. Su estructura, y qué bytes firma el sello, están en la «sección 5.3 de APK Signing Block · El source stamp, 0x6dff800d».

La entrada del ZIP está cubierta por el digest de v2/v3, así que no se puede cambiar sin romper la firma de distribución. Eso une las dos piezas: el sello no puede sustituirse por otro sin invalidar la firma del desarrollador. En los APK reales aparecen siempre juntas; ninguno lleva solo una, y la entrada es siempre el SHA-256 del certificado del par.

Lo comprobamos sobre el base.apk de la Calculadora de Google 9.3, que viene dentro de un .apkm (com.google.android.calculator; el contenedor mide 4.884.172 bytes y el base.apk, 7.298.875).

unzip -p "$APKM" base.apk > base.apk
unzip -p base.apk stamp-cert-sha256 | xxd
00000000: 3257 d599 a49d 2c96 1a47 1ca9 843f 59d3  2W....,..G...?Y.
00000010: 41a4 0588 4583 fc08 7df4 237b 733b bd6d  A...E...}.#{s;.m

Y lo que informa apksigner:

Source Stamp Signer: certificate SHA-256 digest: 3257d599a49d2c961a471ca9843f59d341a405884583fc087df4237b733bbd6d
Source Stamp Signer: key size (bits): 4096
Source Stamp Timestamp: 1789107405

Byte a byte, el mismo valor. Es el certificado de Google, el que llevan todas las piezas con sello que tenemos. El Source Stamp Timestamp es el atributo 0xe43c5946 (STAMP_TIME_ATTR_ID), «an 8-byte little-endian encoded long representing the epoch time in seconds when the stamp block was signed». Aquí, 1789107405 corresponde al 11 de septiembre de 2026. Las marcas de tiempo que hemos visto van de noviembre de 2022 a octubre de 2026; en 130 piezas con sello no hay marca legible, y no sabemos por qué.

En qué se diferencia de la firma de distribución:

Firma v2/v3 Source stamp
Quién la pone El desarrollador (o Play App Signing por él) La cadena de compilación o distribución
Qué acredita Continuidad de la clave y que los bytes no han cambiado Origen: de dónde salió este binario
Qué pasa si falta El APK no instala si apunta a Android 11 (targetSdkVersion 30) o más; con menos, basta v1 (ver «Esquemas de firma v1, v2 y v3») Nada, es opcional
Qué pasa si falla El APK se rechaza apksigner responde DOES NOT VERIFY; la plataforma no lo mira al verificar la firma
Presencia en el muestrario Ver la tabla siguiente Ver la tabla siguiente

La tabla siguiente separa los grupos, que no se suman (F-Droid e IzzyOnDroid comparten ficheros). «Apps» es la pieza base de cada app; las piezas con bloque v2 o v3 se cuentan por pieza, porque cada split lleva su firma (en F-Droid, IzzyOnDroid y el mercado chino hay una pieza por app):

Grupo Piezas con bloque v2 o v3 Apps solo con v1 (sin bloque) Apps con sello en la base
F-Droid 4.367 de 4.766 (92 %) 399 de 4.766 (8 %) 0 de 4.766
IzzyOnDroid 1.386 de 1.402 (99 %) 16 de 1.402 (1 %) 6 de 1.402 (0,4 %)
Google Play, más instaladas 7.889 de 7.893 (más del 99 %) 4 de 658 (1 %) 518 de 658 (79 %)
Google Play, muestra al azar 1.272 de 1.272 0 de 369 324 de 369 (88 %)
Mercado chino 99 de 100 1 de 100 0 de 100
Webs de los autores 7 de 7 0 de 7 0 de 7

Los 399 de F-Droid que solo llevan v1 apuntan todos a una versión de Android anterior a la 11. Ninguna app que apunte a la 11 o a una posterior llega sin v2 o v3, en ningún grupo. No hay ninguna app sin firma alguna. No hemos probado en un dispositivo que un APK con solo v1 y targetSdkVersion menor que 30 se instale. Ejemplos de solo v1: pro.rudloff.lineageos_updater_shortcut versión 2 (12.599 bytes) y tk.al54.dev.badpixels versión 4 (13.949 bytes), ambas de F-Droid.

Esa fila no es la misma para apksigner y para el dispositivo. apksig cuenta un sello con errores como error del APK. En android-17.0.0_r1, en cambio, ApkSignatureVerifier no mira el par 0x6dff800d, y SourceStampVerifier, la clase de la plataforma que sí lo verifica, no lanza excepciones: devuelve un SourceStampVerificationResult —no presente, no verificado o verificado—, y un error al leer el APK cuenta como sello ausente, «without affecting the outcome of any of the other signature schemes» (SourceStampVerifier.java, líneas 95-162). No hemos encontrado ninguna llamada a SourceStampVerifier en ParsingPackageUtils.java, PackageInstallerSession.java, InstallPackageHelper.java ni PackageManagerService.java de esa etiqueta.

No hemos visto ningún APK cuyo sello falle, así que lo que dice la tabla sobre el rechazo sale del código, no de un ejemplo. apksigner pudo evaluar el sello del 98,6 % de las piezas que lo llevan y verifica en todas. Las otras 127 no se evaluaron por otra causa: 34 usan v3.2 y necesitan un Java con ML-DSA (con Java 25 verifican las 34), y 93 son splits de 6 apps de Google Play sin minSdkVersion, a los que apksigner exige la firma v1 que no llevan. No son firmas malas.

Todas las piezas con source stamp llevan el mismo certificado, el de Google (SHA-256 3257d599…bd6d, RSA de 4.096 bits). Lo pone Google Play en las apps partidas: lo llevan prácticamente todas sus piezas, la base incluida, sean de arquitectura, de idioma, de densidad o asset packs. En las apps de un solo APK es otra historia: entre las más instaladas lo lleva solo un tercio, y en la muestra al azar, una de cada diez.

Y no es que bundletool lo añada por defecto (solo lo hace con --create-stamp, que vale false si no se indica). Lo pidió quien generó esos splits, que aquí es Google Play («sección 6 de Artefactos auxiliares · Otros artefactos que aparecen en APK reales»). Fuera de Google Play solo hay 6 piezas con sello, todas de IzzyOnDroid. Un source stamp presente indica que el APK lo firmó Google Play; no prueba que se descargara de allí. Su ausencia en una app de un solo APK es normal; en la base de una app partida es rara: entre las más instaladas solo falta en una, com.heytap.themestore. Ejemplos:

  • com.heytap.themestore 17.16.0 (base.apk): app partida de las más instaladas sin sello en ninguna pieza (la base y 4 módulos); tampoco lleva frosting.
  • com.noprestige.kanaquiz (base.apk, 2.853.784 bytes): app de un solo APK sin sello, con frosting. Es la ausencia normal.
  • com.github.shingyx.boomswitch 14 (IzzyOnDroid; 2.655.472 bytes): pieza con el sello de Google fuera de Play.

El sello no es la única marca de origen de Google Play. La otra es el frosting (par 0x2146444e), que solo va en la base y nunca en un split. Es casi exclusivo de Google Play: lo llevan tres de cada cuatro apps de las más instaladas y casi todas las de la muestra al azar. Aquí medimos si el par está; su contenido solo lo decodificamos en 493 bases. En las apps de un solo APK las dos marcas se complementan: las 45 de la muestra al azar que no llevan sello llevan frosting. La tabla muestra las bases de cada grupo:

Grupo Sello y frosting Solo frosting Solo sello Ninguno
Más instaladas de Google Play (658 apps) 460 41 58 99
Muestra al azar de Google Play (369 apps) 323 45 1 0

Cuadra con la tabla anterior: las 140 apps de las más instaladas sin sello en la base (658 − 518) son las 41 de solo frosting más las 99 sin ninguna marca.

Entre las más instaladas, el frosting va en la base del 98 % de las apps partidas y solo del 27 % de las de un solo APK. Ninguna de las dos marcas prueba por sí sola que el APK salió de Play; las dos juntas son la pista más fuerte.

9. Keystores

Crear, listar y exportar un keystore, JKS o PKCS#12 (RFC 7292), está en la «sección 4 de Firma y empaquetado · keytool». Lo único que importa aquí es la contraseña: en un JKS cada clave puede tener la suya, distinta de la del almacén, y por eso apksigner separa --ks-pass de --key-pass; keytool avisa de que JKS es un formato propietario al crearlo («sección 10.1 · Crear un keystore de prueba»).

9.1 El debug keystore

~/.android/debug.keystore usa valores públicos —contraseña android y alias androiddebugkey—, así que no sirve para distribuir: cualquiera que tenga el fichero firma actualizaciones, y la mayoría de las tiendas, Google Play incluida, no aceptan lo firmado con él. El detalle está en la «sección 4.4 de Firma y empaquetado · El debug keystore».

Aun así hay APK en circulación firmados con ella. Llevan el certificado de depuración (CN=Android Debug, O=Android, C=US) 7 apps de F-Droid y 1 de las más instaladas de Google Play, que se descargó de un espejo. Sus certificados duran 30 años. Una app del mercado chino lleva la clave de depuración en v1 y v2 y otra clave en v3, con un lineage de dos eslabones; no la contamos con las anteriores porque aquí se mira el firmante del bloque de versión mayor. Fíjate en que lo que las tiendas no aceptan es subir una aplicación firmada así, no que exista. Que una de Google Play se haya descargado de un espejo no prueba que Play la acepte, y no sabemos si las 7 de F-Droid son compilaciones de F-Droid o del autor. Ejemplos:

  • com.icesu.kinnaid 567 (F-Droid; 4.590.711 bytes) y hev.sockstun 12 (F-Droid; 5.943.999 bytes): firmadas con la clave de depuración.
  • com.amanotes.beathopper 8.18.1 (base.apk, Google Play; 65.695.571 bytes): ídem; llegó de APKMirror.
  • com.pingan.carowner 4480 (mercado chino; 243.154.702 bytes): v1 y v2 con la clave de depuración y v3 con la de la empresa.

10. Recetas

Herramientas: apksigner 0.9 y zipalign de build-tools 37.0.0, keytool de OpenJDK 21.0.10, xxd y python3 3.12. Ejecutado el 31 de octubre de 2026. Todo sobre copias en el scratchpad; el muestrario se lee y no se toca (se describe en «El muestrario»). Para el uso general de estas herramientas, ver «Firma y empaquetado».

10.1 Crear un keystore de prueba

SCR=/tmp/scratch/firma
keytool -genkeypair -v -keystore $SCR/pruebas.jks -storetype JKS -alias pruebas \
  -keyalg RSA -keysize 2048 -validity 10000 \
  -storepass pruebas -keypass pruebas \
  -dname "CN=Ejemplo Test, OU=Doc, O=Ejemplo, L=Madrid, ST=Madrid, C=ES"
Generando par de claves RSA de 2.048 bits para certificado autofirmado (SHA384withRSA) con
una validez de 10.000 días
	para: CN=Ejemplo Test, OU=Doc, O=Ejemplo, L=Madrid, ST=Madrid, C=ES
[Almacenando /tmp/scratch/firma/pruebas.jks]

Warning:
El almacén de claves JKS utiliza un formato propietario. Se recomienda migrar a PKCS12, que
es un formato estándar del sector que utiliza "keytool -importkeystore -srckeystore
pruebas.jks -destkeystore pruebas.jks -deststoretype pkcs12".

Con -storetype PKCS12 no aparece el aviso y -keypass sobra. Los 10.000 días de validez llevan el certificado hasta 2053, muy por encima del umbral de Play. keytool sale en el idioma del sistema; aquí, en español.

10.2 Firmar una copia y verificarla

MUESTRARIO=/ruta/al/muestrario     # ajustar a donde esté el muestrario
shasum -a 256 "$MUESTRARIO/fdroid/org.fossify.math_10.apk"
# 7c5443c22d6d62c67dfe80df33ea9161ff0fa440f92590bcb45d7008b57613ed
cp "$MUESTRARIO/fdroid/org.fossify.math_10.apk" $SCR/copia.apk
$BT/apksigner sign --ks $SCR/pruebas.jks --ks-key-alias pruebas \
  --ks-pass pass:pruebas --key-pass pass:pruebas \
  --v4-signing-enabled true --out $SCR/firmado.apk $SCR/copia.apk
ls -la $SCR/firmado.apk*
$BT/apksigner verify --verbose --print-certs $SCR/firmado.apk | head -12
-rw-r--r--@ 1 jj  staff  7176566 31 oct. 03:19 firmado.apk
-rw-r--r--@ 1 jj  staff    62992 31 oct. 03:19 firmado.apk.idsig

Verifies
Verified using v1 scheme (JAR signing): false
Verified using v2 scheme (APK Signature Scheme v2): true
Verified using v3 scheme (APK Signature Scheme v3): true
…v3.1 y v3.2: false…
Verified using v4 scheme (APK Signature Scheme v4): false
Verified for SourceStamp: false
Number of signers: 1
V3.0 Signer: certificate DN: CN=Ejemplo Test, OU=Doc, O=Ejemplo, L=Madrid, ST=Madrid, C=ES
V3.0 Signer: certificate SHA-256 digest: dd8c2894783af5be81453c842618708cdc8b2ea9c071d5fd09776ee572e01a9f

La entrada es org.fossify.math versión 10, de F-Droid (7.047.681 bytes; solo bloque v2, minSdkVersion 26, targetSdkVersion 36). En la salida de verify cambia solo la huella. Esa huella, la raíz y los digests son del certificado de laboratorio de esa ejecución: cada vez que la repitas saldrán otros. apksigner añade además la firma v1 y el bloque v3 («sección 10.5 · Por qué el APK firmado pesa más»).

--v4-signing-enabled true es el valor por defecto: sin la opción, el .idsig sale igual. Escribirla solo cambia qué pasa si falla la firma v4: con ella, el error detiene la firma; sin ella, se ignora en silencio (ApkSignerTool.java, líneas 149, 204-206 y 480).

v4: false con el .idsig recién generado al lado. No es un fallo: apksigner no busca el fichero por convención de nombre, hay que dárselo:

$BT/apksigner verify --verbose --v4-signature-file $SCR/firmado.apk.idsig $SCR/firmado.apk \
  | sed -n '1p;7p'
Verifies
Verified using v4 scheme (APK Signature Scheme v4): true

Es el error de diagnóstico más frecuente con v4: concluir que la firma no se generó cuando lo que falta es el argumento.

10.3 Leer el .idsig

El volcado hexadecimal está descompuesto campo a campo en la «sección 2.3 · Un .idsig real, campo a campo». El recorrido programático son quince líneas:

python3 - <<'PY'
import struct
b = open("/tmp/scratch/firma/firmado.apk.idsig", "rb").read()
p = 0
ver, = struct.unpack_from("<I", b, p); p += 4
hl,  = struct.unpack_from("<I", b, p); p += 4
hi = b[p:p+hl]; p += hl
sl,  = struct.unpack_from("<I", b, p); p += 4 + sl
tl,  = struct.unpack_from("<I", b, p); p += 4
salt, = struct.unpack_from("<I", hi, 5)
rl,   = struct.unpack_from("<I", hi, 9 + salt)
print("version", ver, "hashingInfo", hl, "signingInfos", sl, "verityTree", tl)
print("hashAlgorithm", struct.unpack_from("<I", hi, 0)[0], "log2BlockSize", hi[4],
      "bloque", 2**hi[4], "salt", salt)
print("rawRootHash", hi[13+salt:13+salt+rl].hex())
print("offset del arbol", p, "bytes restantes", len(b) - p)
PY
version 2 hashingInfo 45 signingInfos 1491 verityTree 61440
hashAlgorithm 1 log2BlockSize 12 bloque 4096 salt 0
rawRootHash bafd1c25f31719954b46868bc7884bbe06d5dfb030269ea329f86d2b386993c6
offset del arbol 1552 bytes restantes 61440

Los 61.440 bytes del árbol son los que predice el cálculo de la «sección 3.2 · El tamaño del árbol, comprobado».

10.4 Comprobar que la firma detecta un cambio de un solo byte

cp $SCR/firmado.apk $SCR/tocado.apk
python3 -c "
b = bytearray(open('/tmp/scratch/firma/tocado.apk','rb').read())
b[1000000] ^= 0x01
open('/tmp/scratch/firma/tocado.apk','wb').write(b)"
$BT/apksigner verify --verbose $SCR/tocado.apk
DOES NOT VERIFY
ERROR: APK Signature Scheme v3 signer #1: APK integrity check failed. CHUNKED_SHA256 digest
mismatch. Expected: <40209ec8c81f2cee21dfaa9aaf357e262dbde382c1d929569ee5fb877ad145c4>,
actual: <94a6f907d91d92d0b590ee4e36da154facc98e955d0ddc89c8fe6af80ad1e0f1>

Basta un bit invertido en un byte perdido en medio del fichero (el 1.000.000, dentro de las entradas del ZIP, no en la cabecera). Fíjate en el Expected: es el mismo valor que el apkDigest del .idsig de la «sección 10.3 · Leer el .idsig», el anclaje de la «sección 4 · v4 no se sostiene sola». Este digest y el actual cambian con la clave, porque apksigner añade la firma v1 (META-INF/PRUEBAS.SF, .RSA y MANIFEST.MF) y esos ficheros entran en el contenido que se digiere.

10.5 Por qué el APK firmado pesa más

El APK firmado pesa 128.885 bytes más que el original (7.176.566 frente a 7.047.681). Y no es por la alineación, como cabría pensar. Casi todo es la firma v1 (META-INF/MANIFEST.MF, PRUEBAS.SF y PRUEBAS.RSA), que apksigner añadió aunque minSdkVersion sea 26. Las tres entradas, ya comprimidas, suman 125.835 bytes (MANIFEST.MF 60.703, PRUEBAS.SF 64.040 y PRUEBAS.RSA 1.092) y sus cabeceras locales, 149 más. El Central Directory crece 197 bytes por las tres entradas nuevas (115.040 frente a 114.843; de 1.584 a 1.587 entradas) y el resto, 2.704 bytes, sale por diferencia: relleno de alineación en los campos extra de las entradas. El APK Signing Block mide 4.096 bytes antes y después. La cuenta sale de unzip -lv sobre copia.apk y firmado.apk y de leer el EOCD con python3 -I y struct; con otra clave los tamaños de PRUEBAS.RSA cambian unos bytes. Con un alias de más de 8 caracteres apksigner corta el nombre del .SF.

10.6 Comprobar que un APK descargado es auténtico

El método compara la huella del certificado con una referencia que no viene del propio APK: la de la versión que ya tienes instalada, la que publica el autor o la de otra tienda.

  1. Calcula el SHA-256 del fichero (shasum -a 256 fichero.apk) y compáralo con el que publique la tienda.
  2. Saca la huella del firmante: apksigner verify --print-certs fichero.apk | grep 'SHA-256'.
  3. Compárala con la de la versión que ya tienes instalada o con la que publica el autor. Si coincide, la actualización es de la misma clave.
  4. No compares el CN. Hay 338 certificados distintos con el mismo nombre de Google (CN=Android, OU=Android, O=Google Inc.), y 261 de los 6.431 certificados distintos del muestrario firman varios paquetes.

Ejemplo real: org.fossify.math 10 y org.fossify.clock 10, ambos de F-Droid, dan la misma huella de firmante, affdb124d3f4720c2f98dbca9eacba0514fba4306e20a2786c861c3c0d6ff292, la de Fossify, que firma 17 paquetes distintos. Esa huella es la del APK original; la del firmado de las recetas es otra, de laboratorio.

Fuentes

  1. APK signature scheme v4 — Android Open Source Project — https://source.android.com/docs/security/features/apksigning/v4 Consultado el 12 de agosto de 2026. De aquí salen la descripción del esquema, la estructura del .idsig de la «sección 2.2 · Estructura» con sus citas literales sobre versión, algoritmo, tamaño de bloque y sal, la exigencia «A v4 signature requires a complementary v2 or v3 signature» de la «sección 4 · v4 no se sostiene sola» y la relación exacta con fs-verity de la «sección 3.3 · Qué comparte con fs-verity y qué no».
  2. AOSP — tools/apksig/.../internal/apk/v4/V4Signature.java — https://android.googlesource.com/platform/tools/apksig/+/refs/tags/android-17.0.0_r1/src/main/java/com/android/apksig/internal/apk/v4/V4Signature.java Consultado el 25 de septiembre de 2026. De aquí salen las tablas de campos de la «sección 2.2 · Estructura»: CURRENT_VERSION, HASHING_ALGORITHM_SHA256, LOG2_BLOCK_SIZE_4096_BYTES, MAX_SIGNING_INFOS_SIZE y el orden exacto de los campos de HashingInfo y SigningInfo. Consultado de nuevo el 18 de octubre: readBytes devuelve null ante un EOFException (líneas 270-279), de la «sección 5.4 · Un .idsig que no corresponde: apksigner lo ignora, el instalador no», y MAX_SIGNING_INFOS_SIZE limita lo que se escribe (178-181), de la «sección 2.2 · Estructura».
  3. AOSP — tools/apksig/.../internal/apk/v4/V4SchemeSigner.java — https://android.googlesource.com/platform/tools/apksig/+/refs/tags/android-17.0.0_r1/src/main/java/com/android/apksig/internal/apk/v4/V4SchemeSigner.java Consultado el 25 de septiembre de 2026. De aquí salen el comentario sobre el árbol como campo opcional con prefijo de longitud, la elección del apkDigest entre v3 y v2 de la «sección 4 · v4 no se sostiene sola» y el comentario «Salt has to stay empty for fs-verity compatibility». Consultado de nuevo el 18 de octubre para el bloque 0x1b93ad61 que generateSignature añade con firmante v3.1, de la «sección 4 · v4 no se sostiene sola» (líneas 217-237).
  4. AOSP — tools/apksig/.../internal/apk/v4/V4SchemeVerifier.java — https://android.googlesource.com/platform/tools/apksig/+/refs/tags/android-17.0.0_r1/src/main/java/com/android/apksig/internal/apk/v4/V4SchemeVerifier.java Consultado el 25 de septiembre de 2026. De aquí sale el mecanismo de la «sección 5.4 · Un .idsig que no corresponde: apksigner lo ignora, el instalador no»: el error se apunta en el firmante v4 y no en el resultado. Consultado de nuevo el 18 de octubre para la lectura del árbol con readBytes (línea 74) y su comparación, que se salta si es null, y la de la raíz (247-263), de la tabla de la «sección 5.4 · Un .idsig que no corresponde: apksigner lo ignora, el instalador no».
  5. AOSP — tools/apksig/.../internal/util/VerityTreeBuilder.java — https://android.googlesource.com/platform/tools/apksig/+/refs/tags/android-17.0.0_r1/src/main/java/com/android/apksig/internal/util/VerityTreeBuilder.java Consultado el 25 de septiembre de 2026. De aquí salen CHUNK_SIZE = 4096, el algoritmo calculateLevelOffset con su redondeo a 4096 de la «sección 3.2 · El tamaño del árbol, comprobado», la exigencia de alineación de generateVerityTreeRootHash y el comentario sobre la regeneración del árbol en el dispositivo.
  6. AOSP — tools/apksig/.../ApkVerifier.java — https://android.googlesource.com/platform/tools/apksig/+/refs/tags/android-17.0.0_r1/src/main/java/com/android/apksig/ApkVerifier.java Consultado el 25 de septiembre de 2026. De aquí sale íntegro el flujo de la «sección 5.1 · El flujo», con las condiciones exactas de cada esquema, los comentarios citados en 5.2, la comprobación de coincidencia entre firmantes v1 y v2, la de targetSandboxVersion y la búsqueda de la entrada stamp-cert-sha256. Consultado de nuevo el 18 de octubre para las líneas de la regla 5 de la «sección 5.2 · Las reglas, en orden» (450-494).
  7. AOSP — tools/apksig/.../internal/apk/stamp/SourceStampConstants.java — https://android.googlesource.com/platform/tools/apksig/+/refs/tags/android-17.0.0_r1/src/main/java/com/android/apksig/internal/apk/stamp/SourceStampConstants.java Consultado el 25 de septiembre de 2026. De aquí salen el nombre de la entrada stamp-cert-sha256, el identificador 0x6dff800d y la descripción del atributo de marca de tiempo 0xe43c5946 de la «sección 8 · El source stamp».
  8. fs-verity — documentación del kernel de Linux — https://docs.kernel.org/filesystems/fsverity.html Consultado el 12 de agosto de 2026. De aquí salen la definición de fs-verity, la construcción del árbol de Merkle citada en la «sección 3.1 · Cómo se construye», el relleno con ceros del último bloque, el tratamiento de la sal y la observación de que el digest se calcula sobre el fsverity_descriptor y no sobre la raíz sola.
  9. apksigner — Android Studio — https://developer.android.com/tools/apksigner Consultado el 12 de agosto y el 18 de octubre de 2026; la página sigue con fecha del 5 de marzo. De aquí salen las opciones --v4-signing-enabled, --ks-pass y --key-pass de las secciones «9» y «10». --v4-signature-file no está en la página («sección 5.4 · Un .idsig que no corresponde: apksigner lo ignora, el instalador no»).
  10. Sign your app — Android Studio — https://developer.android.com/studio/publish/app-signing Consultado el 12 de agosto de 2026. De aquí salen el requisito de validez hasta después del 22 de octubre de 2033 de la «sección 6 · Cadenas de certificados: qué se verifica y qué no», y la ruta del debug keystore y el rechazo de las tiendas de la «sección 9.1 · El debug keystore».
  11. Client authentication — Google Play services — https://developers.google.com/android/guides/client-auth Consultado el 12 de agosto de 2026. De aquí salen la contraseña android y el alias androiddebugkey del debug keystore de la «sección 9.1 · El debug keystore». Se usa esta fuente porque la página de firma de aplicaciones no publica la contraseña.
  12. AOSP — frameworks/base/core/java/android/util/apk/ApkSignatureVerifier.java y ApkSignatureSchemeV3Verifier.java en la etiqueta android-17.0.0_r1 — https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/core/java/android/util/apk/ApkSignatureVerifier.java Consultado el 25 de septiembre de 2026. De aquí sale el orden de verificación que aplica la plataforma (verifySignaturesInternal, verifyV3AndBelowSignatures y, dentro de v3, el de ApkSignatureSchemeV3Verifier.verify) de la «sección 5 · El algoritmo completo de verificación». El 18 de octubre se comprobaron la elección del firmante v3 por Build.VERSION.SDK_INT (ApkSignatureSchemeV3Verifier.java, líneas 357-397 y 593-612) y que, si v2 verifica, la plataforma no llegue a v1 (ApkSignatureVerifier.java, líneas 198-240).
  13. AOSP — packages/modules/adb/client/incremental_server.cpp en la etiqueta android-17.0.0_r1 — https://android.googlesource.com/platform/packages/modules/adb/+/refs/tags/android-17.0.0_r1/client/incremental_server.cpp Consultado el 25 de septiembre de 2026 en android-16.0.0_r1 y el 18 de octubre en android-17.0.0_r1. De aquí sale que adb envía al dispositivo los bloques del árbol leídos del .idsig (SendTreeBlock, línea 243, y open_signature, líneas 680-705) de la «sección 3.3 · Qué comparte con fs-verity y qué no».
  14. BuildApksCommand.java de bundletool 1.18.3 — https://github.com/google/bundletool/blob/1.18.3/src/main/java/com/android/tools/build/bundletool/commands/BuildApksCommand.java Consultado el 25 de septiembre de 2026. De aquí sale que --create-stamp vale false por defecto (populateSourceStampFromFlags), de la «sección 8 · El source stamp».
  15. AOSP — tools/apksig/.../ApkVerifier.java en la etiqueta android-17.0.0_r1 — https://android.googlesource.com/platform/tools/apksig/+/refs/tags/android-17.0.0_r1/src/main/java/com/android/apksig/ApkVerifier.java Consultado el 25 de septiembre de 2026. De aquí sale que un source stamp con errores hace que containsErrors() devuelva true, y con ello DOES NOT VERIFY, de la «sección 8 · El source stamp».
  16. APK Signature Scheme v3.2 — Android Open Source Project — https://source.android.com/docs/security/features/apksigning/v3-2 Consultado el 25 de septiembre de 2026. De aquí sale la recomendación de conceder ROLLBACK durante el despliegue de la firma híbrida, de la «sección 7 · Leer un lineage de rotación».
  17. AOSP — frameworks/base, ApkSignatureVerifier.java, ApkSignatureSchemeV4Verifier.java y core/java/android/os/incremental/V4Signature.java, etiqueta android-17.0.0_r1 — https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/core/java/android/util/apk/ApkSignatureVerifier.java Consultado el 25 de septiembre de 2026, con PackageInstallerSession.java y ParsingPackageUtils.java de la misma etiqueta. De aquí sale qué hace el instalador con un .idsig que no corresponde («sección 5.4 · Un .idsig que no corresponde: apksigner lo ignora, el instalador no»). Consultado de nuevo el 18 de octubre, con ApkSignatureSchemeV3Verifier.java y ApkSignatureSchemeV2Verifier.java del mismo directorio: de ahí salen la «sección 5.5 · Con .idsig, la integridad la pone el árbol» (ApkSignatureVerifier.java, líneas 83-96, 250-347, 268-299 y 307-332; ApkSignatureSchemeV3Verifier.java, 120-123 y 319-321; ApkSignatureSchemeV2Verifier.java, 129-133 y 215-217; ApkSignatureSchemeV4Verifier.java, 140-157), la elección del bloque del .idsig por v3BlockId de la «sección 4 · v4 no se sostiene sola» (ApkSignatureSchemeV4Verifier.java, 160-179) y el presupuesto conjunto de 8096 bytes de la «sección 2.2 · Estructura» (V4Signature.readFrom, en core/java/android/os/incremental/V4Signature.java, 260-269 y 306-319).
  18. Emulador Android 14 arm64-v8a — adb install --incremental con el .idsig de otro APK y con uno truncado, el 25 de septiembre de 2026. De aquí salen los dos fallos reproducidos de la «sección 5.4 · Un .idsig que no corresponde: apksigner lo ignora, el instalador no».
  19. AOSP — apksigner en la etiqueta android-17.0.0_r1 — https://android.googlesource.com/platform/tools/apksig/+/refs/tags/android-17.0.0_r1/src/apksigner/java/com/android/apksigner/ApkSignerTool.java, con src/main/java/com/android/apksig/ApkSigner.java y DefaultApkSignerEngine.java del mismo repositorio, y apksigner verify -h de build-tools 37.0.0, ejecutado. Consultado y ejecutado el 18 de octubre de 2026. De aquí salen que --v4-signature-file solo esté en el código (ApkSignerTool.java, línea 620) de la «sección 5.4 · Un .idsig que no corresponde: apksigner lo ignora, el instalador no», y el valor por defecto de --v4-signing-enabled de la «sección 10.2 · Firmar una copia y verificarla»: true (ApkSignerTool.java, línea 149), con los fallos ignorados salvo que la opción se escriba (línea 480; ApkSigner.java, líneas 684-685; DefaultApkSignerEngine.java, líneas 1355-1371).
  20. AOSP — SourceStampVerifier.java y SourceStampVerificationResult.java en android-17.0.0_r1 — https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/core/java/android/util/apk/SourceStampVerifier.java Consultado el 18 de octubre de 2026, con ApkSignatureVerifier.java, ParsingPackageUtils.java, PackageInstallerSession.java, InstallPackageHelper.java y PackageManagerService.java de la misma etiqueta. De aquí sale lo que hace la plataforma con un source stamp que no verifica, de la «sección 8 · El source stamp».
  21. AOSP — core/java/android/content/pm/flags.aconfig en android-17.0.0_r1 — https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/core/java/android/content/pm/flags.aconfig Consultado el 18 de octubre de 2026. De aquí sale el flag always_load_past_certs_v4 de la «sección 5.5 · Con .idsig, la integridad la pone el árbol» (líneas 274-281), «Always read the corresponding v3/3.1 signature block for the current v4 to get the past rotated certificates, even when not verifying integrity».
  22. apksigner 0.9 de build-tools 37.0.0 y python3 — ejecutados el 18 de octubre de 2026 sobre el APK de prueba de la «sección 9 de APK Signing Block · El volcador», firmado con rotación a partir de la API 33. De aquí sale el .idsig con dos signingInfo de la «sección 4 · v4 no se sostiene sola», leído campo a campo.
  23. Muestrario de APK de octubre de 2026 — descargado entre el 19 y el 27 de octubre de 2026; descrito en «El muestrario». De aquí salen las cifras de las secciones «1», «2.1», «3.2», «4», «5», «6», «7», «8» y «9».
  24. apksigner 0.9 y zipalign de build-tools 37.0.0, keytool de OpenJDK 21.0.10 y python3 3.12 — ejecutados el 31 de octubre de 2026 sobre una copia de org.fossify.math versión 10, con una clave de laboratorio de un solo uso. De aquí salen los tamaños, la raíz, los digests y las huellas de las secciones «2.3», «3.2», «5.4» y «10».