Firma v4, verificación y keystores
Antes conviene leer «Esquemas de firma v1, v2 y v3» · «APK Signing Block»
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: unbase.apkde 149.778.360 bytes, de un juego grande.com.king.farmheroessaga(6.99.15): unbase.apkde 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 sugetSignedData, 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».
apksignerno la usa: el.idsiggenerado aquí declarasalt length = 0, y el comentario deV4SchemeSignerexplica 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
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_verificationversión 4 (IzzyOnDroid; 10.750 bytes): anomalía del lector deZIP, yapksignerverifica.com.martinmimigames.tinymusicplayerversión 4 (F-Droid e IzzyOnDroid; 16.520 bytes): ídem.- Magisk 31000,
com.topjohnwu.magisk(IzzyOnDroid; 11.606.088 bytes): comentario delEOCDno 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.gamemanager80506001 (41.648.903 bytes) ycom.ifeng.newvideo73440 (47.696.655 bytes): bloque de canal en elAPK Signing Block.com.suning.mobile.ebuy596 (135.494.589 bytes): el canal va como ficheroMETA-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
.apkmllevan una firma de JAR propia de APKMirror (META-INF/MANIFEST.MF,APKMIRRO.SFyAPKMIRRO.RSA, másinfo.json,icon.pngyAPKM_installer.url). Cubre el contenedor, no las piezas, y no la hemos verificado. - Los 72
.xapkno llevan firma propia: llevanmanifest.json(uno trae ademásAPKComboInstaller.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.imageresizershrinker251: F-Droid e IzzyOnDroid, mismo certificado (20d7689d…) en ficheros distintos.com.bugsdev2.bookaccio400: F-Droid e IzzyOnDroid, otro certificado (90aa662b…frente aba2fdd5e…).- Firefox 158 (
org.mozilla.firefox): la web de Mozilla y Google Play, mismo certificado (a78b62a5…). org.videolan.vlc13070206: 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:
- Una entrada del
ZIPllamadastamp-cert-sha256, en la raíz, con 32 bytes: el SHA-256 del certificado del sello. - Un par
0x6dff800den elAPK 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.themestore17.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 soloAPKsin sello, con frosting. Es la ausencia normal.com.github.shingyx.boomswitch14 (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.kinnaid567 (F-Droid; 4.590.711 bytes) yhev.sockstun12 (F-Droid; 5.943.999 bytes): firmadas con la clave de depuración.com.amanotes.beathopper8.18.1 (base.apk, Google Play; 65.695.571 bytes): ídem; llegó de APKMirror.com.pingan.carowner4480 (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.
- Calcula el SHA-256 del fichero (
shasum -a 256 fichero.apk) y compáralo con el que publique la tienda. - Saca la huella del firmante:
apksigner verify --print-certs fichero.apk | grep 'SHA-256'. - 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.
- 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
- 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
.idsigde 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». - 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_SIZEy el orden exacto de los campos deHashingInfoySigningInfo. Consultado de nuevo el 18 de octubre:readBytesdevuelvenullante unEOFException(líneas 270-279), de la «sección 5.4 · Un .idsig que no corresponde: apksigner lo ignora, el instalador no», yMAX_SIGNING_INFOS_SIZElimita lo que se escribe (178-181), de la «sección 2.2 · Estructura». - 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 delapkDigestentre 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 bloque0x1b93ad61quegenerateSignatureañade con firmante v3.1, de la «sección 4 · v4 no se sostiene sola» (líneas 217-237). - 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 conreadBytes(línea 74) y su comparación, que se salta si esnull, 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». - 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í salenCHUNK_SIZE = 4096, el algoritmocalculateLevelOffsetcon su redondeo a 4096 de la «sección 3.2 · El tamaño del árbol, comprobado», la exigencia de alineación degenerateVerityTreeRootHashy el comentario sobre la regeneración del árbol en el dispositivo. - 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 detargetSandboxVersiony la búsqueda de la entradastamp-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). - 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 entradastamp-cert-sha256, el identificador0x6dff800dy la descripción del atributo de marca de tiempo0xe43c5946de la «sección 8 · El source stamp». - 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_descriptory no sobre la raíz sola. - 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-passy--key-passde las secciones «9» y «10».--v4-signature-fileno está en la página («sección 5.4 · Un .idsig que no corresponde: apksigner lo ignora, el instalador no»). - 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».
- 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
androidy el aliasandroiddebugkeydel 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. - AOSP —
frameworks/base/core/java/android/util/apk/ApkSignatureVerifier.javayApkSignatureSchemeV3Verifier.javaen la etiquetaandroid-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,verifyV3AndBelowSignaturesy, dentro de v3, el deApkSignatureSchemeV3Verifier.verify) de la «sección 5 · El algoritmo completo de verificación». El 18 de octubre se comprobaron la elección del firmante v3 porBuild.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). - AOSP —
packages/modules/adb/client/incremental_server.cppen la etiquetaandroid-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 enandroid-16.0.0_r1y el 18 de octubre enandroid-17.0.0_r1. De aquí sale queadbenvía al dispositivo los bloques del árbol leídos del.idsig(SendTreeBlock, línea 243, yopen_signature, líneas 680-705) de la «sección 3.3 · Qué comparte con fs-verity y qué no». BuildApksCommand.javadebundletool1.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-stampvalefalsepor defecto (populateSourceStampFromFlags), de la «sección 8 · El source stamp».- AOSP —
tools/apksig/.../ApkVerifier.javaen la etiquetaandroid-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 unsource stampcon errores hace quecontainsErrors()devuelvatrue, y con elloDOES NOT VERIFY, de la «sección 8 · El source stamp». - 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
ROLLBACKdurante el despliegue de la firma híbrida, de la «sección 7 · Leer un lineage de rotación». - AOSP —
frameworks/base,ApkSignatureVerifier.java,ApkSignatureSchemeV4Verifier.javaycore/java/android/os/incremental/V4Signature.java, etiquetaandroid-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, conPackageInstallerSession.javayParsingPackageUtils.javade la misma etiqueta. De aquí sale qué hace el instalador con un.idsigque no corresponde («sección 5.4 · Un .idsig que no corresponde: apksigner lo ignora, el instalador no»). Consultado de nuevo el 18 de octubre, conApkSignatureSchemeV3Verifier.javayApkSignatureSchemeV2Verifier.javadel 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.idsigporv3BlockIdde 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, encore/java/android/os/incremental/V4Signature.java, 260-269 y 306-319). - Emulador Android 14
arm64-v8a—adb install --incrementalcon el.idsigde otroAPKy 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». - AOSP —
apksigneren la etiquetaandroid-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, consrc/main/java/com/android/apksig/ApkSigner.javayDefaultApkSignerEngine.javadel mismo repositorio, yapksigner verify -hdebuild-tools37.0.0, ejecutado. Consultado y ejecutado el 18 de octubre de 2026. De aquí salen que--v4-signature-filesolo 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-enabledde 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). - AOSP —
SourceStampVerifier.javaySourceStampVerificationResult.javaenandroid-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, conApkSignatureVerifier.java,ParsingPackageUtils.java,PackageInstallerSession.java,InstallPackageHelper.javayPackageManagerService.javade la misma etiqueta. De aquí sale lo que hace la plataforma con unsource stampque no verifica, de la «sección 8 · El source stamp». - AOSP —
core/java/android/content/pm/flags.aconfigenandroid-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 flagalways_load_past_certs_v4de 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». apksigner0.9 debuild-tools37.0.0 ypython3— ejecutados el 18 de octubre de 2026 sobre elAPKde 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.idsigcon dossigningInfode la «sección 4 · v4 no se sostiene sola», leído campo a campo.- 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».
apksigner0.9 yzipaligndebuild-tools37.0.0,keytoolde OpenJDK 21.0.10 ypython33.12 — ejecutados el 31 de octubre de 2026 sobre una copia deorg.fossify.mathversió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».