El APK Signing Block

Antes conviene leer «Contenedor ZIP» · «Esquemas de firma v1, v2 y v3»

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

1. Qué es y por qué existe

En pocas palabras. El APK Signing Block es un bloque de bytes que Android guarda dentro del APK, justo antes del índice del ZIP. Contiene las firmas v2, v3, v3.1 y v3.2 y, a su lado, datos que añaden las herramientas y las tiendas. unzip no lo ve. Android sí lo busca.

Por qué está ahí. Un APK es un ZIP, y la firma v2 quiere proteger todos sus bytes. Si la firma fuese un fichero más dentro del ZIP, añadirla cambiaría el índice del ZIP (el Central Directory) y la firma ya no coincidiría con lo firmado. Si estuviese fuera del ZIP, los programas que leen ZIP no la encontrarían. Android usa un hueco: el final del ZIP (EOCD) dice en qué byte empieza el índice, así que los lectores saltan allí y nunca miran lo que hay justo antes. En ese hueco va el bloque.

La propiedad que lo hace posible: el EOCD apunta al Central Directory por offset absoluto, así que ningún lector de ZIP mira lo que hay entre el último dato y ese offset. Ahí va el APK Signing Block («glosario»): un contenedor propio de Android, autodescriptivo, extensible e invisible para unzip.

Acaba siendo mucho más que una firma. El formato es una secuencia de pares ID-valor y todo lector debe saltarse los identificadores que no conoce. Por eso las herramientas y las tiendas lo usan para dejar sus propios datos. Conviven en él las firmas v2, v3, v3.1 y v3.2, el source stamp que pone Google Play, los datos de dependencias que añade el Android Gradle Plugin, el frosting de Play, el relleno y los canales de distribución de las tiendas chinas. En el «muestrario» hemos visto 21 identificadores de par distintos. Nueve tienen nombre en la tabla de la «sección 4 · Identificadores de bloque conocidos» (el décimo de esa tabla, el sello v1, no aparece); los otros doce no los explica ninguna fuente pública que hayamos encontrado («sección 4 · Identificadores de bloque conocidos»).

Para hacerte una idea: entre las apps más instaladas de Google Play, nueve de cada diez con bloque llevan algo más que firmas y relleno. En F-Droid, en torno al 2 %. La «sección 10 · Censo real del muestrario» mide qué lleva cada fuente. Un ejemplo con todo junto es el base.apk de Google Keep (com.google.android.keep 5.26.411.03.97, el .apkm de APKMirror): v2, v3.1, v3, sello, frosting y relleno.

Este documento describe el contenedor y el algoritmo de digest. Qué garantiza cada esquema está en «Esquemas de firma v1, v2 y v3»; el orden de verificación, en «Firma v4 y verificación».

Endianness: todos los números de este documento se guardan en little-endian, igual que los del ZIP que los rodea: el byte menos significativo va primero. Por eso el ID 0x7109871a aparece en el fichero como 1a 87 09 71. La «sección 3.3 · Un bloque real, byte a byte» lo muestra con un bloque real.

2. Dónde vive

Entre el final de los datos de la última entrada y el inicio del Central Directory, tal y como describe la «sección 2 de Contenedor ZIP · Layout global». No se repite aquí el layout del ZIP; lo que importa es cómo se localiza el bloque, y siempre es de atrás hacia delante:

1. buscar el EOCD (firma 0x06054b50) desde el final del fichero
2. leer su campo de offset 0x10  →  offset absoluto del Central Directory  (cd_off)
3. mirar los 16 bytes en [cd_off - 16, cd_off)
      ¿son "APK Sig Block 42"?   no  → el APK no tiene APK Signing Block
                                 sí  → seguir
4. leer el uint64 en cd_off - 24  →  size_al_final
5. inicio_del_bloque = cd_off - 8 - size_al_final
6. leer el uint64 en inicio_del_bloque  →  size_al_principio
7. exigir size_al_principio == size_al_final

El paso 3 es el que da nombre al campo mágico. La especificación es explícita sobre para qué sirve: «The magic value provides a quick way to establish that what precedes Central Directory is likely the APK signing block». Likely, no certainly: los pasos 4 a 7 son los que confirman.

El paso 7 no es decorativo. Los dos campos de tamaño existen para poder recorrer el bloque en los dos sentidos. Si discrepan, o el fichero está manipulado o el EOCD elegido no es el bueno.

2.1 Cómo mirarlo

apksigner verify -v --print-certs app.apk dice quién firmó y qué esquemas comprobó. Ojo: no sirve para saber qué esquemas hay. Un «false» puede ser un esquema que falta o uno que apksigner no necesitaba comprobar para el minSdk de ese APK, y lo segundo es muy común: en el caso de v2, de cada cinco «false» unos cuatro son de piezas que sí traen el esquema.

Para ver qué hay en el bloque, par por par, usa el volcador de la «sección 9 · El volcador».

3. Layout byte a byte

                                                    ◄── crece hacia arriba
┌──────────────────────────────────────────────────────────┐  ← inicio_del_bloque
│ size of block          uint64   (excluye este campo)     │
├──────────────────────────────────────────────────────────┤
│ ┌──────────────────────────────────────────────────────┐ │
│ │ size of pair    uint64   (excluye este campo)        │ │
│ │ ID              uint32                               │ │  par 1
│ │ value           (size of pair − 4) bytes             │ │
│ └──────────────────────────────────────────────────────┘ │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ size / ID / value                                    │ │  par 2
│ └──────────────────────────────────────────────────────┘ │
│                          …                               │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ par de relleno  ID = 0x42726577  (opcional)          │ │
│ └──────────────────────────────────────────────────────┘ │
├──────────────────────────────────────────────────────────┤
│ size of block          uint64   (idéntico al de arriba)  │
├──────────────────────────────────────────────────────────┤
│ magic                  "APK Sig Block 42"   16 bytes     │
└──────────────────────────────────────────────────────────┘  ← cd_off
│ ZIP Central Directory                                     │

3.1 Campos del bloque

Campo Offset Tamaño Tipo Significado
size of block 0x00 8 uint64 Bytes desde el final de este campo hasta el final de la magic. Equivale a tamaño_total − 8
pairs 0x08 var — Secuencia de pares ID-valor, sin separador
size of block — 8 uint64 Repetición exacta del campo de 0x00
magic — 16 char[16] 41 50 4B 20 53 69 67 20 42 6C 6F 63 6B 20 34 32 = APK Sig Block 42

El tamaño total del bloque en el fichero es size of block + 8.

3.2 Campos de un par ID-valor

Campo Offset Tamaño Tipo Significado
size of pair 0x00 8 uint64 Bytes desde el final de este campo hasta el final del valor. Incluye los 4 del ID
ID 0x08 4 uint32 Identificador del bloque. Tabla en la «sección 4 · Identificadores de bloque conocidos»
value 0x0C var — size of pair − 4 bytes de contenido opaco

Los pares se encadenan sin relleno entre ellos: el siguiente empieza en offset_actual + 8 + size_of_pair. El recorrido termina cuando se alcanza el segundo campo de tamaño, es decir, cd_off − 24.

Un lector tiene que hacer tres comprobaciones en cada iteración para no entrar en un bucle infinito ni leer fuera de rango con un APK manipulado. Un size of pair menor que 4 es un fichero malformado. También lo es un par que se salga de cd_off − 24, y un resto de menos de 8 bytes, donde no cabe ni el campo de tamaño.

¿Pasa en la práctica? Casi nunca. En el muestrario no hay ningún bloque cuyos dos campos de tamaño discrepen, ni un par vacío o con size of pair menor que 4, ni un par que se salga del bloque, ni varios firmantes en v2, v3 o v3.1. Las únicas rarezas son un ID repetido en dos piezas, 4 bytes sobrantes tras el último par en una y un comentario en el EOCD en cuatro. apksigner verifica las siete.

  • El par v3.1 sale dos veces en la web de WhatsApp (com.whatsapp, WhatsApp.apk) y en Facebook Lite (com.facebook.lite 534.0.0.7.108, de APKMirror).
  • Sobran 4 bytes tras el último par en com.enclavd.app 2212 (F-Droid): no cabe ni un size of pair.
  • El comentario del EOCD mide 46 bytes en com.topjohnwu.magisk 30700 (F-Droid).

Un lector que se quede con el primer par de un ID repetido, como hace el volcador de la «sección 9 · El volcador», lee lo mismo que Android.

El orden de los pares no está fijado, pero en la práctica casi siempre es el mismo. apksig escribe en el orden en que se los pasan y ApkVerifier los busca por ID, no por posición. apksigner escribe v2, v3.1, v3.2, v3 y el sello en ese orden relativo (v3.2 va entre v3.1 y v3: en com.phasora sale v2 → v3.2 → v3). Lo cumplen prácticamente todas las piezas. Las excepciones son Facebook Lite (v3.1 repetido y 0xff3b5998 primero), la web de WhatsApp (v3.1 repetido) y tres piezas chinas, como com.dragon.read 74132, con v3 antes que v2.

Las herramientas que añaden datos después de firmar los dejan al final. La información de dependencias va siempre tras las firmas. El frosting de Play suele ir justo antes del relleno, y el relleno es el último par en casi todas las piezas. Cuando no lo es, alguien añadió un par después: el frosting (en APK que el autor ya había firmado con relleno) o un identificador de canal en piezas del mercado chino. Ejemplo del frosting tras el relleno: com.dsi.ant.service.socket 4.18.00 (APKMirror) lleva v2, dependency info, relleno y, después, un frosting de 169 bytes. Las secuencias más frecuentes son v2 → v3 → relleno en F-Droid y en el mercado chino, v2 → relleno en IzzyOnDroid y v2 → v3 → sello → relleno en Google Play.

3.3 Un bloque real, byte a byte

org.vi_server.red_screen versión 3, de F-Droid (17.562 bytes). El bloque ocupa 4.096 bytes y empieza en el offset 12.288. Se obtiene con python3 -I dump_sigblock.py («sección 9 · El volcador»).

offset 12288 (0x3000)  f8 0f 00 00 00 00 00 00   ← size of block = 0x0ff8 = 4088
                       f9 05 00 00 00 00 00 00   ← size of pair del par 1 = 0x05f9 = 1529
                       1a 87 09 71               ← ID = 0x7109871a (firma v2)
                       f1 05 00 00 ed 05 00 00 … ← secuencia de signers (1521 B), primer signer (1517 B) …
offset 13833           f9 05 00 00 00 00 00 00   ← size of pair del par 2 = 1529
                       c0 68 53 f0               ← ID = 0xf05368c0 (firma v3)
…
offset 16360 (0x3fe8)  f8 0f 00 00 00 00 00 00   ← size of block, repetido (cd_off − 24)
offset 16368 (0x3ff0)  41 50 4b 20 53 69 67 20 42 6c 6f 63 6b 20 34 32   ← "APK Sig Block 42"
offset 16384 (0x4000)  ← aquí empieza el Central Directory

El EOCD, en el offset 17.540, guarda ese 16.384 en su campo de offset (00 40 00 00). Antes del bloque hay 1.795 bytes de ceros (del 10.493 al 12.287). Los pares son v2 (1.525 bytes), v3 (1.525) y relleno (978). El relleno empieza por los bytes 77 65 72 42; leídos como número uint32 little-endian dan el ID 0x42726577, que en ASCII, de izquierda a derecha, es Brew («sección 8 · El bloque de relleno»).

4. Identificadores de bloque conocidos

Todos los valores de esta tabla se han verificado contra el código fuente indicado.

ID Nombre en apksig Fichero de origen Contenido
0x7109871a APK_SIGNATURE_SCHEME_V2_BLOCK_ID v2/V2SchemeConstants.java Firma v2
0xf05368c0 APK_SIGNATURE_SCHEME_V3_BLOCK_ID v3/V3SchemeConstants.java Firma v3
0x1b93ad61 APK_SIGNATURE_SCHEME_V31_BLOCK_ID v3/V3SchemeConstants.java Firma v3.1
0x70e1c89f APK_SIGNATURE_SCHEME_V32_BLOCK_ID v3/V3SchemeConstants.java, etiqueta android-17.0.0_r1 Firma v3.2, híbrida
0x2b09189e V1_SOURCE_STAMP_BLOCK_ID stamp/SourceStampConstants.java Source stamp v1 (obsoleto)
0x6dff800d V2_SOURCE_STAMP_BLOCK_ID stamp/SourceStampConstants.java Source stamp v2
0x42726577 VERITY_PADDING_BLOCK_ID ApkSigningBlockUtils.java Relleno de alineación («sección 8 · El bloque de relleno»)
0x504b4453 — No está en apksig Metadatos de dependencias de Google Play
0x2146444e — No está en apksig «Frosting» de Google Play («sección 11 · El “frosting” de Google Play: 0x2146444e»)
0x71777777 — No está en apksig Metadatos de Meituan (canal de distribución chino)

La tabla siguiente añade los identificadores que aparecen en el muestrario y no están en la anterior. Mira la última columna: dice dónde los hemos visto. Ninguno tiene fuente pública; el contenido se describe tal como se observa.

ID Contenido En el muestrario
0xfa1cfabe Bytes opacos: 41.938 B en las bases, 200 B en los splits. No se ha interpretado. 683 piezas de 58 apps de Google Play (35 de las más instaladas y 23 del sorteo), todas con PairIP
0x881155ff Canal de Tencent (texto o JSON corto), por ejemplo {"pn":"SLL","sf":0}, 301746, YingYongBao 7 piezas, todas del mercado chino
0x71717874, 0x71777775, 0x881155f0 Datos de canal de las tiendas chinas, sin documentar 17, 6 y 3 piezas, casi todas chinas
0xff3b5998 4.084 bytes a cero, como primer par 2 piezas de Google Play: Facebook Lite e Instagram Lite (APKMirror)
0x0134899c, 0x71777776, 0x12344321, 0x99666666, 0x7a786b21, 0x71777778 Sin documentar (0x7a786b21 contiene el texto «Packer Ng Sig V2» y un canal) 1 pieza china cada uno

El sello v1 (0x2b09189e) no aparece en ninguna pieza. 0xfa1cfabe solo aparece en apps de Google Play, también en sus splits, y siempre en apps con PairIP (el protector de Google Play). Es una asociación, no una identificación. Si verificas o reempaquetas un APK, trátalo como un par desconocido y sáltalo. Ejemplos:

  • 0xfa1cfabe de 41.938 B en una base: com.doctorslab.tech.logocreator.logomaker › base.apk. De 200 B en un split: no.vsp.senja › split_config.es.apk.
  • 0xff3b5998: Facebook Lite 534.0.0.7.108 (primer par, v3.1 repetido, frosting y relleno) e Instagram Lite 534.0.0.8.108, ambos de APKMirror.
  • 0x881155ff: com.mfw.roadbook 1148 (19 B: {"pn":"SLL","sf":0}) y com.wlwzb.gdt 100 (6 B: «301746», más 0x881155f0 de 10.240 B).
  • 0x71717874: com.tencent.tgclub 2026081227 (20 B tras v2).
  • Varios a la vez: com.luna.music 100213030 lleva v2, v3, relleno, Walle («{"meta_umeng_channel": "tengxun_8478_64"}»), 0x99666666 y 0x71777775.
  • 0x7a786b21: com.tianyancha.skyeye 160920 (43 B con «Packer Ng Sig V2» y el canal «sll360»).

v4 no tiene identificador de bloque. Vive en un fichero .idsig aparte, y por eso «Firma v4 y verificación» lo trata por separado. Tampoco lo tiene v1: sus artefactos son entradas del ZIP bajo META-INF/.

0x70e1c89f es el bloque de la firma v3.2 de Android 17, con MIN_SDK_WITH_V32_SUPPORT = AndroidSdkVersion.C, que vale 37. Lo documenta source.android.com («APK Signature Scheme v3.2») y está en la etiqueta android-17.0.0_r1 de apksig; no en la rama main, que se congeló en marzo de 2025. Su formato y sus dos firmantes, uno clásico y otro poscuántico, están en «Esquemas de firma → §7 · v3.2: la firma híbrida».

Ya se ve en APK reales, aunque pocos: 34 piezas de 9 apps del sorteo de Google Play (el 2 % de sus apps), todas sacadas con adb, y ninguna app de las demás fuentes. Las 9 apps son com.LiiKrass.BrawlBoxSimulator, com.astropeak.congklak, com.chatakmovie.app, com.clarkstudio.idl, com.coddykit.corruptstate, com.phasora, com.ragdollsurvival.forestnight, com.verato.securevpn y com.vexostudio.win786. Si una app lo lleva, lo llevan todas sus piezas, splits incluidos.

En las 34 piezas hay dos firmantes: uno RSA (0x0104) y uno ML-DSA (0x0501), válidos desde el SDK 37 (rango [37, 2147483647]), con lineage de flags 0x1f y 0x17. El par mide unos 24.700 bytes, el más grande del bloque. Se lee en las 34 sin errores. Ejemplos: el base.apk de com.phasora («sección 9 · El volcador», tercer volcado) y el split split_config.xxhdpi.apk de com.astropeak.congklak.

Ojo con el JDK: apksigner de build-tools 37.0.0 con Java 21 no verifica ninguna de estas piezas, porque no sabe leer la clave ML-DSA, que llegó al JDK en la versión 24. Con Java 25.0.5 verifican todas. Que el bloque solo salga en carpetas de adb lo hemos medido; por qué, no lo sabemos.

0x504b4453, 0x2146444e y 0x71777777 no son esquemas de firma de la plataforma: buscados en hexadecimal y en decimal en src/main de platform/tools/apksig en android-17.0.0_r1, no aparecen. 0x504b4453 lo añade el Android Gradle Plugin después de firmar: es DEPENDENCY_INFO_BLOCK_ID en signflinger/src/com/android/signflinger/SignedApk.java de platform/tools/base (líneas 57-58 y 254-256 en la etiqueta studio-2026.1.2), y lleva los datos de dependencias que, según la documentación de Android Studio, van «encrypted by a Google Play signing key». 0x71777777 es el APK_CHANNEL_BLOCK_ID de Walle, el empaquetador de canales de Meituan (payload_reader/.../ApkUtil.java, línea 40). 0x2146444e no tiene fuente primaria pública: el nombre de «frosting» de Google Play sale del enumerado BlockId de avast/apkverifier, con el que se han cotejado los tres valores. Los tres aparecen en APK reales («sección 10 · Censo real del muestrario»):

  • 0x504b4453 se ve sobre todo en IzzyOnDroid (casi tres de cada diez apps); en el resto de fuentes es mucho más raro.
  • El frosting 0x2146444e está en tres de cada cuatro de las apps más instaladas de Play y en casi todas las del sorteo. Fuera de Play solo lo lleva una app de IzzyOnDroid.
  • 0x71777777, el canal de Walle, aparece en una de cada cuatro apps chinas y en una de Google Play. Su contenido es un texto o un JSON corto con el nombre del canal, por ejemplo {"channel_name":"360助手","channel":"30010"} en com.ifeng.newvideo 73440 (v2, dependency info, Walle de 46 B y relleno). Otro ejemplo, sin relleno: cn.ninegame.gamemanager 80506001 (v2, Walle de 77 B y 0x71777778 de 3.995 B a cero).

El único APK de fuera de Play con frosting es com.tortillum.signalid 3, de IzzyOnDroid: verifica con la clave de Play y lleva también dependency info. Quien reempaquete un APK debe conservar estos pares o saber que, al quitarlos, pierde datos que usa la tienda.

4.1 Los atributos internos, que también son identificadores

No son bloques del APK Signing Block sino additional attributes dentro de un bloque de firma. Se confunden a menudo con los anteriores porque son uint32 del mismo aspecto. Todos verificados en el código:

ID Nombre Dónde aparece Contenido
0xbeeff00d STRIPPING_PROTECTION_ATTR_ID Bloque v2 Número del esquema superior presente
0x3ba06f8c PROOF_OF_ROTATION_ATTR_ID Firmantes v3, v3.1 y v3.2 El lineage de rotación («sección 5.2 · Rechazos estructurales y reglas del lineage»)
0x559f8b02 ROTATION_MIN_SDK_VERSION_ATTR_ID Bloque v3 minSdkVersion que debe declarar el v3.1
0xc2a6b3ba ROTATION_ON_DEV_RELEASE_ATTR_ID (SIGNER_TARGETS_DEV_RELEASE_ATTR_ID desde Android 17) Firmantes v3.1 y v3.2 El firmante apunta a una release en desarrollo
0x9d6303f7 PROOF_OF_ROTATION_ATTR_ID (stamp) Source stamp Lineage del certificado del stamp
0xe43c5946 STAMP_TIME_ATTR_ID Source stamp Época en segundos, uint64 little-endian
0xbf940529 HYBRID_MIN_SDK_VERSION_ATTR_ID Firmantes v3.0 y v3.1 SDK mínimo del bloque v3.2, int32 little-endian: si el atributo está y el bloque híbrido falta o no coincide, el APK se rechaza
0x9f06b79c HYBRID_MAX_SDK_VERSION_ATTR_ID Firmantes v3.0 y v3.1 SDK máximo del bloque v3.2. Opcional: si falta no se compara; si está sin el mínimo, el APK se rechaza. apksigner 37.0.0 no lo escribe, pero los APK reales sí lo traen (ver abajo)

En los 34 APK del muestrario que llevan v3.2, el firmante v3 declara los dos atributos: HYBRID_MIN_SDK_VERSION = 37 y HYBRID_MAX_SDK_VERSION = 2147483647. Así que el máximo lo escribe alguna herramienta que no es apksigner 37.0.0; no sabemos cuál. Se ve en el volcado de com.phasora › base.apk de la «sección 9 · El volcador». No hay ningún APK con el atributo y sin bloque v3.2, así que el rechazo en ese caso no lo hemos medido.

5. Estructura interna de un bloque v2 o v3

El valor de los pares 0x7109871a, 0xf05368c0, 0x1b93ad61 y 0x70e1c89f tiene la misma forma general. Todo son secuencias con prefijo de longitud uint32: primero un uint32 con los bytes que siguen, luego esos bytes. Anidado tres niveles.

valor del par
└── uint32 len ─ secuencia de signers
    └── uint32 len ─ signer
        ├── uint32 len ─ signed data
        │   ├── uint32 len ─ secuencia de digests
        │   │   └── uint32 len ─ digest
        │   │       ├── uint32  signature algorithm ID
        │   │       └── uint32 len ─ bytes del digest
        │   ├── uint32 len ─ secuencia de certificados
        │   │   └── uint32 len ─ certificado X.509 en DER
        │   ├── uint32  minSdkVersion            ← solo v3, v3.1 y v3.2
        │   ├── uint32  maxSdkVersion            ← solo v3, v3.1 y v3.2
        │   └── uint32 len ─ secuencia de additional attributes
        │       └── uint32 len ─ attribute
        │           ├── uint32  ID               ← tabla de la sección 4.1
        │           └── valor
        ├── uint32  minSdkVersion                ← solo v3, v3.1 y v3.2, copia SIN firmar
        ├── uint32  maxSdkVersion                ← solo v3, v3.1 y v3.2, copia SIN firmar
        ├── uint32 len ─ secuencia de signatures
        │   └── uint32 len ─ signature
        │       ├── uint32  signature algorithm ID
        │       └── uint32 len ─ bytes de la firma
        └── uint32 len ─ public key (SubjectPublicKeyInfo en DER)

Cuatro reglas que gobiernan la verificación de esta estructura:

  1. La firma se calcula sobre los bytes del signed data completo, tal cual aparecen en el fichero. No sobre una reserialización: hay que quedarse con el rango de bytes original.
  2. Los algoritmos de digests y los de signatures tienen que formar la misma lista, en el mismo orden. La spec manda comprobar que «the ordered list of signature algorithm IDs in digests and signatures is identical», y los dos verificadores comparan las dos listas con List.equals: los mismos algoritmos en otro orden también se rechazan (V2SchemeVerifier.java, líneas 408-421; en la plataforma, ApkSignatureSchemeV2Verifier.java, 324-327, y ApkSignatureSchemeV3Verifier.java, 532-540).
  3. El primer certificado de la secuencia es el del firmante, y su clave pública debe ser idéntica al campo public key del signer. Comprobar solo uno de los dos deja pasar un APK con la clave cambiada.
  4. Las copias sin firmar de minSdkVersion y maxSdkVersion —solo en v3, v3.1 y v3.2— permiten descartar un firmante fuera de rango sin abrir el signed data, y la decisión real usa las de dentro. Pero no son un atajo informativo: tienen que ser idénticas a las firmadas. La especificación las define como «duplicate of the signed data value, must match», y el paso 3.3 de verificación ordena comprobarlo. Una discrepancia no es un aviso, es un fallo: V3SchemeVerifier.parseSigner emite V3_MIN_SDK_VERSION_MISMATCH_BETWEEN_SIGNER_AND_SIGNED_DATA_RECORD como error, y en AOSP ApkSignatureSchemeV3Verifier.verifySigner lanza SecurityException("minSdkVersion mismatch between signed and unsigned in v3 signer block."). Un verificador propio que se salte esa comparación acepta bloques que Android rechaza.

Volcado real del bloque v3.1 del base.apk de Google Keep (com.google.android.keep 5.26.411.03.97, el .apkm de APKMirror, pieza base.apk), con el lineage desplegado. Se obtiene con python3 -I dump_sigblock.py -v base.apk sobre el base.apk extraído del .apkm:

  bloque v3.1: valor=7613 B, secuencia de signers=7609 B
    signer: minSdkVersion=33 maxSdkVersion=2147483647
      signed data: digests=76 B certs=1488 B attrs=4927 B
        digest    alg=0x0104 RSA_PKCS1_V1_5_WITH_SHA512        64 B  a78835ab8424cd459429f00d…
        certificate X.509 DER: 1484 B
        minSdkVersion=33 maxSdkVersion=2147483647  (copia firmada)
        attribute 0x3ba06f8c PROOF_OF_ROTATION  valor=4919 B
          lineage version=1
          nodo #1: cert=1095 B  sigAlgId=0x0103 RSA_PKCS1_V1_5_WITH_SHA256  sig=0 B
                    flags=0x00000017 → INSTALLED_DATA|SHARED_USER_ID|PERMISSION|AUTH
          nodo #2: cert=1484 B  sigAlgId=0x0104 RSA_PKCS1_V1_5_WITH_SHA512  sig=256 B
                    flags=0x0000001f → INSTALLED_DATA|SHARED_USER_ID|PERMISSION|ROLLBACK|AUTH
          nodo #3: cert=1484 B  sigAlgId=0x0000 ?  sig=512 B
                    flags=0x00000017 → INSTALLED_DATA|SHARED_USER_ID|PERMISSION|AUTH
        signature alg=0x0104 RSA_PKCS1_V1_5_WITH_SHA512        512 B
        public key SubjectPublicKeyInfo DER: 550 B

Esta versión de Keep ha rotado dos veces: tres certificados en el lineage. El segundo nodo lleva la capacidad ROLLBACK (0x1f). El bloque mide 20.480 bytes y empieza en 17.526.784. Los pares son v2, v3.1 (7.613 B), v3, sello (3.057 B), frosting (3.973 B) y relleno (2.219 B). El v3 de esta pieza declara minSdk 24, maxSdk 32 y ROTATION_MIN_SDK_VERSION = 33, y el certificado del sello (1.421 B) cubre los esquemas 2 y 3, no el v3.1.

5.1 Lo que el verificador comprueba además de parsear

Leer la estructura no dice qué acepta Android. El verificador de la plataforma, android.util.apk de frameworks/base, aplica reglas que no se ven en el formato. Todas están leídas en la etiqueta android-17.0.0_r1, y las líneas son de esa etiqueta:

Regla Qué hace la plataforma Dónde
Una firma por firmante No verifica todas. De las signatures cuyo algoritmo conoce, elige la más fuerte según su digest de contenido —CHUNKED_SHA512 antes que VERITY_CHUNKED_SHA256, y esta antes que CHUNKED_SHA256—, verifica solo esa y comprueba solo el digest de contenido de ese algoritmo compareSignatureAlgorithm en ApkSigningBlockUtils.java, 453-498; ApkSignatureSchemeV2Verifier.java, 243-272 y 302-329; ApkSignatureSchemeV3Verifier.java, 406-450 y 505-530
Algoritmos desconocidos Se saltan al elegir; si no queda ninguno, No supported signatures found ApkSignatureSchemeV2Verifier.java, 252-254 y 266-272
Firmantes en v2 Diez como máximo: APK Signature Scheme v2 only supports a maximum of 10 signers ApkSignatureSchemeV2Verifier.java, 80 y 189-195
Firmantes en v3 Cuentan solo los que cubren el SDK_INT del dispositivo; los demás se saltan. De esos, v3.0 admite exactamente uno; v3.1, uno, o dos si uno apunta a una versión en desarrollo; v3.2, exactamente dos. Con tres, rechazo ApkSignatureSchemeV3Verifier.java, 240-304, 357-397, 846-861 y 884-899
Atributos adicionales desconocidos Se ignoran ApkSignatureSchemeV2Verifier.java, 395-397; ApkSignatureSchemeV3Verifier.java, 777-779
Clave pública El campo public key tiene que ser, byte a byte, la codificación DER (SubjectPublicKeyInfo) de la clave del primer certificado: Public key mismatch between certificate and signature record ApkSignatureSchemeV2Verifier.java, 357-362; ApkSignatureSchemeV3Verifier.java, 582-591
zip64 ZIP64 APK not supported ApkSigningBlockUtils.java, 78-80
Central Directory seguido del EOCD El offset del Central Directory más su tamaño tiene que ser el offset del EOCD: ZIP Central Directory is not immediately followed by End of Central Directory ApkSigningBlockUtils.java, 412-428
size of block Entre 24 y Integer.MAX_VALUE − 8, sin que el bloque empiece antes del offset 0, y el de la cabecera igual al del final ApkSigningBlockUtils.java, 740-779
Pares del bloque Los recorre hasta dar con el identificador que busca: malformado si quedan menos de 8 bytes para el tamaño, si size of pair es menor que 4 o si se sale de lo que queda. Un identificador desconocido se salta, y lo que haya detrás del bloque buscado no se mira ApkSigningBlockUtils.java, 792-822

Las cuatro últimas filas no rechazan por sí mismas. Lanzan SignatureNotFoundException, no SecurityException, así que para ApkSignatureVerifier el APK no tiene bloque v2 ni v3 y sigue con el esquema siguiente (ApkSignatureVerifier.java, 198-240). Lo que pasa después depende de lo que haya debajo: con targetSdk 30 o superior el mínimo es v2 y el APK se rechaza (ApkSignatureVerifier.java, 579-584); si queda v1, su X-Android-APK-Signed lo rechaza («sección 3.2 de Esquemas de firma v1, v2 y v3 · META-INF/CERT.SF») cuando la verificación es completa: ApkSignatureVerifier.verify pasa verifyFull activado a StrictJarFile, que solo entonces mira esa cabecera, y unsafeGetCertsWithoutVerification lo pasa desactivado y no rechaza por ella (ApkSignatureVerifier.java, 83-96 y 439-442; StrictJarVerifier.java, 399-445). Las demás filas sí son un rechazo directo: el esquema estaba y no verificó.

apksig hace la elección de la primera fila de otra manera: getSignaturesToVerify toma, para cada versión de plataforma del rango pedido, la firma más fuerte que esa versión admite, así que puede verificar más de una por firmante (ApkSigningBlockUtilsLite.java, 167-219). La lista completa de lo que rechaza la plataforma, con sus mensajes, está en la «sección 4 de Qué rechaza cada lector · El verificador de firmas».

Un apksigner verify que falla no siempre es un bloque roto. apksigner (build-tools 37.0.0, Java 21.0.10, sin --min-sdk-version) verifica casi todo el muestrario. Las 127 piezas que no verifica, de 15 apps, fallan por otras causas, nunca por un defecto del bloque:

  • 93 splits de seis apps de Google Play (Microsoft Outlook, Office, Word, Excel y PowerPoint, y com.mi.globalbrowser) dan «Missing META-INF/MANIFEST.MF». Solo llevan v3 y no declaran minSdk, así que apksigner supone el SDK 1 y exige la firma v1, que no existe. Con el --min-sdk-version de la base (33 o 30) verifican todos. Ejemplos: com.microsoft.office.officehubrow 16.0.20611.20024 › split_lenssampledoc.apk y com.microsoft.office.powerpoint 16.0.20611.20014 › split_config.uk.apk.
  • 34 piezas de 9 apps del sorteo de Play llevan v3.2 con un firmante ML-DSA. Java 21 no sabe leerlo («ML-DSA KeyFactory not available»). Con Java 25.0.5 verifican todas. Ejemplo: com.phasora › base.apk.

Y al revés: los bloques raros sí verifican. Con ID repetido, bytes sobrantes, comentario en el ZIP, sin relleno, con verity, con dependency info, con IDs de terceros o con inicio sin alinear, verifican todos. Con frosting, todos menos 9, que fallan por llevar v3.2. Las piezas sin bloque también verifican.

5.2 Rechazos estructurales y reglas del lineage

Los dos verificadores exigen además que la estructura tenga contenido. Un bloque v2 o v3.0 sin firmantes, o un firmante sin firmas o sin certificados, no se salta: se rechaza. En la plataforma, un bloque v3.1 o v3.2 sin firmantes que cubran el SDK del dispositivo sí se salta (primera fila). El orden es el de la spec, que solo deja leer el signed data después de verificar su firma: la falta de firmas se detecta al elegir la que se verifica, y la de certificados, ya verificada la firma (ApkSignatureSchemeV2Verifier.java, línea 290 frente a 354-356; V2SchemeVerifier.java, 326 frente a 369-372, y lo mismo en v3).

Falta Plataforma (SecurityException) apksig (error)
Firmantes No signers found (ApkSignatureSchemeV2Verifier.java, 207-209). En v3.0 sale el mismo mensaje cuando ningún firmante cubre el SDK del dispositivo, también con la secuencia vacía (ApkSignatureSchemeV3Verifier.java, 264-269); un bloque v3.1 o v3.2 en esa situación se salta V2_SIG_NO_SIGNERS, V3_SIG_NO_SIGNERS (V2SchemeVerifier.java, 192-195; V3SchemeVerifier.java, 321-324)
Firmas No signatures found (ApkSignatureSchemeV2Verifier.java, 266-268; ApkSignatureSchemeV3Verifier.java, 437-443) V2_SIG_NO_SIGNATURES, V3_SIG_NO_SIGNATURES (V2SchemeVerifier.java, 286-289; V3SchemeVerifier.java, 409-412)
Certificados No certificates listed (ApkSignatureSchemeV2Verifier.java, 354-356; ApkSignatureSchemeV3Verifier.java, 575-580) V2_SIG_NO_CERTIFICATES, V3_SIG_NO_CERTIFICATES (V2SchemeVerifier.java, 369-372; V3SchemeVerifier.java, 511-514)

El lineage del atributo 0x3ba06f8c —su formato está en la «sección 5.2 de Esquemas de firma v1, v2 y v3 · El lineage de rotación»— tiene reglas propias. Las tres primeras las aplica la plataforma en verifyProofOfRotationStruct (ApkSigningBlockUtils.java, 851-939) y apksig al leerlo (V3SigningCertificateLineage.java, 76-167); la cuarta y la quinta, la plataforma en ApkSignatureSchemeV3Verifier:

  1. Cada nodo, a partir del segundo, va firmado por la clave del anterior, con el algoritmo que el anterior declara fuera de su signed data: Unable to verify signature of certificate #N … when verifying Proof-of-rotation record (líneas 888-903; en apksig, 116-134).
  2. Ese algoritmo es el que el nodo declara dentro de su signed data: Signing algorithm ID mismatch for certificate #N (906-912; en apksig, 136-142).
  3. Ningún certificado se repite: Encountered duplicate entries in Proof-of-rotation record (918-922; en apksig, 145-149).
  4. El último certificado es el del firmante: Terminal certificate in Proof-of-rotation record does not match APK signing certificate (ApkSignatureSchemeV3Verifier.java, 674-686).
  5. Un solo lineage por firmante: Encountered multiple Proof-of-rotation records (ApkSignatureSchemeV3Verifier.java, 647-656).

En apksig, las tres primeras salen como V3_SIG_POR_DID_NOT_VERIFY, y la cuarta como V3_SIG_POR_CERT_MISMATCH, que cubre también un certificado de firmante que no está en el lineage (V3SchemeVerifier.java, 595-612). Hay dos diferencias entre los dos verificadores. apksig rechaza un lineage cuya versión no sea 1, y la plataforma la lee y no la mira («get the version code, but don't do anything with it», ApkSigningBlockUtils.java, 877-878). Y apksig no aplica la quinta regla: un segundo atributo 0x3ba06f8c sustituye al primero sin error (V3SchemeVerifier.java, 595-599).

5.3 El source stamp, 0x6dff800d

El valor del par 0x6dff800d no tiene la forma de un firmante de v2 o v3. Lo escribe V2SourceStampSigner de apksig (líneas 124-147) y lo leen el SourceStampVerifier de apksig y el de la plataforma, con prefijos uint32 como el resto:

valor del par
└── uint32 len ─ bloque del sello
    ├── uint32 len ─ certificado X.509 del sello, en DER
    ├── uint32 len ─ secuencia de digests firmados, uno por esquema
    │   └── uint32 len ─ elemento
    │       ├── uint32  esquema: 1 = v1 (JAR), 2 = v2, 3 = v3
    │       └── uint32 len ─ secuencia de signatures
    │           └── uint32 len ─ signature
    │               ├── uint32  signature algorithm ID
    │               └── uint32 len ─ firma de la lista de digests de ese esquema
    ├── uint32 len ─ atributos                                  ← opcional
    │   └── uint32 len ─ secuencia de atributos
    │       └── uint32 len ─ atributo: uint32 ID + valor
    └── uint32 len ─ secuencia de signatures de los atributos   ← opcional

Quién pone el sello. No lo pone el desarrollador, lo pone Google Play al distribuir. Todas las piezas con sello del muestrario comparten un único certificado, con el nombre CN=Android, OU=Android, O=Google Inc., L=Mountain View, ST=California, C=US (SHA-256 3257d599a49d2c961a471ca9843f59d341a405884583fc087df4237b733bbd6d), y apksigner lo da por bueno en todas las que verifica (las 127 que no verifican fallan por otras causas, «sección 5.1 · Lo que el verificador comprueba además de parsear»). Lo llevan casi todas las piezas de Google Play, splits y asset packs incluidos, vengan de .apkm, de .xapk o de adb; los .apk sueltos, solo uno de cada tres. Fuera de Play solo aparece en 6 piezas de IzzyOnDroid, con el mismo sello de Google: son binarios que pasaron por Play (por ejemplo com.leaf.explorer 142).

La entrada stamp-cert-sha256 del ZIP coincide con el certificado del bloque en todas las piezas con sello. En las bases y en los APK únicos (nunca en los splits), el manifiesto suele añadir com.android.stamp.source, que donde se leyó (9 piezas) vale https://play.google.com/store. El stamp.type es STAMP_TYPE_DISTRIBUTION_APK en las bases y STAMP_TYPE_STANDALONE_APK en los APK únicos (6 piezas leídas con aapt2). El sello v1 (0x2b09189e) no aparece en ninguna pieza. Así que el sello indica que la pieza pasó por Play, y no hace falta bundletool para que exista. Ejemplos: el base.apk de Keep («sección 5 · Estructura interna de un bloque v2 o v3») y TickTock-TikTok+Live+Wallpaper 36.0 de APKPure (v2, v3, sello y relleno, bloque de 8.192 B desde 315.392). En el volcado de com.phasora › base.apk el sello cubre los esquemas 1, 2 y 3 y no el v3.1 ni el v3.2.

Cuatro reglas lo gobiernan:

  1. El certificado se ata al ZIP por su hash. Su SHA-256 tiene que ser el contenido de la entrada stamp-cert-sha256, que v2 y v3 cubren como cualquier otra: Certificate mismatch between APK and signature block en la plataforma (SourceStampVerifier.java, 257-261) y SOURCE_STAMP_CERTIFICATE_MISMATCH_BETWEEN_SIGNATURE_BLOCK_AND_APK en apksig (SourceStampVerifier.java, 207-219). Sin esa entrada, la plataforma da el sello por ausente (126-131).
  2. El sello no firma el APK: firma los digests que ya declaran las firmas del desarrollador. Para cada esquema firma su lista de digests de contenido, codificada como los digests de la «sección 5 · Estructura interna de un bloque v2 o v3» pero con el ID de digest de la «sección 6.3 · Los algoritmos de digest de contenido» en vez del de firma, y ordenada por ese ID (V2SourceStampSigner.java, 150-192). Para v1, la lista es un solo SHA256, ID 4, del META-INF/MANIFEST.MF entero. La plataforma toma esos digests tal como los declaran los bloques v3 (0xf05368c0) y v2, sin recalcularlos, porque eso ya lo hace la verificación de cada esquema, y exige una firma para cada esquema que encuentra: No signatures found for signature scheme N (SourceStampVerifier.java, 187-200 y 339-394). No mira el bloque v3.1, y apksig no lo firma ni lo verifica: deja un INFO, «No digests are available in the source stamp for signature scheme: 31» (SourceStampVerifier.java de apksig, 139-148).
  3. Los atributos se firman aparte, sobre el contenido de su campo tal cual, con su prefijo interno (V2SourceStampSigner.java, 118-122; SourceStampVerifier.java de apksig, 165-179). 0xe43c5946 es la marca de tiempo, 8 bytes con los segundos de la época, que apksig escribe por defecto y exige positiva (322-330). 0x9d6303f7 es el lineage del certificado del sello, con el formato y las reglas de la «sección 5.2 · Rechazos estructurales y reglas del lineage» y su último certificado igual al del sello (SourceStampVerifier.java de la plataforma, 454-492). La plataforma solo lee este último.
  4. apksig firma el sello siempre con 0x0103, RSA_PKCS1_V1_5_WITH_SHA256, sea cual sea la clave (DefaultApkSignerEngine.java, 721-724): con una clave EC, apksigner sign --stamp-signer termina en InvalidKeyException: Failed to sign using SHA256withRSA.

Con varios APK de una misma aplicación —los splits—, la plataforma exige además el mismo certificado y el mismo lineage de sello en todos (SourceStampVerifier.java, 95-115). En el muestrario se cumple sin excepción: las apps con splits llevan el mismo certificado de firma y el mismo sello en todas sus piezas. El lineage del sello no lo hemos comparado. Ejemplo: de.systembau.prourlaubapp › base.apk. Qué hace el instalador con el resultado está en la «sección 8 de Firma v4 y verificación · El source stamp», y la «sección 9 · El volcador» vuelca un sello con -v. En ese APK de prueba, las firmas de los esquemas 2 y 3 son idénticas byte a byte: las dos listas son el mismo CHUNKED_SHA256, y 0x0103 es determinista.

5.4 La rotación de clave en la práctica

Rotar la clave es cambiar la clave de firma de una app sin perder las actualizaciones. El v3.1 es el bloque que lo hace posible desde Android 13. Lo usan sobre todo las apps más instaladas de Play (una de cada diez); en las demás fuentes es raro, y F-Droid e IzzyOnDroid no lo usan.

  • Siempre con v3. Ninguna pieza lleva v3.1 sin v3. El v3 declara siempre ROTATION_MIN_SDK_VERSION, y desde ese SDK manda el v3.1. El SDK es 33 en todas las apps menos una, que usa 37: com.oplus.games 10.42.3 (APKMirror).
  • Cuántos nodos. Lo normal es un lineage de 2 nodos en el v3.1; algunas apps tienen 3, como el base.apk de Keep («sección 5 · Estructura interna de un bloque v2 o v3»). En los lineage que leímos (una muestra de 6), los flags son 0x17 en la mayoría y 0x1f, con ROLLBACK, en el nodo intermedio de Keep y en 2 más.
  • Qué clave. La clave del v3.1 es casi siempre RSA de 4.096 bits (algoritmo 0x0104), y la del v3 de esas mismas apps suele ser RSA de 2.048 o de 1.024. Cuadra con una rotación a una clave más fuerte. «Clave de la app» es la del v3.1 si existe y, si no, la de v3 o v2: para Android 13 y posteriores vale la del v3.1.
  • Lineage dentro de v3, sin v3.1. Hay piezas con un lineage de 2 nodos dentro del v3 y sin v3.1, sobre todo en el mercado chino y en Play. Son rotaciones anteriores a v3.1. Ejemplo: com.google.android.deskclock 9.2 › split_config.mdpi.apk.
  • Otros ejemplos con v3.1. com.google.android.apps.mapslite 165.0 (APKMirror), y la web de WhatsApp, donde el par v3.1 sale dos veces.

Qué proporción de apps tiene una capacidad ROLLBACK activa no lo hemos medido (límite en la «sección 1 · Qué es y por qué existe»).

6. El algoritmo de digest por chunks

Es el detalle que hay que implementar exactamente, y el que más se equivoca. La descripción oficial y el código de ApkSigningBlockUtils.java coinciden byte a byte.

6.1 Qué se trocea

Los tres tramos cubiertos, en este orden y concatenados como si fuesen un solo flujo:

tramo 1: bytes [0, inicio_del_APK_Signing_Block)      contenido de las entradas ZIP
tramo 3: el Central Directory completo
tramo 4: el EOCD, con su campo de offset del CD sustituido por el tamaño del tramo 1

El tramo 2 —el propio APK Signing Block— no entra. Y la sustitución del tramo 4 es la excepción necesaria que explica la «sección 4.1 de Esquemas de firma v1, v2 y v3 · Las dos exclusiones y por qué son necesarias».

Ojo, que esto cuesta caro descubrirlo tarde: los tres tramos no se concatenan antes de trocear. Cada uno se trocea por separado y el último trozo de cada tramo puede ser más corto de 1 MiB. El comentario de ChunkSupplier en apksig lo dice: «When bounds are met in a supplied DataSource, the data from the next DataSource are NOT concatenated». Un implementador que junte los tres tramos en un buffer y luego trocee obtiene chunks distintos y digests distintos para el mismo fichero.

6.2 El troceado

  • Tamaño de chunk: 1 MiB = 1.048.576 bytes. En el código, CONTENT_DIGESTED_CHUNK_MAX_SIZE_BYTES = 1024 * 1024.
  • Digest de cada chunk: se digiere 0xa5 ‖ longitud del chunk (uint32 LE) ‖ datos.
  • Digest final: se digiere 0x5a ‖ número total de chunks (uint32 LE) ‖ concatenación de todos los digests de chunk, en orden.
chunk i  ⟶  H(0xa5 ∥ leni (u32 LE) ∥ datosi)  ⟶  di\text{chunk } i \;\longrightarrow\; H\bigl(\texttt{0xa5} \,\|\, \mathrm{len}_i\,(\text{u32 LE}) \,\|\, \text{datos}_i\bigr) \;\longrightarrow\; d_i
digest final=H(0x5a ∥ n (u32 LE) ∥ d0 ∥ d1 ∥ … ∥ dn−1)\text{digest final} = H\bigl(\texttt{0x5a} \,\|\, n\,(\text{u32 LE}) \,\|\, d_0 \,\|\, d_1 \,\|\, \ldots \,\|\, d_{n-1}\bigr)

El código construye el buffer del segundo nivel exactamente así, y el comentario no deja lugar a interpretación:

concatOfDigestsOfChunks = new byte[1 + 4 + chunkCount * digestOutputSize];
// Fill the initial values of the concatenated digests of chunks, which is
// {0x5a, 4-bytes-of-little-endian-chunk-count, digests*...}.
concatOfDigestsOfChunks[0] = 0x5a;

Los dos prefijos existen por lo mismo: separar el dominio. Sin ellos, el digest de un chunk y el digest final serían hashes del mismo espacio de entradas, y un atacante podría construir un fichero cuyo contenido fuese, a la vez, una lista válida de digests. Con 0xa5 en un nivel y 0x5a en el otro, las dos entradas nunca colisionan. La longitud incluida en el prefijo hace lo propio con el último chunk, que es más corto.

6.3 Los algoritmos de digest de contenido

ContentDigestAlgorithm.java define cuatro:

Nombre ID Hash Chunk Uso
CHUNKED_SHA256 1 SHA-256 1 MiB v2, v3, v3.1
CHUNKED_SHA512 2 SHA-512 1 MiB v2, v3, v3.1 con clave grande
VERITY_CHUNKED_SHA256 3 SHA-256 4 KiB APK verity: árbol de Merkle, no lista plana
SHA256 4 SHA-256 — Sin trocear: el SHA-256 de META-INF/MANIFEST.MF con el que el source stamp cubre la firma v1

VERITY_CHUNKED_SHA256 no usa el algoritmo de esta sección: construye un árbol de Merkle de bloques de 4 KiB, y su digest final es la raíz del árbol más el tamaño del contenido. El árbol se parece al de la firma v4, descrito en «Firma v4 y verificación → §3 · El árbol de Merkle y fs-verity», pero no es el mismo: aquí cada hash lleva una sal de 8 bytes a cero y el árbol cubre el fichero sin el APK Signing Block, mientras que el de v4 va sin sal, cubre el fichero entero y su digest es solo la raíz.

Su presencia impone dos condiciones extra, que verifyIntegrity comprueba lanzando una excepción:

if ((beforeApkSigningBlock.size() % ANDROID_COMMON_PAGE_ALIGNMENT_BYTES != 0)) {
    throw new RuntimeException("APK Signing Block is not aligned on 4k boundary: " + …);
}
…
if (signingBlockSize % ANDROID_COMMON_PAGE_ALIGNMENT_BYTES != 0) {
    throw new RuntimeException("APK Signing Block size is not multiple of page size: " + …);
}

Es decir: si hay digest de verity, el bloque tiene que empezar en múltiplo de 4096 y medir un múltiplo de 4096. La «sección 10.2 · Alineación» comprueba esa correlación sobre el muestrario, y se cumple sin excepciones.

7. Algoritmos de firma

Sacados de SignatureAlgorithm.java. La columna «Digest de contenido» dice qué algoritmo de la «sección 6.3 · Los algoritmos de digest de contenido» acompaña obligatoriamente a cada firma, y la última, con qué nombre se pide la firma a java.security.Signature y qué bytes deja en el campo signature.

ID Nombre en apksig Firma Digest de contenido minSdkVersion JCA y bytes de signature
0x0101 RSA_PSS_WITH_SHA256 RSASSA-PSS, SHA-256, MGF1 SHA-256, sal de 32 B CHUNKED_SHA256 24 SHA256withRSA/PSS, trailerField 1: tantos bytes como el módulo
0x0102 RSA_PSS_WITH_SHA512 RSASSA-PSS, SHA-512, MGF1 SHA-512, sal de 64 B CHUNKED_SHA512 24 SHA512withRSA/PSS, ídem
0x0103 RSA_PKCS1_V1_5_WITH_SHA256 RSASSA-PKCS1-v1_5, SHA-256 CHUNKED_SHA256 24 SHA256withRSA: tantos bytes como el módulo, que con la clave pública dan un DigestInfo DER
0x0104 RSA_PKCS1_V1_5_WITH_SHA512 RSASSA-PKCS1-v1_5, SHA-512 CHUNKED_SHA512 24 SHA512withRSA, ídem
0x0201 ECDSA_WITH_SHA256 ECDSA, SHA-256 CHUNKED_SHA256 24 SHA256withECDSA: Ecdsa-Sig-Value en DER, no r‖s
0x0202 ECDSA_WITH_SHA512 ECDSA, SHA-512 CHUNKED_SHA512 24 SHA512withECDSA, ídem
0x0301 DSA_WITH_SHA256 DSA, SHA-256 CHUNKED_SHA256 24 SHA256withDSA: Dss-Sig-Value en DER, no r‖s
0x0301 DETDSA_WITH_SHA256 DSA determinista, RFC 6979 CHUNKED_SHA256 24 SHA256withDetDSA al firmar, ídem
0x0421 VERITY_RSA_PKCS1_V1_5_WITH_SHA256 RSASSA-PKCS1-v1_5, SHA-256 VERITY_CHUNKED_SHA256 28 Como 0x0103
0x0423 VERITY_ECDSA_WITH_SHA256 ECDSA, SHA-256 VERITY_CHUNKED_SHA256 28 Como 0x0201
0x0425 VERITY_DSA_WITH_SHA256 DSA, SHA-256 VERITY_CHUNKED_SHA256 28 Como 0x0301
0x0501 ML_DSA ML-DSA (ML-DSA-65 o ML-DSA-87; apksig también acepta ML-DSA-44, que la plataforma no admite) CHUNKED_SHA512 37 ML-DSA: la firma de FIPS 204 tal cual

Los nombres JCA son los mismos en apksig (SignatureAlgorithm.java, líneas 35-162) y en la plataforma (ApkSigningBlockUtils.java de android.util.apk, 588-624), y de ellos depende qué hay en el campo. Con ECDSA y DSA, la codificación DER de SEQUENCE { r INTEGER, s INTEGER } (Ecdsa-Sig-Value y Dss-Sig-Value en el RFC 3279). Su longitud varía, porque cada entero lleva su cabecera y, si hace falta, un cero delante. No es la concatenación r‖s de IEEE P1363, que en JCA se pide con otro nombre, SHA256withECDSAinP1363Format. Con RSASSA-PKCS1-v1_5, un bloque del tamaño del módulo que, abierto con la clave pública, contiene el DigestInfo DER del hash (RFC 8017, apartado 9.2); con PSS, el mismo tamaño y el trailerField 1, que es el byte final 0xbc (apéndice A.2.3). Con ML-DSA, la firma de FIPS 204 sin envoltura, hecha sobre los bytes del signed data y sin contexto: 3.309 bytes con ML-DSA-65.

Lo comprobamos el 18 de octubre de 2026 sobre APK de prueba firmados con apksigner 37.0.0. Las firmas 0x0103, 0x0201, 0x0301 y 0x0501 verifican sobre los bytes del signed data con openssl 3.6.3 (dgst -sha256 -verify las tres primeras, pkeyutl -verify -rawin la de ML-DSA-65). La de ECDSA P-256 mide 72 bytes y empieza por 30 46 02 21, y la de otro firmante P-256 mide 71. La de DSA es un SEQUENCE de dos INTEGER. La de RSA, abierta con pkeyutl -verifyrecover, da SEQUENCE { SEQUENCE { sha256, NULL }, OCTET STRING }. La de PSS no hemos podido comprobarla así: con una clave RSA, apksig elige PKCS#1 v1.5 «to guarantee deterministic signatures» (V2SchemeSigner.java, líneas 95-97; V3SchemeSigner.java, 115-117).

0x0301 está duplicado a propósito: DSA_WITH_SHA256 y DETDSA_WITH_SHA256 comparten identificador porque en el fichero son indistinguibles; la diferencia es solo cómo se generó el nonce al firmar. Un parser que use un mapa ID → nombre tiene que decidir cuál gana, y da igual cuál: la verificación es la misma.

Los rangos de clave que admite la especificación: RSA de 1024 a 16384 bits, EC sobre las curvas NIST P-256, P-384 y P-521, DSA de 1024 a 3072 bits. En uso real hay claves fuera de ellos: una app del mercado chino, cn.ninegame.gamemanager 80506001, está firmada con una clave RSA de 512 bits y apksigner la verifica. Dentro del rango se ven unas pocas claves RSA de 8.192 bits, curvas P-256, P-384 y P-521 en F-Droid e IzzyOnDroid, y DSA de 1.024 y 2.048 bits en apps antiguas. Ejemplos de curva elíptica: be.cuypers_ghys.gaai 104000 (IzzyOnDroid; P-256) y org.axpos.lovelaceav 31614 (IzzyOnDroid; P-521). En dos firmantes de IzzyOnDroid, el bloque v2 lista además un algoritmo de firma 0x9901 que no está en la tabla de arriba, por ejemplo en rsquared226.budget_my_life 14; no sabemos qué es, y lo citamos como observado.

En la práctica se usan 8 de los 11 identificadores de algoritmo distintos de la tabla (que tiene 12 filas porque 0x0301 sale dos veces). Domina con mucho 0x0103 (RSA con SHA-256), seguido de 0x0104 (RSA con SHA-512); detrás vienen 0x0421 (RSA con verity) y 0x0301 (DSA), y ECDSA (0x0201, 0x0202) y 0x0425 (DSA con verity) son casos sueltos. 0x0501 (ML-DSA) va en el segundo firmante de los 34 bloques v3.2. No aparecen 0x0101 ni 0x0102 (PSS) ni 0x0423 (ECDSA con verity).

La curva elíptica es rara: solo unas pocas apps de F-Droid e IzzyOnDroid. Y sigue habiendo claves débiles. «Clave de la app» aquí es la del firmante v3.1 si existe y, si no, la de v3 o v2; para Android 13 y posteriores vale la del v3.1. Con esa clave, RSA de 1.024 bits la llevan una de cada cuatro apps de las más instaladas de Play y la mitad de las chinas. Lo habitual en cada sitio es RSA de 2.048 bits en F-Droid e IzzyOnDroid, RSA de 4.096 en el sorteo de Play y RSA de 1.024 en el mercado chino.

Las firmas verity no salen por defecto. apksigner sign solo las añade con --verity-enabled, que vale false si no se indica. La ayuda de la herramienta lo describe como «Whether to enable the verity signature algorithm for the v2 and v3 signature schemes»; la página de apksigner de developer.android.com no lo menciona. Con la opción, escribe la firma verity al lado de la normal, no en su lugar: con una clave RSA de hasta 3.072 bits, 0x0103 y 0x0421 en el mismo firmante. El Android Gradle Plugin no las pide: signflinger crea su DefaultApkSignerEngine sin activar verity, que en apksig está apagado por defecto.

Aun así, hay firmas verity en piezas de varios sitios. Donde más, en F-Droid (una de cada cinco), y ahí casi todas llevan el DN de F-Droid: la cadena de F-Droid las activa. En Google Play casi no las hay. Siempre van junto a la firma normal: 0x0103 + 0x0421 y, con DSA, 0x0301 + 0x0425; 0x0423 (ECDSA con verity) no sale en ninguna pieza. Veinte piezas, casi todas de IzzyOnDroid, llevan verity y también dependency info, el par que añade el plugin: lo más probable es que alguien las volviera a firmar después de compilarlas. Es una inferencia por la presencia simultánea de los dos pares; con datos estáticos no sabemos qué herramienta firmó en último lugar. Ejemplos: pro.rudloff.search_to_browser 2 (F-Droid) y com.mcdz.seeip 5 (IzzyOnDroid; dependency info y verity, bloque en 57.344 con 2.428 bytes de ceros delante).

8. El bloque de relleno

El par 0x42726577 (que en ASCII se lee Brew, leyendo el uint32 como big-endian) no lleva información: es relleno para que el tamaño total del bloque sea múltiplo de 4096.

Casi todas las piezas lo cumplen; solo el mercado chino se sale bastante, con más de un tercio de excepciones. Las excepciones son de dos tipos:

  • Sin relleno. Hay 67 piezas sin el par, y en ninguna el tamaño es múltiplo. Ejemplos: org.briarproject.briar.android 10522 (F-Droid), con un bloque de 1.415 B con solo v2 (1.371 B) que empieza en 50.557.671, y cn.ninegame.gamemanager 80506001 (mercado chino), con v2, Walle y 0x71777778.
  • Con relleno y un par detrás. Hay 61 piezas con relleno y tamaño no múltiplo, porque alguien añadió un par después de rellenar: el frosting de Play en 55 e identificadores de canal chinos en 6. En ninguna de las 61 es el relleno el último par. Ejemplo: com.dsi.ant.service.socket 4.18.00 (APKMirror) lleva v2, dependency info, relleno y, después, un frosting de 169 bytes; el bloque mide 4.277 bytes.

generateApkSigningBlock lo calcula así:

int resultSize = 8 /*size*/ + blocksSize + 8 /*size*/ + 16 /*magic*/;
if (resultSize % ANDROID_COMMON_PAGE_ALIGNMENT_BYTES != 0) {
    int padding = ANDROID_COMMON_PAGE_ALIGNMENT_BYTES -
            (resultSize % ANDROID_COMMON_PAGE_ALIGNMENT_BYTES);
    if (padding < 12) {  // minimum size of an ID-value pair
        padding += ANDROID_COMMON_PAGE_ALIGNMENT_BYTES;
    }
    …
}

Dos consecuencias que un implementador debe reproducir:

  • El relleno cuenta como un par completo, con sus 8 bytes de longitud y sus 4 de ID. Por eso, si faltan menos de 12 bytes para llegar al múltiplo, se añade una página entera: no cabe un par válido en menos.
  • Se alinea el tamaño, no la posición. Que el bloque empiece en un múltiplo de 4096 es una condición distinta, y no la exige el mismo que la cumple. El verificador solo la exige cuando hay digest de verity («sección 6.3 · Los algoritmos de digest de contenido»). apksigner la cumple siempre: pide el bloque con outputZipSections2, que activa el relleno, y generateApkSigningBlockPadding inserta hasta 4.095 bytes a cero entre la última entrada del ZIP y el bloque, no dentro de él, haya verity o no (DefaultApkSignerEngine.java, líneas 1167-1171 y 1186-1189; ApkSigningBlockUtils.java, 835-852). El Android Gradle Plugin rellena el bloque, pero no lo alinea.

apksigner alinea el inicio del bloque; el Android Gradle Plugin no. Cuando firma apksigner, entre la última entrada del ZIP y el bloque hay de 1 a 4.095 bytes de ceros. Un ejemplo es org.vi_server.red_screen 3 (F-Droid): el bloque está en 12.288 = 4.096 × 3, con 1.795 bytes de ceros antes y sin verity («sección 3.3 · Un bloque real, byte a byte»). Otro, fr.smarquis.sleeptimer 16300 en F-Droid, tiene el bloque en 16.384 con 827 bytes de ceros. En los APK que firma el Android Gradle Plugin, lo habitual es que el bloque tenga relleno pero empiece donde acaba la última entrada, sin ceros delante y sin alinear: moe.henry_zhr.force_dark 2 (IzzyOnDroid) lo tiene en 3.828, con v2, dependency info (206 B) y relleno. La misma versión de fr.smarquis.sleeptimer 16300 en IzzyOnDroid solo lleva v2 y relleno, y su bloque empieza en 13.292, sin ceros delante. Qué programa firmó es una inferencia por la huella (su v1 o su dependency info): v2 y v3 no dicen qué programa los escribió.

¿Cuántos empiezan alineados a 4.096? Casi todos los de Google Play, dos tercios de los de F-Droid, algo más de la mitad en el mercado chino y solo uno de cada cinco en IzzyOnDroid, donde manda el plugin de Gradle. Los ceros entre la última entrada y el bloque miden de 1 a 4.095 bytes y salieron todos a cero en las 73 piezas cuyo hueco leímos.

Se cumplen dos reglas en todas las piezas medidas: si hay ceros delante, el bloque está alineado; si no está alineado, no hay ceros delante. Y fíjate en que el inicio sin alinear no es un error: es lo normal en IzzyOnDroid y muy común en F-Droid. En Google Play, ninguna base ni split empieza sin alinear; solo algunos APK sueltos.

Que el tamaño del bloque sea múltiplo de 4096 tiene un efecto lateral visible: el offset del Central Directory hereda la alineación del final de los datos. En com.termux 1022 (F-Droid) ese offset vale 0x06D8D000 = 114.872.320, múltiplo exacto de 4096 (4.096 × 28.045), y el EOCD de la «sección 6.3 de Contenedor ZIP · El EOCD de un APK real» lo enseña.

8.1 El bloque y las páginas de 16 KB

Los móviles con páginas de memoria de 16 KB obligan a alinear a 16.384 bytes las bibliotecas nativas del APK (.so). El bloque de firma no cambia: sigue rellenándose a 4.096 bytes (ANDROID_COMMON_PAGE_ALIGNMENT_BYTES, en el código de esta sección) y apksigner sigue alineando a 4.096. Nadie alinea el bloque a 16 KiB. De los bloques que empiezan alineados a 4.096, uno de cada cuatro empieza también en múltiplo de 16.384, que es justo lo que daría el azar. Y el tamaño del bloque casi nunca es múltiplo de 16.384. Qué hay que alinear para 16 KB está en «Alineación y zipalign».

9. El volcador

Es la herramienta que hace falta para todo lo demás, en Python puro y sin dependencias. Recorre el bloque y enumera los pares; con -v decodifica además los firmantes de v2, v3, v3.1 y v3.2 y el source stamp, con el formato de los volcados de la «sección 5 · Estructura interna de un bloque v2 o v3». Proyecta el fichero en memoria con mmap en vez de leerlo entero, porque el muestrario tiene APK de más de 4 GB, como com.tencent.tmgp.yongyong.mrzh 744 (4.076.962.064 bytes, sin bloque y con un comentario del EOCD de 20 bytes). Busca el EOCD como ZipUtils.findZipEndOfCentralDirectoryRecord de apksig (ZipUtils.java, líneas 458-491): la firma PK\x05\x06 solo vale si su comment length llega justo al final del fichero.

#!/usr/bin/env python3
"""Vuelca los pares ID-valor del APK Signing Block de un APK.
Con -v decodifica además los firmantes de v2, v3, v3.1 y v3.2 y el source stamp v2."""
import hashlib, mmap, struct, sys

MAGIC = b"APK Sig Block 42"
NAMES = {
    0x7109871A: "v2 (APK_SIGNATURE_SCHEME_V2_BLOCK_ID)",
    0xF05368C0: "v3 (APK_SIGNATURE_SCHEME_V3_BLOCK_ID)",
    0x1B93AD61: "v3.1 (APK_SIGNATURE_SCHEME_V31_BLOCK_ID)",
    0x70E1C89F: "v3.2 (APK_SIGNATURE_SCHEME_V32_BLOCK_ID)",
    0x2B09189E: "source stamp v1 (V1_SOURCE_STAMP_BLOCK_ID)",
    0x6DFF800D: "source stamp v2 (V2_SOURCE_STAMP_BLOCK_ID)",
    0x42726577: "padding (VERITY_PADDING_BLOCK_ID)",
    0x504B4453: "dependency info (Google Play)",
    0x2146444E: "frosting (Google Play)",
    0x71777777: "Walle (canal de Meituan)",
    0x881155FF: "VasDolly (canal de Tencent)",
    0xFA1CFABE: "sin documentar (con PairIP)",
}
ALGS = {0x0101: "RSA_PSS_WITH_SHA256", 0x0102: "RSA_PSS_WITH_SHA512",
        0x0103: "RSA_PKCS1_V1_5_WITH_SHA256", 0x0104: "RSA_PKCS1_V1_5_WITH_SHA512",
        0x0201: "ECDSA_WITH_SHA256", 0x0202: "ECDSA_WITH_SHA512", 0x0301: "DSA_WITH_SHA256",
        0x0421: "VERITY_RSA_PKCS1_V1_5_WITH_SHA256", 0x0423: "VERITY_ECDSA_WITH_SHA256",
        0x0425: "VERITY_DSA_WITH_SHA256", 0x0501: "ML_DSA"}
ATTRS = {0xBEEFF00D: "STRIPPING_PROTECTION", 0x3BA06F8C: "PROOF_OF_ROTATION",
         0x559F8B02: "ROTATION_MIN_SDK_VERSION", 0xC2A6B3BA: "SIGNER_TARGETS_DEV_RELEASE",
         0xBF940529: "HYBRID_MIN_SDK_VERSION", 0x9F06B79C: "HYBRID_MAX_SDK_VERSION",
         0x9D6303F7: "PROOF_OF_ROTATION (stamp)", 0xE43C5946: "STAMP_TIME"}
CAPS = ("INSTALLED_DATA", "SHARED_USER_ID", "PERMISSION", "ROLLBACK", "AUTH")
SIGNER_BLOCKS = (0x7109871A, 0xF05368C0, 0x1B93AD61, 0x70E1C89F)


def find_eocd(buf):
    # Como ZipUtils.findZipEndOfCentralDirectoryRecord: la firma vale solo si su
    # comment length llega justo al final del fichero.
    for clen in range(min(len(buf) - 22, 65535) + 1):
        i = len(buf) - 22 - clen
        if buf[i:i + 4] == b"PK\x05\x06" and struct.unpack_from("<H", buf, i + 20)[0] == clen:
            return i
    return -1


def parse(path):
    with open(path, "rb") as f:
        buf = mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ)   # no carga el fichero entero
    idx = find_eocd(buf)
    if idx < 0:
        raise SystemExit("EOCD no encontrado")
    cd_off = struct.unpack_from("<I", buf, idx + 16)[0]
    if buf[cd_off - 16:cd_off] != MAGIC:
        return None, cd_off
    size_at_end = struct.unpack_from("<Q", buf, cd_off - 24)[0]
    blk_start = cd_off - 8 - size_at_end
    size_at_start = struct.unpack_from("<Q", buf, blk_start)[0]
    if size_at_start != size_at_end:                    # bloque malformado
        return (blk_start, size_at_start, size_at_end, []), cd_off
    pairs, p, end = [], blk_start + 8, cd_off - 24
    while p < end:
        if end - p < 8:                                 # no cabe el size of pair
            pairs.append(("MALFORMADO", f"quedan {end - p} bytes", p))
            break
        (plen,) = struct.unpack_from("<Q", buf, p)
        if plen < 4 or p + 8 + plen > end:              # par malformado
            pairs.append(("MALFORMADO", f"size of pair = {plen}", p))
            break
        (pid,) = struct.unpack_from("<I", buf, p + 8)
        pairs.append((pid, plen - 4, buf[p + 12:p + 8 + plen]))
        p += 8 + plen
    return (blk_start, size_at_start, size_at_end, pairs), cd_off


def lp(b, p=0):                       # bytes con prefijo uint32: (valor, offset siguiente)
    (n,) = struct.unpack_from("<I", b, p)
    if n > len(b) - p - 4:
        raise ValueError(f"prefijo de {n} bytes fuera de rango en el offset {p}")
    return b[p + 4:p + 4 + n], p + 4 + n


def seq(b):                           # secuencia de elementos con prefijo uint32
    p = 0
    while p < len(b):
        item, p = lp(b, p)
        yield item


def algs(b, label, ind, show=0):      # elementos uint32 alg + bytes con prefijo
    for item in seq(b):
        (alg,) = struct.unpack_from("<I", item)
        val = lp(item, 4)[0]
        tail = f"  {val[:show].hex()}…" if show else ""
        print(f"{ind}{label:<9} alg=0x{alg:04x} {ALGS.get(alg, '?'):<34}{len(val)} B{tail}")


def attributes(b, ind):
    for a in seq(b):
        (aid,), val = struct.unpack_from("<I", a), a[4:]
        print(f"{ind}attribute 0x{aid:08x} {ATTRS.get(aid, '?')}  valor={len(val)} B")
        if aid in (0x3BA06F8C, 0x9D6303F7):           # lineage: version + nodos
            print(f"{ind}  lineage version={struct.unpack_from('<I', val)[0]}")
            for i, node in enumerate(seq(val[4:]), 1):
                sd, p = lp(node)
                flags, nxt = struct.unpack_from("<II", node, p)
                caps = "|".join(c for bit, c in enumerate(CAPS) if flags >> bit & 1)
                print(f"{ind}  nodo #{i}: cert={len(lp(sd)[0])} B  sigAlgId=0x{nxt:04x} "
                      f"{ALGS.get(nxt, '?')}  sig={len(lp(node, p + 8)[0])} B")
                print(f"{ind}            flags=0x{flags:08x} → {caps}")
        elif len(val) in (4, 8):
            print(f"{ind}  valor = {int.from_bytes(val, 'little', signed=True)}")


def signers(pid, val):
    v3 = pid != 0x7109871A
    print(f"  bloque {NAMES[pid].split()[0]}: valor={len(val)} B, "
          f"secuencia de signers={len(lp(val)[0])} B")
    for s in seq(lp(val)[0]):
        sd, p = lp(s)
        sdk = " minSdkVersion=%d maxSdkVersion=%d" % struct.unpack_from("<II", s, p) if v3 else ""
        sigs, p = lp(s, p + 8 if v3 else p)
        digs, q = lp(sd)
        certs, q = lp(sd, q)
        attrs = lp(sd, q + 8 if v3 else q)[0]
        print(f"    signer:{sdk}")
        print(f"      signed data: digests={len(digs)} B certs={len(certs)} B attrs={len(attrs)} B")
        algs(digs, "digest", "        ", 12)
        for c in seq(certs):
            print(f"        certificate X.509 DER: {len(c)} B")
        if v3:
            print("        minSdkVersion=%d maxSdkVersion=%d  (copia firmada)"
                  % struct.unpack_from("<II", sd, q))
        attributes(attrs, "        ")
        algs(sigs, "signature", "        ")
        print(f"        public key SubjectPublicKeyInfo DER: {len(lp(s, p)[0])} B")


def stamp(val):                       # source stamp v2
    blk = lp(val)[0]
    cert, p = lp(blk)
    schemes, p = lp(blk, p)
    print(f"  source stamp: valor={len(val)} B")
    print(f"    certificate X.509 DER: {len(cert)} B  SHA-256={hashlib.sha256(cert).hexdigest()}")
    for sc in seq(schemes):           # uint32 esquema + firmas de su lista de digests
        algs(lp(sc, 4)[0], f"esquema {struct.unpack_from('<I', sc)[0]}", "    ")
    if p < len(blk):                  # atributos y sus firmas
        attrs, p = lp(blk, p)
        algs(lp(blk, p)[0], "atributos", "    ")
        attributes(lp(attrs)[0], "    ")


verbose = "-v" in sys.argv[1:]
for path in [a for a in sys.argv[1:] if a != "-v"]:
    res, cd_off = parse(path)
    name = path.rsplit("/", 1)[-1]
    if res is None:
        print(f"{name}: SIN APK Signing Block (CD en {cd_off})")
        continue
    blk_start, s1, s2, pairs = res
    print(f"== {name}")
    print(f"   inicio del bloque : {blk_start}   (multiplo de 4096: {blk_start % 4096 == 0})")
    print(f"   size (cabeza/cola): {s1} / {s2}   coinciden: {s1 == s2}")
    print(f"   offset del CD     : {cd_off}   total del bloque: {cd_off - blk_start}")
    for pid, plen, val in pairs:
        if pid == "MALFORMADO":
            print(f"   MALFORMADO en el offset {val}: {plen}")
            break
        print(f"   0x{pid:08x}  {plen:>9} bytes  {NAMES.get(pid, 'DESCONOCIDO')}")
    for pid, plen, val in pairs if verbose else []:
        try:
            if pid in SIGNER_BLOCKS:
                signers(pid, val)
            elif pid == 0x6DFF800D:
                stamp(val)
        except (ValueError, struct.error) as e:
            print(f"  0x{pid:08x}: no se puede decodificar: {e}")
    print()

Salida real sobre tres APK del muestrario (Termux de F-Droid, Kanaquiz de la web de su autor y el base.apk de Keep):

unzip -o com.google.android.keep_5.26.411.03.97-220679628_1arch_1dpi_24lang_5077c1df745152f19ddcb9e265a31428_apkmirror.com.apkm \
      base.apk -d keep_x
python3 dump_sigblock.py com.termux_1022.apk \
                         kanaquiz-v0.15.1-release.apk \
                         keep_x/base.apk
== com.termux_1022.apk
   inicio del bloque : 114868224   (multiplo de 4096: True)
   size (cabeza/cola): 4088 / 4088   coinciden: True
   offset del CD     : 114872320   total del bloque: 4096
   0x7109871a       1525 bytes  v2 (APK_SIGNATURE_SCHEME_V2_BLOCK_ID)
   0xf05368c0       1525 bytes  v3 (APK_SIGNATURE_SCHEME_V3_BLOCK_ID)
   0x42726577        978 bytes  padding (VERITY_PADDING_BLOCK_ID)

== kanaquiz-v0.15.1-release.apk
   inicio del bloque : 2793413   (multiplo de 4096: False)
   size (cabeza/cola): 12280 / 12280   coinciden: True
   offset del CD     : 2805701   total del bloque: 12288
   0x7109871a       1601 bytes  v2 (APK_SIGNATURE_SCHEME_V2_BLOCK_ID)
   0x504b4453       8234 bytes  dependency info (Google Play)
   0x42726577       2385 bytes  padding (VERITY_PADDING_BLOCK_ID)

== base.apk
   inicio del bloque : 17526784   (multiplo de 4096: True)
   size (cabeza/cola): 20472 / 20472   coinciden: True
   offset del CD     : 17547264   total del bloque: 20480
   0x7109871a       1751 bytes  v2 (APK_SIGNATURE_SCHEME_V2_BLOCK_ID)
   0x1b93ad61       7613 bytes  v3.1 (APK_SIGNATURE_SCHEME_V31_BLOCK_ID)
   0xf05368c0       1763 bytes  v3 (APK_SIGNATURE_SCHEME_V3_BLOCK_ID)
   0x6dff800d       3057 bytes  source stamp v2 (V2_SOURCE_STAMP_BLOCK_ID)
   0x2146444e       3973 bytes  frosting (Google Play)
   0x42726577       2219 bytes  padding (VERITY_PADDING_BLOCK_ID)

Los tres bloques miden 4.096, 12.288 y 20.480 bytes. El de Kanaquiz empieza en un offset no alineado (2.793.413) y no pasa nada: no tiene digest de verity, así que la condición de la «sección 6.3 · Los algoritmos de digest de contenido» no se aplica. El 0x2146444e de Keep es el frosting que describe la «sección 11 · El “frosting” de Google Play: 0x2146444e»: el volcador lo nombra porque lo tiene en NAMES. 0x70e1c89f no aparece en ninguno de estos tres; sí en el base.apk de com.phasora (volcado más abajo). Las comprobaciones del bloque y de los pares solo actúan sobre un bloque malformado, así que no cambian ninguna salida. Tomar la última firma PK\x05\x06 con rfind, como hace un volcador más simple, solo da otro resultado si el comentario del ZIP contiene esa secuencia; con un APK de prueba así, responde SIN APK Signing Block (CD en 0). En los tres ejemplos, el Central Directory hallado va precedido de la magic.

Con -v, sobre un APK de prueba sin código generado con aapt2 el 18 de octubre de 2026 y firmado con apksigner 37.0.0: K0, RSA de 2.048 bits, rotada a K1, RSA de 4.096, a partir de la API 33, y un sello RSA de 2.048 bits («sección 5.3 · El source stamp, 0x6dff800d»). Las claves se crearon con keytool -genkeypair -storetype PKCS12.

BT=~/Library/Android/sdk/build-tools/37.0.0
$BT/aapt2 link --manifest AndroidManifest.xml \
  -I ~/Library/Android/sdk/platforms/android-36/android.jar -o sin_firmar.apk  # minSdk 24
$BT/apksigner rotate --out lin.bin --old-signer --ks k0.p12 --ks-pass pass:pruebas \
  --new-signer --ks k1.p12 --ks-pass pass:pruebas
$BT/apksigner sign --ks k0.p12 --ks-pass pass:pruebas \
  --next-signer --ks k1.p12 --ks-pass pass:pruebas --lineage lin.bin \
  --rotation-min-sdk-version 33 --stamp-signer --ks sello.p12 --ks-pass pass:pruebas \
  --out rotado.apk sin_firmar.apk
python3 dump_sigblock.py -v rotado.apk
== rotado.apk
   inicio del bloque : 4096   (multiplo de 4096: True)
   size (cabeza/cola): 12280 / 12280   coinciden: True
   offset del CD     : 16384   total del bloque: 12288
   0x7109871a       1441 bytes  v2 (APK_SIGNATURE_SCHEME_V2_BLOCK_ID)
   0x1b93ad61       4899 bytes  v3.1 (APK_SIGNATURE_SCHEME_V31_BLOCK_ID)
   0xf05368c0       1453 bytes  v3 (APK_SIGNATURE_SCHEME_V3_BLOCK_ID)
   0x6dff800d       1937 bytes  source stamp v2 (V2_SOURCE_STAMP_BLOCK_ID)
   0x42726577       2466 bytes  padding (VERITY_PADDING_BLOCK_ID)
  bloque v2: valor=1441 B, secuencia de signers=1437 B
    signer:
      signed data: digests=44 B certs=787 B attrs=12 B
        digest    alg=0x0103 RSA_PKCS1_V1_5_WITH_SHA256        32 B  67dd7561e67e78dc15627439…
        certificate X.509 DER: 783 B
        attribute 0xbeeff00d STRIPPING_PROTECTION  valor=4 B
          valor = 3
        signature alg=0x0103 RSA_PKCS1_V1_5_WITH_SHA256        256 B
        public key SubjectPublicKeyInfo DER: 294 B
  bloque v3.1: valor=4899 B, secuencia de signers=4895 B
    signer: minSdkVersion=33 maxSdkVersion=2147483647
      signed data: digests=76 B certs=1299 B attrs=2402 B
        digest    alg=0x0104 RSA_PKCS1_V1_5_WITH_SHA512        64 B  736cb7eea40bd8a6ef79dab3…
        certificate X.509 DER: 1295 B
        minSdkVersion=33 maxSdkVersion=2147483647  (copia firmada)
        attribute 0x3ba06f8c PROOF_OF_ROTATION  valor=2394 B
          lineage version=1
          nodo #1: cert=783 B  sigAlgId=0x0103 RSA_PKCS1_V1_5_WITH_SHA256  sig=0 B
                    flags=0x00000017 → INSTALLED_DATA|SHARED_USER_ID|PERMISSION|AUTH
          nodo #2: cert=1295 B  sigAlgId=0x0000 ?  sig=256 B
                    flags=0x00000017 → INSTALLED_DATA|SHARED_USER_ID|PERMISSION|AUTH
        signature alg=0x0104 RSA_PKCS1_V1_5_WITH_SHA512        512 B
        public key SubjectPublicKeyInfo DER: 550 B
  bloque v3: valor=1453 B, secuencia de signers=1449 B
    signer: minSdkVersion=24 maxSdkVersion=32
      signed data: digests=44 B certs=787 B attrs=12 B
        digest    alg=0x0103 RSA_PKCS1_V1_5_WITH_SHA256        32 B  67dd7561e67e78dc15627439…
        certificate X.509 DER: 783 B
        minSdkVersion=24 maxSdkVersion=32  (copia firmada)
        attribute 0x559f8b02 ROTATION_MIN_SDK_VERSION  valor=4 B
          valor = 33
        signature alg=0x0103 RSA_PKCS1_V1_5_WITH_SHA256        256 B
        public key SubjectPublicKeyInfo DER: 294 B
  source stamp: valor=1937 B
    certificate X.509 DER: 789 B  SHA-256=103fbb15f9c01e64419d8cdb8554414bddfb742a169d64b9c340670aeed412de
    esquema 1 alg=0x0103 RSA_PKCS1_V1_5_WITH_SHA256        256 B
    esquema 2 alg=0x0103 RSA_PKCS1_V1_5_WITH_SHA256        256 B
    esquema 3 alg=0x0103 RSA_PKCS1_V1_5_WITH_SHA256        256 B
    atributos alg=0x0103 RSA_PKCS1_V1_5_WITH_SHA256        256 B
    attribute 0xe43c5946 STAMP_TIME  valor=8 B
      valor = 1792345211

El bloque v2 lleva STRIPPING_PROTECTION = 3; el v3, el firmante original para [24, 32] con ROTATION_MIN_SDK_VERSION = 33, y el v3.1, el rotado con su lineage de dos nodos y las capacidades por defecto, 0x17. El sello firma tres esquemas —1, 2 y 3, no el v3.1— y sus atributos, y el SHA-256 de su certificado es el contenido de stamp-cert-sha256. El bloque empieza en 4.096 sin verity: es el relleno de la «sección 8 · El bloque de relleno».

Con -v, sobre un bloque v3.2 de una app de Google Play sacada con adb (com.phasora, pieza base.apk, del sorteo):

== base.apk
   inicio del bloque : 16379904   (multiplo de 4096: True)
   size (cabeza/cola): 40952 / 40952   coinciden: True
   offset del CD     : 16420864   total del bloque: 40960
   0x7109871a       2622 bytes  v2 (APK_SIGNATURE_SCHEME_V2_BLOCK_ID)
   0x70e1c89f      24735 bytes  v3.2 (APK_SIGNATURE_SCHEME_V32_BLOCK_ID)
   0xf05368c0       2646 bytes  v3 (APK_SIGNATURE_SCHEME_V3_BLOCK_ID)
   0x6dff800d       3593 bytes  source stamp v2 (V2_SOURCE_STAMP_BLOCK_ID)
   0x2146444e       3838 bytes  frosting (Google Play)
   0x42726577       3422 bytes  padding (VERITY_PADDING_BLOCK_ID)
  bloque v3.2: valor=24735 B, secuencia de signers=24731 B
    signer: minSdkVersion=37 maxSdkVersion=2147483647
      signed data: digests=76 B certs=1424 B attrs=3420 B
        digest    alg=0x0104 RSA_PKCS1_V1_5_WITH_SHA512        64 B  a8ed0f9f645d91d5837b7418…
        certificate X.509 DER: 1420 B
        minSdkVersion=37 maxSdkVersion=2147483647  (copia firmada)
        attribute 0x3ba06f8c PROOF_OF_ROTATION  valor=3412 B
          lineage version=1
          nodo #1: cert=1420 B  sigAlgId=0x0104 RSA_PKCS1_V1_5_WITH_SHA512  sig=0 B
                    flags=0x0000001f → INSTALLED_DATA|SHARED_USER_ID|PERMISSION|ROLLBACK|AUTH
          nodo #2: cert=1420 B  sigAlgId=0x0000 ?  sig=512 B
                    flags=0x00000017 → INSTALLED_DATA|SHARED_USER_ID|PERMISSION|AUTH
        signature alg=0x0104 RSA_PKCS1_V1_5_WITH_SHA512        512 B
        public key SubjectPublicKeyInfo DER: 550 B
    signer: minSdkVersion=37 maxSdkVersion=2147483647
      signed data: digests=76 B certs=5641 B attrs=7637 B
        digest    alg=0x0501 ML_DSA                            64 B  a8ed0f9f645d91d5837b7418…
        certificate X.509 DER: 5637 B
        minSdkVersion=37 maxSdkVersion=2147483647  (copia firmada)
        attribute 0x3ba06f8c PROOF_OF_ROTATION  valor=7629 B
          lineage version=1
          nodo #1: cert=1420 B  sigAlgId=0x0104 RSA_PKCS1_V1_5_WITH_SHA512  sig=0 B
                    flags=0x0000001f → INSTALLED_DATA|SHARED_USER_ID|PERMISSION|ROLLBACK|AUTH
          nodo #2: cert=5637 B  sigAlgId=0x0000 ?  sig=512 B
                    flags=0x00000017 → INSTALLED_DATA|SHARED_USER_ID|PERMISSION|AUTH
        signature alg=0x0501 ML_DSA                            3309 B
        public key SubjectPublicKeyInfo DER: 1974 B
  bloque v3: valor=2646 B, secuencia de signers=2642 B
    signer: minSdkVersion=24 maxSdkVersion=2147483647
      signed data: digests=76 B certs=1424 B attrs=24 B
        …
        attribute 0xbf940529 HYBRID_MIN_SDK_VERSION  valor=4 B
          valor = 37
        attribute 0x9f06b79c HYBRID_MAX_SDK_VERSION  valor=4 B
          valor = 2147483647

El volcado se abrevia con «…» en los campos del v3 que no cambian; el volcador imprime todo. El v3.2 lleva dos firmantes con la misma lista de SDK [37, ∞): el clásico (RSA con SHA-512) y el poscuántico (ML-DSA, cuya firma mide 3.309 bytes con una clave pública de 1.974). El v3 declara con HYBRID_MIN_SDK_VERSION y HYBRID_MAX_SDK_VERSION desde qué SDK vale el bloque híbrido. El sello cubre los esquemas 1, 2 y 3, y su marca de tiempo (STAMP_TIME) vale 1787639111, el 25 de agosto de 2026.

10. Censo real del muestrario

Esta sección mide qué lleva el bloque en la práctica. Los números salen de 15.183 piezas de 7.045 apps del muestrario («El muestrario»). Una pieza es un APK; una app es lo que se descargó una vez (un .apk, un .apkm, un .xapk o una carpeta de adb), y salvo que se diga otra cosa, las cifras por app son las de su pieza base o única. No sumes los grupos entre sí: hay 262 ficheros que están a la vez en F-Droid y en IzzyOnDroid. Todo se ha medido leyendo los bytes de los ficheros; no hemos ejecutado ni instalado ningún APK.

Para situarte: F-Droid aporta 4.766 apps (una pieza cada una), IzzyOnDroid 1.402, las más instaladas de Google Play 658 apps con 7.893 piezas, el sorteo de Play 369 apps con 1.272 piezas, el mercado chino 100 y las webs de los autores 7. Por formatos: 6.220 .apk, 388 .apkm, 72 .xapk (450 piezas) y 365 carpetas de adb (1.225 piezas).

10.1 Frecuencia por identificador

La tabla cuenta, por fuente, las apps cuya pieza base o única lleva cada par. Qué mirar: el sello y el frosting son de Google Play; v3.1 y v3.2, de apps recientes de Play; la dependency info, de los APK que el desarrollador compila con el Android Gradle Plugin y sube tal cual; Walle, del mercado chino.

F-Droid (4.766) IzzyOnDroid (1.402) Play, más instaladas (658) Play, sorteo (369) Mercado chino (100) Webs (7)
sin APK Signing Block 399 (8 %) 16 (1 %) 4 (1 %) 0 1 0
v2 4.355 (91 %) 1.380 (98 %) 647 (98 %) 369 (100 %) 99 (99 %) 7
v3 3.060 (64 %) 245 (17 %) 593 (90 %) 328 (89 %) 37 (37 %) 2
v3.1 0 0 63 (10 %) 3 (1 %) 1 1
v3.2 0 0 0 9 (2 %) 0 0
sello v2 0 6 (0,4 %) 518 (79 %) 324 (88 %) 0 0
relleno 4.362 (92 %) 1.374 (98 %) 638 (97 %) 368 (100 %) 67 (67 %) 6
frosting 0 1 (0,1 %) 501 (76 %) 368 (100 %) 0 0
dependency info 103 (2 %) 412 (29 %) 43 (7 %) 38 (10 %) 8 (8 %) 3
Walle 0 0 1 (0,2 %) 0 24 (24 %) 0

Contadas por pieza salen otras proporciones, porque una app de Play tiene muchos splits. El frosting está en 501 de 658 apps de las más instaladas (76 %), pero solo en 501 de 7.893 piezas (6 %), porque solo lo lleva la base o el APK único. En total hay 420 piezas sin bloque, 592 con dependency info, 870 con frosting, 8.982 con sello, 1.093 con v3.1, 34 con v3.2, 27 con Walle y 683 con 0xfa1cfabe. Ejemplos de la tabla: com.termux 1022 de F-Droid (v2, v3 y relleno), el base.apk de Keep, com.phasora › base.apk (v3.2) y Kanaquiz de la web de su autor (v2, dependency info y relleno).

Los conjuntos de pares más frecuentes (sin orden; el orden está en la «sección 3 · Layout byte a byte») cambian mucho con la fuente. En F-Droid casi todas las apps son v2 + v3 + relleno (3.046 de 4.766) o v2 + relleno (1.202). En IzzyOnDroid domina v2 + relleno (723 de 1.402), y 406 llevan además dependency info. En las más instaladas de Google Play, la combinación más común es v2 + v3 + sello + frosting + relleno (367 de 658); otras son v2 + v3 + relleno (52), v2 + v3 + sello + relleno (52), v2 + v3.1 + v3 + sello + frosting + relleno (51) y, con 0xfa1cfabe, v2 + v3 + sello + 0xfa1cfabe + frosting + relleno (35). En el sorteo, esa combinación común está en 288 de 369, y 38 apps traen v2 + dependency info + relleno + frosting. En el mercado chino hay 16 apps con v2 solo, y la más común es v2 + v3 + relleno (19 de 100).

Seis lecturas:

  1. v2 está en casi todas las apps, no en todas. Faltan en 420 piezas sueltas, que no tienen bloque, casi todas de F-Droid (el 8 % de sus apps). Son APK firmados solo con v1, y aquí se nota la obligación de targetSdk ≥ 30: ninguno llega a 30. Entre los de targetSdk menor de 30, en cambio, son muchos: el 61 % en F-Droid. Los APK sin v2 pero con bloque son v3 solitarios: APK únicos con minSdk 28 o más (12 de F-Droid, 6 de IzzyOnDroid) o splits de Play que solo llevan v3 (111 piezas de 11 apps). Los 1.571 splits de idioma de menos de 50 KB llevan v2. Ejemplos: pro.rudloff.lineageos_updater_shortcut 2 (F-Droid; targetSdk 29, solo v1 de jarsigner) y tk.al54.dev.badpixels 4 (F-Droid; targetSdk 24).
  2. Falta el relleno en 67 piezas, todas APK sueltos, y la mitad del mercado chino (una de cada tres de sus apps). Ninguna mide un múltiplo de 4096, lo que indica una cadena de firma que no añade el par de relleno. La mayoría lleva solo v2. La herramienta de v1, la única pista de quién firmó, está muy repartida (apksigner, apksig con el MANIFEST.MF del Android Gradle Plugin, jarsigner…), así que no podemos decir cuál fue. Ejemplos: org.briarproject.briar.android 10522 (bloque de 1.415 B), org.briarproject.mailbox 10009 (1.397 B), ambos de F-Droid, y com.viber.voip 9.6.5.5 de la web de Viber (1.544 B). Son distintas de las 61 piezas con relleno cuyo tamaño tampoco es múltiplo («sección 8 · El bloque de relleno»).
  3. El source stamp es de Google Play. Está en el 98 % de las piezas de las más instaladas de Play y en el 96 % de las del sorteo, y en ninguna de F-Droid, del mercado chino ni de las webs. Todas las piezas con sello comparten un único certificado, el de Google, y apksigner lo confirma. No lo produce bundletool por sí solo: lo pone Play al distribuir («sección 5.3 · El source stamp, 0x6dff800d»). Domina en los contenedores porque casi todas sus piezas pasaron por Play; seis APK de IzzyOnDroid lo llevan por la misma razón. Los .apk sueltos de las más instaladas, en cambio, solo lo llevan en un tercio. Ejemplos: TickTock-TikTok+Live+Wallpaper 36.0 (APKPure) y com.leaf.explorer 142 (IzzyOnDroid).
  4. v3.1 es cosa de Google Play. Lo llevan el 10 % de las apps más instaladas y ninguna de F-Droid ni de IzzyOnDroid. Siempre va con v3: la regla V31_BLOCK_FOUND_WITHOUT_V3_BLOCK no se rompe nunca, y todas declaran ROTATION_MIN_SDK_VERSION en el v3. La «sección 5.4 · La rotación de clave en la práctica» cuenta cómo se usa.
  5. El bloque de dependencias lo añade el Android Gradle Plugin al compilar un APK en release. Aparece solo en APK únicos, sobre todo de IzzyOnDroid (casi tres de cada diez de sus apps), y en ninguna base ni split que genere Play. En un AAB, el Android Gradle Plugin guarda esos datos como el fichero BUNDLE-METADATA/com.android.tools.build.libraries/dependencies.pb, y no en el bloque de firma de los APK que bundletool o Play generan después. Los de Play con este par son APK que el autor firmó con el plugin y que llegan tal cual. Casi siempre empiezan sin alinear, porque el plugin rellena el bloque pero no lo alinea («sección 8 · El bloque de relleno»), y su v1, si la hay, es casi siempre del plugin. El escáner de fdroidserver cuenta 0x504b4453 como un problema al revisar un APK, lo que da a los proyectos de F-Droid un motivo para apagarlo; aun así lo llevan 103 apps de F-Droid, así que no lo apagan todas. Ejemplos: Kanaquiz de la web de su autor (bloque de 12.288 B desde 2.793.413, no alineado) y moe.henry_zhr.force_dark 2 de IzzyOnDroid (dependency info de 206 B, bloque en 3.828).
  6. Los APK sueltos, para contraste. Entre los APK sueltos de Play, v3.1 es raro, y el frosting y el sello aparecen en una parte: más de uno de cada cuatro de los de las más instaladas llevan frosting, y los 50 del sorteo (carpetas de adb con un solo APK) lo llevan todos. Ejemplos: com.google.android.apps.mapslite 165.0 (v3.1), com.samsung.android.spdclient 6.1.01 (frosting), ambos de APKMirror, y com.tortillum.signalid 3 de IzzyOnDroid (frosting, un binario que pasó por Play). Ninguna de las 4.766 apps de F-Droid lleva v3.1 ni frosting.

10.2 Alineación

El tamaño del bloque y el offset donde empieza son dos cosas distintas. El tamaño lo decide el relleno; el inicio, la herramienta que firma. El tamaño es múltiplo de 4096 en casi todas las piezas, salvo en el mercado chino (61 de 99); las excepciones son 67 piezas sin relleno y 61 con un par añadido después del relleno («sección 8 · El bloque de relleno»). El inicio alineado depende mucho de la fuente, como cuenta la «sección 8 · El bloque de relleno», y los que no empiezan alineados son siempre APK sueltos, nunca una base ni un split.

La tabla cuenta piezas según tengan o no verity y empiecen o no alineadas. Qué mirar: la columna «con verity y sin alinear» es siempre 0, y es la correlación que confirma la «sección 6.3 · Los algoritmos de digest de contenido».

Fuente sin verity, sin alinear sin verity, alineado con verity, sin alinear con verity, alineado
F-Droid 1.352 2.144 0 871
IzzyOnDroid 1.128 219 0 39
Play, más instaladas 59 7.812 0 18
Play, sorteo 40 1.229 0 3
Mercado chino 39 42 0 18
Webs de los autores 4 3 0 0

Cero excepciones en las 949 piezas con un digest VERITY_CHUNKED_SHA256: todas empiezan en múltiplo de 4096, y las que no empiezan alineadas no llevan verity. Todas las piezas con verity y alineadas, salvo una de F-Droid con hueco 0, tienen ceros delante del bloque (947 de 948). La condición del código no es teórica. Ejemplo: pro.rudloff.search_to_browser 2 (F-Droid) lleva verity (0x0421 junto a 0x0103) y el bloque en 8.192, con 4.073 bytes de ceros delante. Lo que no hemos podido comprobar es que apksigner verify falle ante un bloque no alineado con verity: no hay ninguno.

10.3 El mismo programa en F-Droid y en IzzyOnDroid

Dos APK de la misma versión no son iguales si no los firma el mismo. F-Droid compila el código y lo firma con su propia clave; IzzyOnDroid suele publicar el APK del desarrollador. Hay 262 ficheros idénticos en las dos tiendas (mismo SHA-256), y otros 218 paquetes con un fichero distinto en cada una. En esos 218, el certificado coincide en menos de un tercio. Y las diferencias van casi siempre en el mismo sentido: F-Droid lleva v3, alinea el bloque y añade verity; IzzyOnDroid no, y es el que trae la dependency info. El relleno lo llevan casi siempre las dos copias. Ejemplo: fr.smarquis.sleeptimer 16300. En F-Droid lleva v2 + v3 + relleno con el bloque alineado en 16.384 y 827 bytes de ceros delante. En IzzyOnDroid lleva v2 + relleno con el bloque en 13.292. Otro par: com.martinmimigames.simplefileexplorer 20 (bloque en 32.768 en F-Droid y en 31.493 en IzzyOnDroid).

10.4 Canales de distribución del mercado chino

Las tiendas chinas añaden a cada APK el nombre del canal por el que se descarga, para saber de dónde viene cada instalación. Casi la mitad de las apps chinas lo llevan dentro del bloque de firma, con Walle, VasDolly u otros identificadores sin documentar (hay apps con más de uno). Depende de la tienda: lo llevan una de cada tres apps de 360 y tres de cada cuatro de las bajadas a mano de Tencent. Es raro que el canal vaya en otro sitio: una app lo guarda en META-INF/config_channel.txt (com.suning.mobile.ebuy 596) y otra en el comentario del ZIP (channelId=2002, en la pieza más grande, com.tencent.tmgp.yongyong.mrzh 744; sin bloque).

Estas apps son más viejas que las de Play: más de la mitad llevan solo v1 y v2 y usan una clave RSA de 1.024 bits, y un tercio no tiene relleno. Contenidos observados: Walle {"channel_name":"360助手","channel":"30010"} (46 B, en com.ifeng.newvideo 73440) y {"meta_umeng_channel": "tengxun_8478_64"} (41 B, en com.luna.music 100213030); los de VasDolly, {"pn":"SLL","sf":0} (19 B), 301746 (6 B) y YingYongBao (11 B). Los IDs sin nombre se describen en la tabla de la «sección 4 · Identificadores de bloque conocidos»; ninguno tiene fuente pública. Según cómo se cuente, el canal está en 31 de 100 apps (solo el bloque de canal de Walle o VasDolly), en 46 (con los channelId, en el bloque) o en 48 (en cualquier sitio: bloque, META-INF y comentario del ZIP).

WeChat sirve de comparación. La versión de 360 (com.tencent.mm 3200) y la de Play (com.tencent.mm 8.0.79, de APKMirror, base.apk) usan el mismo certificado RSA de 1.024 bits. La de 360 trae solo v2 en un bloque de 1.177 bytes y sin relleno; la de Play trae v2, v3, sello, frosting y relleno en un bloque de 12.288 bytes. WhatsApp tiene el mismo certificado DSA de 1.024 bits en su web (con el par v3.1 repetido) y en Play (com.whatsapp 2.26.42.9, de APKMirror, base.apk).

10.5 Protectores y firma

Un protector comercial empaqueta el APK y lo vuelve a firmar, y lo que queda en el bloque depende de qué protector sea. En Google Play manda PairIP, que lleva casi todo el sorteo protegido; los protectores clásicos (DexProtector y otros) son pocos. En el mercado chino mandan Bangcle/SecNeo e Ijiami.

Los protectores de Google Play dejan el bloque como el de cualquier app de Play, casi siempre v2 + v3 y con relleno. Los chinos, en cambio, vuelven a v1 + v2 en dos de cada tres apps, llevan a menudo una clave RSA de 1.024 bits y un tercio no tiene relleno. 0xfa1cfabe solo aparece en apps con PairIP: 35 de las 45 de las más instaladas y 23 de las 99 del sorteo. Ejemplos: com.eslamegyp.asd26 › base.apk (PairIP con 0xfa1cfabe) y com.fil_access.app › base.apk (PairIP sin 0xfa1cfabe), ambos del sorteo. La detección de protectores sale del medidor nucleo_codigo del sitio y puede cambiar con él.

10.6 Cómo saber con qué herramienta se firmó un APK

v2 y v3 no dicen qué programa los escribió. Solo la v1 deja una pista (Created-By). Pero el bloque, su alineación y lo que lleva dentro dejan huellas que sirven de indicio. Qué mirar en la tabla: la columna de la izquierda es lo que se ve; la del centro, lo que lo suele producir. Los recuentos son de piezas sueltas distintas (6.267, sin repetir los 262 ficheros de F-Droid e IzzyOnDroid), salvo las dos últimas filas, que son de todas las piezas.

Lo que se ve Lo que lo suele producir Cuántas piezas
Sin APK Signing Block; v1 de jarsigner jarsigner en APK anteriores al targetSdk 30 404 de 420
Relleno; bloque alineado a 4.096; ceros delante; v1 de apksigner apksigner 3.061 de 3.428
Lo anterior más una firma verity (0x0421) apksigner --verity-enabled; en F-Droid, con su DN 947 de las 948 con verity
Relleno; bloque sin alinear; 0 bytes delante; v1 del Android Gradle Plugin, o sin v1 Android Gradle Plugin 2.346
Lo anterior más dependency info (0x504b4453) Android Gradle Plugin 572 de 592
Sin relleno; el tamaño no es múltiplo de 4.096 Una cadena que no añade el relleno 67
Sello 0x6dff800d con el certificado de Google; frosting Google Play, al distribuir 8.982 y 870 (no solo sueltas)
Walle, VasDolly u otro ID de canal Un empaquetador de canales de las tiendas chinas ver la «sección 10.4 · Canales de distribución del mercado chino»

Detalle de las huellas: con relleno, alineado y ceros delante hay 3.428 piezas, con v1 de apksigner en 3.061, de apksig con el MANIFEST.MF del plugin en 186, ninguna v1 en 127, de SignApk en 50 y otra en 4. Con relleno, sin alinear y 0 ceros delante hay 2.346, sin v1 en 1.548, del plugin en 764, de apksig con el MANIFEST.MF del plugin en 33 y otra en 1. Sin bloque, 420: jarsigner en 404 y el resto repartido entre apksig, apksigner, el plugin y SignApk. Con dependency info hay 592 (572 sin alinear y 20 alineadas) y con verity 948 (apksigner 782, apksig con el MANIFEST.MF del plugin 152, sin v1 11, SignApk 3). El DN del certificado también ayuda. Aquí cada pieza cuenta solo en su huella exacta, así que las que llevan además verity, sello u otros pares salen de la primera cuenta y los totales no cuadran con los de arriba: con ceros delante y alineado, sin más marcas, la mayoría son de F-Droid (1.674 frente a 704 de otros); con verity y nada más, 863 de F-Droid y 60 de otros; sin bloque, 398 de F-Droid y 22 de otros.

Es un indicio, no una prueba. Lo que construye el Android Gradle Plugin puede firmarlo después una tienda con su clave, como hace F-Droid, y las 20 piezas con dependency info y verity a la vez lo muestran. Con datos estáticos no sabemos qué herramienta hizo la última firma. Ejemplos: org.vi_server.red_screen 3 (F-Droid; apksigner, alineado), moe.henry_zhr.force_dark 2 (IzzyOnDroid; plugin), pro.rudloff.search_to_browser 2 (F-Droid; verity) y pro.rudloff.lineageos_updater_shortcut 2 (F-Droid; jarsigner).

10.7 Motores de juego y asset packs

El motor (Flutter, Unity, React Native) no deja una huella propia en el bloque: en las bases de Play, las apps hechas con cada motor llevan el mismo conjunto de pares que las demás, v2 + v3 + sello + frosting + relleno. Es una lectura de esos conjuntos, no una prueba. Los asset packs y los módulos sin código sí tienen una regla: todos llevan sello y ninguno frosting. Ejemplo: com.adobe.reader 26.10.0.50639.Beta › split_SAMSDKNativeDF.apk (APKMirror; módulo sin código con v2 + v3 + sello + relleno).

11. El «frosting» de Google Play: 0x2146444e

El base.apk de Google Keep lleva un bloque más, que no está en apksig: 0x2146444e, 3.973 bytes, entre el source stamp y el relleno («sección 9 · El volcador», tercer volcado).

Es el bloque de «frosting» de Google Play. No está en apksig porque no lo escribe la cadena de firma de Android: lo añade Google Play al distribuir, después de que el desarrollador haya firmado. Es una firma adicional, hecha con una clave de Google, que permite a Play Protect saber si un APK concreto salió de Play. El enumerado BlockId de avast/apkverifier (la implementación que lo documenta) lo llama blockIdFrosting = 0x2146444e. Los APK reales lo confirman: no aparece fuera de Play ni en ningún split, y su firma ECDSA verifica en las 57 piezas comprobadas con la clave de Play que publica avast/apkverifier; con un bit cambiado, en ninguna.

Los primeros bytes de su valor confirman que es Protocol Buffers y no una firma con el formato de las de Android (Keep 5.26.411.03.97):

ba 1e 94 1e 08 01 10 01 18 01 20 9c fa e1 fa b2 34 2a fe 1d 42 0c 0a 02 08 1e 30 03 30 02
30 04 30 05 4a 0b 0a 09 08 cc 9b 9d 69 1a 02 08 20 52 20 0a 1e ff ff ff ff ff ff fd ff ff

ba 1e y 94 1e son dos longitudes (3.898 y 3.860 bytes). Después empieza el mensaje: 08 01 10 01 18 01 son los campos 1, 2 y 3 con valor 1, y 20 … es el campo 4. Los valores de esos tres campos no son siempre los mismos: en una muestra de 57 piezas, el campo 1 vale 1 en 35, 2 en 18 y 3 en 4; el campo 2 vale 1 en 31 y 0 en 26; el campo 3 vale 1 en 16 y 0 en 41 (0 es un valor nulo o un campo ausente); solo 6 tienen los tres a 1. El esquema .proto no es público. La estructura exterior que publica avast/apkverifier (signingblock/frosting.go) la hemos reproducido sobre 493 de las 870 piezas con frosting: 364 carpetas de adb, 70 .xapk, 57 .apk y 2 .apkm (Keep y Calculator). Los demás .apkm no los hemos decodificado. Esto es lo que pudimos comprobar en ellas:

  • La firma es un ECDSA-Sig-Value DER de 70 a 72 bytes (14 piezas de 70, 29 de 71 y 14 de 72, porque la P-256 tiene longitud variable). Verifica con la clave pública de Play que frosting.go copia de la tienda («from com.android.vending 11.2.14») en las 57 piezas de una muestra fija (carpetas de adb del sorteo: 26 bases y 10 únicas; .apk únicos de las más instaladas: 20; .apk de IzzyOnDroid: 1), con una sola clave en las 57. El valor es varint(n), n bytes firmados y la firma. Los n bytes son varint(m), el mensaje protobuf de m bytes y una lista de metadatos con el SHA-256 del fichero. El SHA-256, recalculado con el algoritmo de ese fichero, coincide en 5 de 5. Con un bit cambiado, la firma no verifica en ninguna.
  • En el protobuf, 5.8.1.1 es el minSdkVersion: coincide con el manifiesto en 493 de 493 frostings decodificados. 5.9.1.1 es el versionCode, cuando está (en 145 de 493, y siempre coincide; nunca distinto). 5.12.1.5 no es el minSdk: es mayor en 313, igual en 80 y falta en 100; vale 29 en 259, 31 en 47, 32 en 43, 28 en 11, 23 en 9, 21 en 7, 24 en 6, 30 en 5, 26 en 3, 22 en 2 y 34 en 1. Su significado queda abierto.
  • 5.12.2.2.1 es el SHA-256 del propio APK base antes de recibir el frosting: quitando el par 0x2146444e y recalculando el relleno a 4096, coincide en las 5 bases que rehicimos. Cada 5.12.2.3 es un split, con su SHA-256 y su calificador. La lista no es la de lo que recibió el dispositivo: es la de todos los config splits que Play puede generar para esa base (una mediana de 83 por base, p10 2, p90 86, máximo 131; 386 listas). Es una interpretación: en la práctica la lista trae todos los config splits de la base de las apps leídas. Por eso en las carpetas sacadas con adb aparecen todos los config splits de la base (827 de 827) y también en .apkm (27 de 27) y .xapk (344 de 346), pero nunca un módulo ni un asset pack (30 piezas de carpetas y 11 de .xapk quedan fuera). Cobertura de las piezas que no son la base: carpetas de adb 293 de 314 con todas en la lista (21 con solo algunas), .xapk 64 de 70 con todas (6 con algunas) y .apkm 2 de 2. Casos fuera: config.pt y config.in de un .xapk de APKCombo, como Sweet+Selfie_+AI+Camera+Editor 5.7.1776 (APKPure) › config.pt.apk. Ejemplos: Keep (26 de 26 piezas en una lista de 88), Calculator (com.google.android.calculator 9.3, de APKMirror, base.apk; 1 de 1 en una lista de 7), com.dmluh.lesmqxd › base.apk (lista de 83 splits, 3 de las 4 piezas además de la base están en ella y el asset pack split_quandui.apk no) y de.systembau.prourlaubapp › base.apk (lista de 81 splits).
  • El campo 4 tiene el tamaño de una marca de tiempo en milisegundos, y el análisis público lo lee como la fecha de la firma. En el muestrario esa lectura es posible, pero no es la fecha de la firma: cae entre 90,0 y 179,9 días después de la marca de tiempo del sello (31 de 31 piezas con sello y campo 4; mediana 93,0) y nunca más de 93 días después de la descarga (0 de 493). Respecto a la fecha de descarga, cae de −2.183 a +92,2 días (mediana 16,2; anterior a la descarga en 217 piezas y posterior en 276). En Keep, el sello es del 19 de octubre de 2026 y el campo 4, del 19 de enero de 2027, 92 días más tarde. Parece un plazo de unos tres meses (una caducidad), no una fecha de firma; es una hipótesis, y su significado queda abierto.

Su presencia ya es un indicador útil, sin necesidad de verificarla. Va en bases y APK únicos, nunca en splits. Lo llevan tres de cada cuatro apps de las más instaladas de Play y casi todas las del sorteo; fuera de Play, solo una de IzzyOnDroid. En los contenedores (.apkm, .xapk) y en las carpetas de adb está casi siempre; en los .apk sueltos, en algo más de uno de cada cuatro. Entre las aplicaciones de Google con frosting están Keep, Maps (com.google.android.apps.maps 26.42.00.998169724.W, de APKMirror, base.apk), YouTube (com.google.android.youtube 21.41.531, de APKMirror, base.apk) y Duolingo (com.duolingo 6.102.4, de APKMirror, base.apk). Su ausencia no descarta Play: 158 bases o APK únicos de Play no lo llevan (157 de las más instaladas y 1 del sorteo), y 59 de ellos llevan el sello de Play. Un ejemplo sin frosting y con sello es TickTock-TikTok+Live+Wallpaper 36.0 (APKPure).

Los .apkm de APKMirror conservan el frosting porque copian el APK tal cual: lo llevan 378 de las 388 bases, y en las 5 bases que rehicimos sin el par, el SHA-256 coincide con el que declara el frosting. Con esto solo podemos decir que APKMirror no modifica el APK de Play en esas bases. Que un .apkm y un APK sacado con adb de la misma versión sean idénticos byte a byte, o que APKPure vuelva a firmar los .apk que fusiona, no lo hemos medido.

11.1 Lo que recibe un dispositivo

Las carpetas sacadas con adb (todas del sorteo de Play) son lo único del muestrario que refleja lo que Play entrega a un teléfono. En todas menos una la base lleva frosting; ningún split lo lleva. Todas las piezas de una misma app comparten certificado de firma y sello. La lista de splits del frosting recoge todos los config splits de la base, pero no los módulos ni los asset packs. Hay dependency info en 38 carpetas de un solo APK. Y es el único lugar del muestrario donde aparece el bloque v3.2 (9 apps, nunca en .apkm ni .xapk). Qué recibiría otro dispositivo, con otra ABI u otra versión de Android, no lo hemos medido. Ejemplos: com.phasora › base.apk (v3.2) y com.dmluh.lesmqxd › base.apk (base y 4 piezas más, frosting con lista de 83 splits).

Para una herramienta de análisis, el sello y el frosting son la evidencia estructural más barata de que un APK pasó por Google Play, más fiable que el nombre del fichero o que el origen declarado. Dicen por dónde pasó el binario, no por dónde llegó: un APK de IzzyOnDroid (com.tortillum.signalid 3) lleva un frosting que verifica con la clave de Play, y seis más llevan el sello. El sello es la evidencia más amplia (8.982 piezas, también en los splits; com.android.stamp.source en 825); el frosting es más específico (870 piezas, solo bases y APK únicos; identifica la pieza y su lista de splits).

Fuentes

  1. APK signature scheme v2 — Android Open Source Project — https://source.android.com/docs/security/features/apksigning/v2 Consultado el 12 de agosto de 2026. De aquí salen el layout del bloque de la «sección 3 · Layout byte a byte», la cita sobre la magic, el algoritmo de digest por chunks de la «sección 6.2 · El troceado» con sus prefijos 0xa5 y 0x5a, la estructura interna de la «sección 5 · Estructura interna de un bloque v2 o v3» y la tabla de algoritmos de firma de la «sección 7 · Algoritmos de firma» con los rangos de tamaño de clave. Consultado de nuevo el 18 de octubre, con fecha del 30 de septiembre, para la cita de la lista ordenada de algoritmos de la regla 2 de la «sección 5 · Estructura interna de un bloque v2 o v3».
  2. AOSP — tools/apksig/.../internal/apk/ApkSigningBlockUtils.java — https://android.googlesource.com/platform/tools/apksig/+/refs/tags/android-17.0.0_r1/src/main/java/com/android/apksig/internal/apk/ApkSigningBlockUtils.java Consultado el 25 de septiembre de 2026. De aquí salen APK_SIGNING_BLOCK_MAGIC, VERITY_PADDING_BLOCK_ID = 0x42726577, CONTENT_DIGESTED_CHUNK_MAX_SIZE_BYTES, el código citado de generateApkSigningBlock de la «sección 8 · El bloque de relleno», el de ChunkDigests de la «sección 6.2 · El troceado» y las dos comprobaciones de alineación de la «sección 6.3 · Los algoritmos de digest de contenido».
  3. AOSP — tools/apksig/.../internal/apk/SignatureAlgorithm.java — https://android.googlesource.com/platform/tools/apksig/+/refs/tags/android-17.0.0_r1/src/main/java/com/android/apksig/internal/apk/SignatureAlgorithm.java Consultado el 25 de septiembre de 2026. De aquí sale íntegra la tabla de la «sección 7 · Algoritmos de firma», con sus identificadores, sus parámetros PSS y sus minSdkVersion. Consultado de nuevo el 18 de octubre para los nombres JCA de su última columna (líneas 35-162).
  4. AOSP — tools/apksig/.../internal/apk/ContentDigestAlgorithm.java — https://android.googlesource.com/platform/tools/apksig/+/refs/tags/android-17.0.0_r1/src/main/java/com/android/apksig/internal/apk/ContentDigestAlgorithm.java Consultado el 25 de septiembre de 2026. De aquí sale la tabla de la «sección 6.3 · Los algoritmos de digest de contenido».
  5. AOSP — tools/apksig/.../internal/apk/v2/V2SchemeConstants.java — https://android.googlesource.com/platform/tools/apksig/+/refs/tags/android-17.0.0_r1/src/main/java/com/android/apksig/internal/apk/v2/V2SchemeConstants.java Consultado el 25 de septiembre de 2026. De aquí salen 0x7109871a y 0xbeeff00d.
  6. AOSP — tools/apksig/.../internal/apk/v3/V3SchemeConstants.java — https://android.googlesource.com/platform/tools/apksig/+/refs/tags/android-17.0.0_r1/src/main/java/com/android/apksig/internal/apk/v3/V3SchemeConstants.java Consultado el 25 de septiembre de 2026. De aquí salen 0xf05368c0, 0x1b93ad61, 0x3ba06f8c, 0x559f8b02 y 0xc2a6b3ba.
  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 0x2b09189e, 0x6dff800d, 0x9d6303f7 y 0xe43c5946, y la descripción del formato del atributo de marca de tiempo.
  8. avast/apkverifier — signingblock/signingblock.go, commit d0e1a791 — https://github.com/avast/apkverifier/blob/d0e1a791cd5ab5b84eb6f271d59ac3b2a9771071/signingblock/signingblock.go#L26-L42 Consultado el 12 de agosto de 2026 en master y el 18 de octubre en ese commit, que sigue siendo el último de la rama (líneas 26-42). De aquí salen los tres identificadores que no están en apksig: BlockIdDependencyMetadata = 0x504b4453, BlockIdMeituanMetadata = 0x71777777 y blockIdFrosting = 0x2146444e de la «sección 11 · El “frosting” de Google Play: 0x2146444e». Se usa esta fuente porque no existe documentación oficial de Google sobre el bloque de frosting.
  9. Android Gradle Plugin 4.0.0 release notes — Dependency metadata — https://developer.android.com/build/releases/past-releases/agp-4-0-0-release-notes Consultado el 12 de agosto de 2026. De aquí sale la descripción del bloque 0x504b4453: «The data is compressed, encrypted by a Google Play signing key, and stored in the signing block of your release app», y el bloque dependenciesInfo que lo desactiva.
  10. Easter Egg in APK Files: What Is Frosting — BI.ZONE — https://bi-zone.medium.com/easter-egg-in-apk-files-what-is-frosting-f356aa9f4d1 Consultado el 12 de agosto de 2026. De aquí sale la descripción funcional del bloque 0x2146444e de la «sección 11 · El “frosting” de Google Play: 0x2146444e»: quién lo añade, con qué clave se firma y qué metadatos contiene. Es análisis de terceros, no documentación oficial. La «sección 11 · El “frosting” de Google Play: 0x2146444e» comprueba por su cuenta la firma ECDSA, el SHA-256 y los campos del protobuf que se cotejan con el manifiesto y con los splits, y matiza su lectura del campo 4 (esa lectura es posible, pero no coincide con la fecha de la firma); el resto de su interpretación sigue sin verificar.
  11. lib/apksigner.jar de build-tools 37.0.0 — inspeccionado con javap -constants el 12 de agosto de 2026. De aquí salieron APK_SIGNATURE_SCHEME_V32_BLOCK_ID y HYBRID_MIN_SDK_VERSION_ATTR_ID de las secciones «4» y «4.1», antes de encontrarlos en la fuente 12.
  12. AOSP — V3SchemeConstants.java en la etiqueta android-17.0.0_r1, y la página «APK Signature Scheme v3.2» — https://android.googlesource.com/platform/tools/apksig/+/refs/tags/android-17.0.0_r1/src/main/java/com/android/apksig/internal/apk/v3/V3SchemeConstants.java y https://source.android.com/docs/security/features/apksigning/v3-2 Consultadas el 24 de septiembre de 2026. De aquí salen 0x70e1c89f, 0x9f06b79c y lo que hacen los dos atributos híbridos (secciones «4» y «4.1»), y el nombre nuevo de 0xc2a6b3ba.
  13. AOSP — ApkSigningBlockUtils.java, DefaultApkSignerEngine.java y V4SchemeSigner.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/internal/apk/ApkSigningBlockUtils.java y 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 las diferencias entre el árbol de VERITY_CHUNKED_SHA256 (computeApkVerityDigest) y el de v4 (generateV4Signature) de la «sección 6.3 · Los algoritmos de digest de contenido», y el relleno previo al bloque de generateApkSigningBlockPadding de la «sección 8 · El bloque de relleno».
  14. AOSP — tools/base, signflinger/.../SignedApk.java, etiqueta studio-2026.1.2 — https://android.googlesource.com/platform/tools/base/+/refs/tags/studio-2026.1.2/signflinger/src/com/android/signflinger/SignedApk.java Consultado el 25 de septiembre de 2026. De aquí sale que 0x504b4453 es el DEPENDENCY_INFO_BLOCK_ID que añade el Android Gradle Plugin («sección 4 · Identificadores de bloque conocidos»).
  15. Add build dependencies — Android Studio, «Dependency information for Play Console» — https://developer.android.com/build/dependencies Consultado el 25 de septiembre y el 18 de octubre de 2026. De aquí sale que esos datos van cifrados con una clave de Google Play en el bloque de firma («sección 4 · Identificadores de bloque conocidos»), y las opciones includeInApk e includeInBundle de dependenciesInfo de la lectura 5 de la «sección 10.1 · Frecuencia por identificador».
  16. Meituan-Dianping/walle, ApkUtil.java, commit f78edcf — https://github.com/Meituan-Dianping/walle/blob/f78edcf1117a0aa858a3d04bb24d86bf9ad51bb2/payload_reader/src/main/java/com/meituan/android/walle/ApkUtil.java#L40 Consultado el 25 de septiembre de 2026. De aquí sale APK_CHANNEL_BLOCK_ID = 0x71777777 («sección 4 · Identificadores de bloque conocidos»).
  17. avast/apkverifier — signingblock/frosting.go, commit d0e1a791 — https://github.com/avast/apkverifier/blob/d0e1a791cd5ab5b84eb6f271d59ac3b2a9771071/signingblock/frosting.go Consultado el 25 de septiembre de 2026 y reimplementado en Python sobre 493 de las 870 piezas con frosting, con la firma verificada en una muestra de 57. De aquí salen la estructura exterior del frosting, su firma y su SHA-256, y el cotejo de los campos del protobuf de la «sección 11 · El “frosting” de Google Play: 0x2146444e».
  18. AOSP — la verificación de firmas de la plataforma 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/ (ApkSignatureSchemeV2Verifier.java, ApkSignatureSchemeV3Verifier.java, ApkSigningBlockUtils.java y ApkSignatureVerifier.java). Consultado el 18 de octubre de 2026. De aquí salen la tercera comprobación de la «sección 3.2 · Campos de un par ID-valor» y la tabla de la «sección 5.1 · Lo que el verificador comprueba además de parsear», con las líneas que cita.
  19. AOSP — apksig y apksigner en 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/internal/apk/ApkSigningBlockUtilsLite.java, y en el mismo repositorio internal/apk/v2/V2SchemeSigner.java, DefaultApkSignerEngine.java, ApkVerifier.java y src/apksigner/java/com/android/apksigner/ApkSignerTool.java. Consultado el 18 de octubre de 2026. De aquí salen getSignaturesToVerify de la «sección 5.1 · Lo que el verificador comprueba además de parsear» (ApkSigningBlockUtilsLite.java, líneas 167-219), el uso de SHA256 en el source stamp de la «sección 6.3 · Los algoritmos de digest de contenido» (DefaultApkSignerEngine.java, líneas 1305-1330, y ApkVerifier.java, líneas 1255-1270), y lo que activa las firmas verity de la «sección 7 · Algoritmos de firma»: --verity-enabled apagado por defecto (ApkSignerTool.java, líneas 153 y 213-214), verity apagado por defecto en DefaultApkSignerEngine (DefaultApkSignerEngine.java, línea 2084) y la firma verity junto a la normal (V2SchemeSigner.java, líneas 99-107).
  20. apksigner sign -h de build-tools 37.0.0 y la página de apksigner — https://developer.android.com/tools/apksigner. Ejecutado y consultada el 18 de octubre de 2026; la página sigue con fecha del 5 de marzo. De aquí sale la descripción literal de --verity-enabled de la «sección 7 · Algoritmos de firma», que la página no recoge.
  21. AOSP — tools/base en la etiqueta studio-2026.1.2 — https://android.googlesource.com/platform/tools/base/+/refs/tags/studio-2026.1.2/build-system/gradle-core/src/main/java/com/android/build/gradle/internal/tasks/PackageBundleTask.kt y https://android.googlesource.com/platform/tools/base/+/refs/tags/studio-2026.1.2/signflinger/src/com/android/signflinger/SignedApk.java. Consultado el 18 de octubre de 2026. De aquí salen el fichero dependencies.pb del espacio com.android.tools.build.libraries que AGP añade al AAB (PackageBundleTask.kt, líneas 356-357) de la «sección 10.1 · Frecuencia por identificador», y que signflinger no active verity (SignedApk.java, líneas 89-96) de la «sección 7 · Algoritmos de firma».
  22. bundletool 1.18.3 — AppBundle.java y AppBundleSerializer.java — https://github.com/google/bundletool/blob/1.18.3/src/main/java/com/android/tools/build/bundletool/model/AppBundle.java#L75 y https://github.com/google/bundletool/blob/1.18.3/src/main/java/com/android/tools/build/bundletool/io/AppBundleSerializer.java#L62. Consultado el 18 de octubre de 2026. De aquí sale que los metadatos del AAB vayan bajo BUNDLE-METADATA/ («sección 10.1 · Frecuencia por identificador»).
  23. fdroidserver — fdroidserver/scanner.py, commit 5806784d — https://gitlab.com/fdroid/fdroidserver/-/blob/5806784d0d43bed7b938fd4b327162da68927060/fdroidserver/scanner.py#L80-96 Consultado el 18 de octubre de 2026. De aquí sale que el escáner cuente 0x504b4453 entre los bloques de firma extra que son un problema (líneas 80-96 y 690-704), de la «sección 10.1 · Frecuencia por identificador».
  24. AOSP — StrictJarFile.java y StrictJarVerifier.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/jar/StrictJarVerifier.java y, en el mismo directorio, StrictJarFile.java. Consultado el 18 de octubre de 2026. De aquí sale que el rechazo por X-Android-APK-Signed solo se aplica con signatureSchemeRollbackProtectionsEnforced activado (StrictJarVerifier.java, líneas 399-445), que es el verifyFull que StrictJarFile recibe de ApkSignatureVerifier y pasa a StrictJarVerifier (StrictJarFile.java, líneas 103-120), de la «sección 5.1 · Lo que el verificador comprueba además de parsear».
  25. AOSP — apksig en android-17.0.0_r1: verificadores v2 y v3, lineage, ZIP y relleno — https://android.googlesource.com/platform/tools/apksig/+/refs/tags/android-17.0.0_r1/src/main/java/com/android/apksig/internal/apk/v2/V2SchemeVerifier.java, y en el mismo repositorio internal/apk/v3/V3SchemeVerifier.java, internal/apk/v3/V3SigningCertificateLineage.java, SigningCertificateLineage.java, internal/zip/ZipUtils.java, DefaultApkSignerEngine.java y ApkSigner.java. Consultado el 18 de octubre de 2026. De aquí salen la comparación con List.equals de la regla 2 de la «sección 5 · Estructura interna de un bloque v2 o v3» (V2SchemeVerifier.java, líneas 408-421), los Issue y las reglas del lineage de la «sección 5.2 · Rechazos estructurales y reglas del lineage» (V2SchemeVerifier.java, 192-195, 286-289 y 369-372; V3SchemeVerifier.java, 321-324, 409-412, 511-514 y 595-612; V3SigningCertificateLineage.java, 76-167), el relleno previo al bloque que apksigner pide siempre, de la «sección 8 · El bloque de relleno» (ApkSigner.java, línea 636; DefaultApkSignerEngine.java, 1167-1171 y 1186-1189), la búsqueda del EOCD del volcador de la «sección 9 · El volcador» (ZipUtils.java, 458-491) y que apksig no firme con PSS, de la «sección 7 · Algoritmos de firma» (internal/apk/v2/V2SchemeSigner.java, 95-97, e internal/apk/v3/V3SchemeSigner.java, 115-117).
  26. AOSP — el source stamp en apksig, 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/internal/apk/stamp/V2SourceStampSigner.java, y en el mismo directorio SourceStampVerifier.java, V2SourceStampVerifier.java y SourceStampCertificateLineage.java. Consultado el 18 de octubre de 2026. De aquí salen la estructura del par 0x6dff800d y lo que firma (V2SourceStampSigner.java, líneas 118-122, 124-147 y 150-192), las comprobaciones de apksig de la «sección 5.3 · El source stamp, 0x6dff800d» (SourceStampVerifier.java, 139-148, 165-179, 207-219 y 322-330) y el algoritmo fijo del sello (DefaultApkSignerEngine.java, 721-724).
  27. AOSP — android.util.apk en android-17.0.0_r1: rechazos estructurales, lineage y source stamp — https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-17.0.0_r1/core/java/android/util/apk/SourceStampVerifier.java, y en el mismo directorio ApkSignatureSchemeV2Verifier.java, ApkSignatureSchemeV3Verifier.java y ApkSigningBlockUtils.java. Consultado el 18 de octubre de 2026. De aquí salen los mensajes de la plataforma, con las líneas que se citan, de la regla 2 de la «sección 5 · Estructura interna de un bloque v2 o v3» y de las secciones «5.2» y «5.3», y sus nombres JCA de la «sección 7 · Algoritmos de firma» (ApkSigningBlockUtils.java, 588-624).
  28. RFC 3279 — Algorithms and Identifiers for the Internet X.509 Public Key Infrastructure — https://www.rfc-editor.org/rfc/rfc3279.html. Consultado el 18 de octubre de 2026. De aquí salen Dss-Sig-Value y Ecdsa-Sig-Value (apartados 2.2.2 y 2.2.3) de la «sección 7 · Algoritmos de firma».
  29. RFC 8017 — PKCS #1: RSA Cryptography Specifications Version 2.2 — https://www.rfc-editor.org/rfc/rfc8017.html. Consultado el 18 de octubre de 2026. De aquí salen el DigestInfo de RSASSA-PKCS1-v1_5 (apartado 9.2) y el trailerField 1, 0xbc, de RSASSA-PSS (apéndice A.2.3), de la «sección 7 · Algoritmos de firma».
  30. Java Security Standard Algorithm Names — Java SE 21 — https://docs.oracle.com/en/java/javase/21/docs/specs/security/standard-names.html. Consultado el 18 de octubre de 2026. De aquí sale que la concatenación r‖s sea la de las variantes …inP1363Format («the concatenation of the integers r and s in raw bytes»), no la de SHA256withECDSA ni SHA256withDSA, de la «sección 7 · Algoritmos de firma».
  31. apksigner 0.9 y aapt2 de build-tools 37.0.0, keytool, OpenSSL 3.6.3 y el volcador de la «sección 9 · El volcador» — ejecutados el 18 de octubre de 2026 sobre APK de prueba generados con ellos, con Temurin 21.0.10 y, para la firma ML-DSA, Temurin 25.0.2 y la receta de la «sección 7.5 de Esquemas de firma v1, v2 y v3 · Receta: firmar y verificar con apksigner 37.0.0». De aquí salen la comprobación de las codificaciones de la «sección 7 · Algoritmos de firma», el bloque que empieza en 4.096 sin verity de la «sección 8 · El bloque de relleno», el fallo con una clave de sello EC de la «sección 5.3 · El source stamp, 0x6dff800d», la salida de -v y la del APK con comentario de la «sección 9 · El volcador», y la igualdad de las firmas de los esquemas 2 y 3 del sello.
  32. El muestrario («El muestrario») — descargado entre el 19 y el 27 de octubre de 2026. De aquí salen las cifras de las «secciones 1 · Qué es y por qué existe» a 5, 8, 10 y 11.