Alineación y zipalign

Antes conviene leer «Contenedor ZIP» · «APK Signing Block»

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

1. Qué es y por qué existe

Un APK instalado no se desempaqueta. Android lee de él mientras la app viva, y si una entrada va sin comprimir (stored) y sus datos empiezan en un offset alineado, puede mapearla con mmap(2) directamente desde el fichero, sin copiarla a RAM. Eso es lo que prepara zipalign (lo tienes en el «glosario»): pone todas las entradas stored a 4 bytes («sección 2 · La alineación de 4 bytes») y, con -P 16, las .so a 16 KiB («sección 3 · La regla de las páginas de 16 KiB»). Las comprimidas no se alinean nunca, porque no se mapean; al comprobar, zipalign las marca (OK - compressed).

La cita de la documentación y el mecanismo del relleno —ceros al final del extra field del Local File Header, que el Central Directory no refleja— ya están en las secciones «10.3» y «8.1» de «Contenedor ZIP». Aquí nos quedamos con la parte que toca a la firma: el registro de alineación de apksigner, el orden respecto a la firma («sección 4 · El orden importa: alinear ANTES de firmar») y zipalign -c como verificador («sección 5 · zipalign -c como verificador»).

Que las entradas comprimidas no se alinean se nota en cuanto miras APK reales: sus offsets caen en cada resto módulo 4 más o menos una vez de cada cuatro, que es justo lo que da el azar.

1.1 Dos formas de rellenar

zipalign rellena con ceros. apksigner sign (con build-tools 36.0.0 o posterior y sus valores por defecto) hace otra cosa: tira el relleno que hubiera, incluido cualquier registro 0xd935 anterior, y escribe el suyo propio en el extra field de cada entrada stored (ApkSigner.java). Ese registro lleva el header id 0xd935, 2 bytes con el múltiplo de alineación y los ceros que falten, con un mínimo de 6 bytes. zipalign, en cambio, respeta el extra field que ya trae la entrada y solo añade ceros detrás si los datos no caen donde deben. Así que si pasas zipalign sobre un APK que ya alineó apksigner, los registros 0xd935 se quedan como estaban («sección 4.2 · La demostración»).

En la práctica, lo normal sigue siendo el relleno de ceros: lo llevan entre el 80 % y el 95 % de los APK según la fuente. El registro 0xd935 es minoritario (alrededor del 1 % en Google Play, el 9 % en F-Droid), con una excepción llamativa: el mercado chino, donde aparece en 43 de cada 100 piezas. Las dos formas pueden convivir en un mismo APK, lo que encaja con un zipalign pasado sobre algo ya alineado por apksigner, aunque eso es una hipótesis: no sabemos qué herramienta alineó cada APK. Y que un APK no lleve relleno no significa que esté mal alineado; puede que sus datos ya cayeran en su sitio, o que no tenga ninguna entrada stored.

¿Quién escribe el 0xd935? La firma v1 no dice quién alineó, pero da una pista. Lo llevan muchos APK firmados con SignApk (50 de 53), bastantes de jarsigner y apksigner, y ninguno de los 765 firmados por el plugin de Gradle. Así que «lo pone el plugin de Android» no es una explicación válida. El valor guardado es 4 en casi todas las entradas; 16.384 en unas pocas, y 4.096 en una treintena.

Un último matiz: el relleno vive en el Local File Header, y el Central Directory suele no reflejarlo, pero no siempre. Hay APK con el registro 0xd935 también en el Central Directory.

2. La alineación de 4 bytes

Es la regla general, la que aplica zipalign 4: toda entrada stored debe empezar en un múltiplo de 4 bytes. La razón es el acceso alineado a palabra. resources.arsc es una jerarquía de chunks cuyas cabeceras se leen como uint32, y leerlas desde una dirección desalineada es, en el mejor caso, más lento, y en algunas arquitecturas, un fallo.

Prácticamente todo el mundo la cumple. Fallan zipalign -c 4 solo 11 piezas de más de 15.000, y ninguna de Google Play. Las entradas desalineadas suelen ser imágenes .png y resources.arsc. Un ejemplo es dudeofx.eval (F-Droid, versión 102): su resources.arsc va sin comprimir, con los datos en resto 1 módulo 4, y targetSdk 36.

Desde targetSdkVersion 30 esto dejó de ser una optimización para convertirse en requisito de instalación:

«Apps that target Android 11 (API level 30) or higher can't be installed if they contain a compressed resources.arsc file or if this file is not aligned on a 4-byte boundary.»

Si no se cumple, la plataforma responde con INSTALL_PARSE_FAILED_RESOURCES_ARSC_COMPRESSED.

De las apps con ese target, solo hemos encontrado una que no la cumpla: el propio dudeofx.eval. No lo hemos instalado, así que no sabemos qué hace Android con él; solo sabemos lo que hay en los bytes.

Veamos un caso concreto, medido sobre org.fossify.math (F-Droid, versión 1.4.0), entrada assets/dexopt/baseline.prof:

LFH = 325   file_name_length = 27   extra_field_length (LFH) = 2   →  datos en 384
325 + 30 + 27 + 2 = 384 = 4 × 96

Dos bytes de relleno, los mínimos para llegar al siguiente múltiplo de 4. Y la entrada correspondiente del Central Directory declara extra field length = 0: el relleno de ceros está solo en el Local File Header. Por esa asimetría zipinfo no lo enseña (los registros 0xd935, en cambio, a veces sí aparecen en el Central Directory, «sección 1.1 · Dos formas de rellenar»). Puedes repetirlo con python3 -I scripts/muestrario/cifras/alineacion_y_16k_2.py lfh <apk> assets/dexopt/baseline.prof.

2.1 resources.arsc con target menor de 30

Por debajo de 30 la regla no es obligatoria, y ahí sí aparecen incumplimientos, aunque pocos: menos del 1 % de las apps de F-Droid con ese target. Dos ejemplos son com.chessclock.android y nl.asymmetrics.droidshows. Cabría esperar más casos en el mercado chino, pero allí casi no hemos encontrado apps con un target tan bajo.

2.2 Qué va sin comprimir en un APK real

Para saber a qué afecta zipalign 4 conviene saber qué va sin comprimir. Casi siempre, resources.arsc (prácticamente en el 100 % de los casos), las imágenes .png (más del 90 %) y baseline.prof (entre el 70 % y el 90 %).

Los classes.dex van sin comprimir sobre todo cuando el minSdk es 28 o más: entonces es lo habitual (entre el 90 % y el 98 % de las apps). Por debajo de 28 depende mucho de la fuente: en F-Droid casi nunca, en Google Play aproximadamente la mitad de las veces.

Las .so de lib/<abi>/ van sin comprimir en unas dos de cada tres apps que las llevan, salvo en el mercado chino, donde es raro (4 de 100).

3. La regla de las páginas de 16 KiB

3.1 Qué es

Para mapear una .so sin comprimir en un dispositivo con páginas de 16 KiB hacen falta dos alineaciones distintas que se confunden a menudo: la del offset de sus datos dentro del APK y la de los segmentos LOAD del propio ELF. Las dos, y lo que pasa cuando falla cada una, están en la «sección 6.1 de Código nativo y ELF · Qué es el requisito».

Lo que importa aquí es que zipalign solo comprueba la primera, y además lo hace por el nombre: aplica -P a toda entrada stored que acabe en .so, esté o no en lib/<abi>/, y nunca abre el ELF (getAlignment y verify en ZipAlign.cpp). De ahí sale algo que conviene tener muy claro: un APK puede pasar zipalign -c -P 16 y seguir siendo incompatible con páginas de 16 KiB, si sus .so tienen segmentos LOAD alineados a 2**12. Hacen falta los dos controles; ninguno basta por sí solo.

Las dos cosas se ven en APK reales.

zipalign mira el nombre, no la carpeta. Es raro encontrar .so fuera de lib/<abi>/, salvo en el mercado chino, donde aparecen en una de cada cuatro piezas. Casi siempre están en assets/, porque los protectores como Jiagu 360 guardan ahí sus bibliotecas. Hemos visto APK que fallan zipalign -c -P 16 4 únicamente por eso. Por ejemplo, com.jzzs.ParentsHelper (tienda 360): su única .so sin comprimir es assets/libjiagu.so, en un offset con resto 12.288 módulo 16.384, y las otras 14 van comprimidas. Pasa -c 4 y falla -c -P 16 4 solo por esa entrada. Algo parecido le pasa a com.ss.android.ugc.aweme (Douyin) con assets/arm64-v8a/libalog.so.

Pasar zipalign no basta. Entre los APK que pasan zipalign -c -P 16 4 y llevan una .so de 64 bits, entre el 5 % y el 18 % (según la fuente) tienen algún segmento LOAD por debajo de 16 KiB, y en el mercado chino son tres de cada cuatro. Un ejemplo claro es el split de arquitectura de net.bat.store (split_config.arm64_v8a.apk, descargado de APKMirror): sus 16 .so sin comprimir están todas en múltiplos de 16.384, pero 7 de ellas se enlazaron con p_align de 4.096 (libcrashlytics-common, -handler, -trampoline, libcrashlytics, libhpatchz, libmmkv y libsqlcipher). Pasa zipalign y aun así no puedes decir que sea compatible. Ojo: la medida mira el segmento LOAD mínimo de cada .so; no tiene en cuenta el RELRO ni el solape de segmentos que revisa el cargador.

3.2 Desde cuándo y a qué afecta

La regla de Google Play (targetSdkVersion 35 o superior, en dispositivos de 64 bits) y sus fechas, que por cierto no coinciden entre el blog de Android Developers y la guía, están en la «sección 6.2 de Código nativo y ELF · Fecha y alcance en Google Play». Es una regla de publicación, no de la plataforma.

Del contenedor, el instalador solo mira el offset de una .so sin comprimir cuando la app declara extractNativeLibs=false. En un dispositivo de 16 KiB, el Android 15 original rechaza el APK si ese offset no es múltiplo de 16 KiB, con INSTALL_FAILED_INVALID_APK y «Library '…' is not PAGE(16384)-aligned - will not be able to open it directly from apk» (NativeLibraryHelper.cpp). Android 16 —y 15 desde QPR2, según el código— es más tolerante: si el offset es al menos múltiplo de 4 KiB, extrae la biblioteca a disco en vez de rechazar el APK y lo marca con pageSizeCompat=2. Puedes impedirlo con android:pageSizeCompat="disabled" en el manifiesto o poniendo la propiedad pm.16kb.app_compat.disabled a true. La matriz ejecutada en Android 15 y 16 está en la «sección 6.4 de Código nativo y ELF · Qué pasa en el dispositivo».

Lo que vemos en los bytes de APK reales (no lo que hace Android al instalarlos):

  • El atributo y el contenido casan siempre. No hemos encontrado ni una app con extractNativeLibs=false que lleve una .so comprimida, cosa que Android no instalaría.
  • Lo habitual es false con todas las .so sin comprimir, en torno a dos de cada tres apps. El mercado chino es la excepción: allí casi nadie lo hace.
  • true explícito es frecuente en Google Play (cerca del 40 %) y en el mercado chino (59 de 100). Algunas de esas apps llevan de todos modos alguna .so sin comprimir, y zipalign -P 16 sí la comprueba.
  • Sin el atributo, alrededor del 10 % en F-Droid y bastantes más en el mercado chino. Con minSdk menor de 23, casi todas esas apps llevan las .so comprimidas.
  • extractNativeLibs=false con .so en múltiplo de 4.096 pero no de 16.384, que es el caso que Android 16 resuelve extrayendo con aviso: entre el 3 % y el 15 % de las apps según la fuente.
  • extractNativeLibs=false con una .so que ni siquiera es múltiplo de 4.096, el caso de rechazo: no hemos encontrado ninguna.

3.3 El comando

«If your APK contains shared libraries (.so files), use -P 16 to ensure that they're aligned to a 16KiB page boundary suitable for mmap(2) in both 16KiB and 4KiB devices.»

-P generaliza el antiguo -p, que fijaba 4 KiB, aunque no lo retira. Así lo describe la ayuda de zipalign 37.0.0:

Usage: zipalign [-f] [-p] [-P <pagesize_kb>] [-v] [-z] <align> infile.zip outfile.zip
       zipalign -c [-p] [-P <pagesize_kb>] [-v] <align> infile.zip
…
  -p: 4kb page-align uncompressed .so files
…
  -P <pagesize_kb>: Align uncompressed .so files to the specified
                    page size. Valid values for <pagesize_kb> are 4, 16
                    and 64. '-P' cannot be used in combination with '-p'.

Dos detalles que despistan. El 4 del final sigue siendo obligatorio: es la alineación general de la «sección 2 · La alineación de 4 bytes», y -P 16 solo añade una regla más estricta para las .so sin comprimir. Y el valor de -P va en KiB, no en bytes: -P 16 significa 16.384.

El paso siguiente, firmar, también alinea. apksigner sign con sus valores por defecto (--alignment-preserved false y --lib-page-alignment 16384) rehace el relleno de cada entrada stored: 4 bytes para todas y 16 KiB para las que acaban en .so. Lo hemos medido con build-tools 37.0.0: una .so que estaba en el offset 4.096 sale de apksigner en el 16.384, y el resultado pasa zipalign -c -P 16 4. Con --alignment-preserved true se queda en el 4.096 y no pasa. En apksig funciona así en las etiquetas android-15.0.0_r1, android-16.0.0_r1 y android-17.0.0_r1; en android-14.0.0_r1 solo conservaba la alineación que traía la entrada.

En los APK reales se ve el rastro de este comportamiento: cuando un APK lleva el registro 0xd935 con valor 16.384, sus .so sin comprimir están todas en múltiplo de 16.384 (salvo un caso entre 200). Un ejemplo es el propio cliente de F-Droid (org.fdroid.fdroid, targetSdk 37), con cuatro libandroidx.graphics.path.so sin comprimir y p_align de 16.384.

Pero no es lo común. La gran mayoría de APK con .so sin comprimir llevan relleno de ceros y ningún 0xd935, y aun así cumplen los 16 KiB. Los registros con valor 4.096 apuntan a un apksigner anterior a la regla de 16 KiB, aunque no podemos saber cuál.

3.4 Protectores y marcos

Los protectores comerciales suelen dejar sus bibliotecas fuera de lib/. Los motores conocidos (Flutter, Unity, React Native), en cambio, van casi al día.

Protectores. En Google Play, todas las apps con protector que hemos visto (PairIP incluido) tienen sus .so con p_align de 16.384 o más. En el mercado chino la cosa cambia: solo cumplen 11 de 34. Los que fallan son sobre todo Bangcle/SecNeo (libDexHelper.so, con p_align 4.096) y algunos Ijiami; Jiagu 360 usa 65.536. Con tan pocas apps, tómalo como un recuento, no como una tasa de «los protectores chinos». Tres ejemplos:

  • com.xtc.watch (tienda 360, Bangcle/SecNeo): lib/arm64-v8a/libDexHelper-x86.so con p_align 4.096. No cumple.
  • com.able.wisdomtree (mercado chino, Jiagu 360): assets/libjiagu_a64.so con p_align 65.536.
  • com.pazugames.avatarworld (Google Play, PairIP), split split_config.arm64_v8a.apk: libpairipcore.so con p_align 16.384.

Marcos. Entre las apps con .so en lib/arm64-v8a/ y targetSdk 35 o más, cumplen los 16 KB (segmentos LOAD con p_align de 16.384 o más y, si las .so se cargan desde el APK, offsets del ZIP en múltiplo de 16.384):

Marco F-Droid IzzyOnDroid Google Play, más instaladas Google Play, sorteo
Flutter 352/368 (96 %) 92/99 (93 %) 26/27 (96 %) 57/61 (93 %)
Unity — — 89/91 (98 %) 74/77 (96 %)
React Native 57/67 (85 %) — 43/43 (100 %) 29/32 (91 %)
Ninguno de esos 1.565/1.674 (93 %) 486/519 (94 %) 309/345 (90 %) 94/104 (90 %)

Lo curioso es que, en Google Play, las que menos cumplen son las apps que no usan ninguno de esos marcos, es decir, las que llevan código nativo propio. En F-Droid la cifra más baja es la de React Native. Y si quitas el límite de targetSdk, la cosa baja bastante: cumplen el 79 % de las apps Flutter de F-Droid y el 68 % de las de React Native.

3.5 Y las páginas de 64 KiB

zipalign admite también -P 64, pero casi nadie lo usa. Pocas apps tienen todas sus .so de 64 bits enlazadas a 64 KiB (entre el 1 % y el 6 %), y en el ZIP las .so sin comprimir caen en múltiplo de 65.536 más o menos una de cada cuatro veces. Es justo lo que esperarías por azar de un offset que ya está en múltiplo de 16.384. Dicho de otro modo: nadie alinea el ZIP a 64 KiB. Qué haría -P 64 en un dispositivo de 64 KiB no lo hemos medido.

No confundas esto con las apps que tienen todos los segmentos LOAD a 64 KiB o más, que son bastantes más (una de cada cinco en F-Droid), sobre todo por libflutter.so y libapp.so. Es otra cifra.

4. El orden importa: alinear ANTES de firmar

Esta regla se rompe con facilidad: si pasas zipalign después de firmar, eliminas la firma v2 y v3 sin que nadie te avise. La documentación oficial lo dice así:

«Caution: If you sign your APK using apksigner and make further changes to the APK, the APK's signature is invalidated. If you use zipalign to align your APK, use it before signing the APK.»

4.1 Por qué exactamente

Hay dos motivos, uno detrás del otro, y los dos vienen de lo mismo: v2 firma bytes, no entradas.

  1. Alinear mueve bytes. El relleno del extra field desplaza los datos de esa entrada y, con ellos, todo lo que va detrás: el resto de entradas, el Central Directory y el EOCD. El digest de v2 se calcula sobre el tramo 1 (del offset 0 al inicio del APK Signing Block), el Central Directory y el EOCD («sección 6.1 de APK Signing Block · Qué se trocea»). Cambiar el offset de cualquier entrada cambia el digest.
  2. zipalign reconstruye el ZIP y por el camino tira el APK Signing Block. No intenta conservarlo: copia entrada a entrada a un fichero nuevo y escribe un Central Directory y un EOCD nuevos. El hueco entre los datos y el Central Directory, sencillamente, no se reproduce.

Por el segundo motivo, el primero ni llega a notarse: la firma no queda inválida, desaparece. Y aquí entra la protección contra el downgrade de la «sección 5.2 de Firma v4 y verificación · Las reglas, en orden». El .SF de v1 sí sobrevive, porque es una entrada normal del ZIP, y en su cabecera X-Android-APK-Signed declara con qué esquemas se firmó el APK. El verificador lee esa declaración, no encuentra los bloques y rechaza el fichero acusándolo de manipulación.

El mensaje depende de lo que declare el .SF. Si dice X-Android-APK-Signed: 2, 3, apksigner se queja de que faltan v2 y v3 («Signature stripped?»); si solo dice 2, el mensaje habla solo de v2. Casi todos los APK con firma v1 declaran v2 o v3, así que este es el caso que te vas a encontrar. La excepción son los APK firmados únicamente con v1: a esos, alinear después de firmar no les rompe nada. Y si el APK no lleva v1, el mensaje es otro: «Missing META-INF/MANIFEST.MF». Ese mismo error lo da apksigner verify en algunos splits de Google Play que no declaran minSdk y que por eso se verifican exigiendo v1.

4.2 La demostración

Partimos de org.fossify.math (F-Droid, versión 1.4.0). Ya viene firmada con v2 y alineada. Esto es lo que hay en ella, sin tocar nada:

  • Mide 7.047.681 bytes. La última entrada acaba en 6.928.720.
  • El APK Signing Block mide 4.096 bytes y empieza en 6.928.720, que no es múltiplo de 4.096 (6.928.720 = 4.096 × 1.691 + 2.384). Lleva el bloque de v2 (1.386 bytes) y un relleno 0x42726577 (2.654 bytes). No hay ceros delante del bloque.
  • El Central Directory empieza en 6.932.816 y el EOCD, en 7.047.659.
  • No tiene firma v1 (ningún .SF) ni v3.
  • Las cuatro libandroidx.graphics.path.so sin comprimir (una por ABI) están en 2.228.224, 2.244.608, 2.260.992 y 2.277.376, todas múltiplos de 16.384, y la app declara extractNativeLibs=false. Por eso -P 16 no mueve nada en esta pieza.

La receta, siempre sobre una copia:

BT=~/Library/Android/sdk/build-tools/37.0.0
SCR=/tmp/scratch/firma
cp org.fossify.math_10.apk $SCR/copia.apk
$BT/zipalign -c -v 4 $SCR/copia.apk | tail -2
$BT/zipalign -f -P 16 4 $SCR/copia.apk $SCR/copia_alineada.apk
ls -la $SCR/copia.apk $SCR/copia_alineada.apk
$BT/apksigner verify --verbose $SCR/copia_alineada.apk

Lo que esperamos (no lo hemos ejecutado sobre esta pieza): que zipalign devuelva 0, porque para él todo ha ido bien; que la copia alineada mida 7.043.585 bytes, es decir, los 7.047.681 originales menos los 4.096 del bloque que desaparece, ya que no hay nada más que mover; y que apksigner verify falle con algo como «Missing META-INF/MANIFEST.MF», porque la pieza no lleva v1. Los registros 0xd935 no cambian nada: zipalign los conserva y, como las entradas ya están alineadas, no añade ceros («sección 1.1 · Dos formas de rellenar»). Lo comprobamos con un APK de prueba firmado con apksigner 37.0.0 y pasado después por zipalign -f -P 16 4: los dos ficheros eran idénticos hasta el inicio del Central Directory del segundo, registro 0xd935 de resources.arsc incluido. Lo único distinto era el bloque y los ceros que lo precedían (fuente 10).

Para ver el mensaje «Signature stripped?» necesitas una copia firmada con v1+v2+v3 con una clave de pruebas, como en la «sección 10.2 de Firma v4 y verificación · Firmar una copia y verificarla», porque solo entonces el .SF declara v2 y v3. Con esa copia, en una ejecución del 12 de agosto de 2026, la salida fue:

DOES NOT VERIFY
ERROR: JAR signer PRUEBAS.RSA: JAR signature META-INF/PRUEBAS.SF indicates the APK is signed
using APK Signature Scheme v2 but no such signature was found. Signature stripped?
ERROR: JAR signer PRUEBAS.RSA: JAR signature META-INF/PRUEBAS.SF indicates the APK is signed
using APK Signature Scheme v3 but no such signature was found. Signature stripped?

El mensaje engaña sobre la causa. «Signature stripped?» suena a ataque, y aquí no es más que un zipalign ejecutado un paso tarde.

Un apunte de paso: los ceros que apksigner pone delante del bloque para que empiece en múltiplo de 4.096 («sección 8 de APK Signing Block · El bloque de relleno») no los lleva todo el mundo. Casi todos los APK de Google Play sí; en F-Droid, unos dos de cada tres, y en IzzyOnDroid, menos de uno de cada cinco. El volcador de la «sección 9 de APK Signing Block · El volcador» te enseña el bloque de cualquier APK.

4.3 El orden correcto

$BT/zipalign -f -P 16 4 $SCR/copia.apk $SCR/alineado.apk
$BT/apksigner sign --ks $SCR/pruebas.jks --ks-key-alias pruebas \
  --ks-pass pass:pruebas --key-pass pass:pruebas \
  --out $SCR/alineado_firmado.apk $SCR/alineado.apk
$BT/apksigner verify --verbose $SCR/alineado_firmado.apk | head -4
$BT/zipalign -c -v 4 $SCR/alineado_firmado.apk | tail -1
$BT/zipalign -c -P 16 4 $SCR/alineado_firmado.apk; echo "exit=$?"
Verifies
Verified using v1 scheme (JAR signing): false
Verified using v2 scheme (APK Signature Scheme v2): true
Verified using v3 scheme (APK Signature Scheme v3): true
Verification successful
exit=0

Alineado y luego firmado, las dos comprobaciones pasan. Esta salida es de una copia de prueba firmada con las mismas opciones, no de la pieza de la «sección 4.2 · La demostración». Si quieres afirmar que la cadena es determinista, comparar tamaños no basta: compara los SHA-256 de alineado_firmado.apk y de la copia firmada sin zipalign previo.

La regla práctica: zipalign es lo último antes de firmar, y apksigner sign es lo último de todo. Después, nada toca el APK.

¿Sigue haciendo falta zipalign? Para alinear, no, si firmas con apksigner sign de build-tools 36.0.0 o posterior con sus valores por defecto: ya rehace el relleno de cada entrada stored («sección 3.3 · El comando»). Sí lo necesitas:

  • si firmas con otra herramienta que no realinee;
  • si firmas con --alignment-preserved true, que conserva la alineación de entrada;
  • para recomprimir con Zopfli (-z), que apksigner no hace, y siempre antes de firmar;
  • como comprobación: zipalign -c no modifica el fichero, y es el único uso de zipalign que puede ir después de firmar.

4.4 Bloques de canal

Las herramientas de canal chinas (Walle, VasDolly) añaden un par más al APK Signing Block después de firmar, con los identificadores 0x71777777 (Walle) y 0x881155ff (VasDolly). No rompen la firma v2 porque el bloque no entra en el digest, que cubre las entradas, el Central Directory y el EOCD. Y como tampoco tocan las entradas, la alineación no cambia.

Es algo muy del mercado chino: lo hemos visto en 31 de 100 APK de allí (24 con Walle y 7 con VasDolly) y en uno solo de Google Play. Todos pasan zipalign -c 4. Lo que sí varía es el tamaño del bloque, que en algunos casos deja de ser múltiplo de 4.096. Y llevar el par de relleno 0x42726577 no significa que el APK se haya firmado con verity. Dos ejemplos con varios pares en el bloque son com.tuniu.app.ui (0x7109871a, 0xf05368c0, 0x71777777 y 0x42726577) y com.callme.sy (0x7109871a, 0x71777777 y 0x42726577).

5. zipalign -c como verificador

-c comprueba sin modificar. Devuelve 0 si todo cumple y 1 si algo no, así que puedes usarlo en un script. Con -v imprime una línea por entrada con el offset de los datos, no el del Local File Header.

Comando Qué comprueba Qué reporta
zipalign -c -v 4 Toda entrada stored en múltiplo de 4 (OK), (OK - compressed) o (BAD - <resto>)
zipalign -c -P 16 -v 4 Lo anterior más las .so stored en múltiplo de 16.384 Ídem

El (BAD - n) no es un código de error: es el resto de dividir el offset entre la alineación exigida, o sea, cuántos bytes sobran.

5.1 Un caso que no cumple

Pasamos zipalign -c 4 y zipalign -c -P 16 4 (build-tools 37.0.0) por los más de 15.000 APK del muestrario, incluidos los que van dentro de .apkm y .xapk. Ojo con los .apkm: dentro las piezas van comprimidas, así que hay que extraerlas antes de comprobarlas.

zipalign -c -P 16 4 falla si alguna entrada stored no está en múltiplo de 4, o si alguna .so sin comprimir (esté o no en lib/) no está en múltiplo de 16.384. Fallan 192 piezas de unas 15.000, y casi todas (181) pasan -c 4: el problema es la regla de 16 KiB, no la de 4 bytes. Y no fallan solo los APK raros; fallan APK sueltos y splits de arquitectura:

  • APK sueltos: el 1,6 % en F-Droid, el 8 % de los de Google Play descargados sueltos y el 19 % en el mercado chino. Un ejemplo de F-Droid que pasa -c 4 y falla -c -P 16 4 es tk.hack5.treblecheck.
  • Splits de arquitectura: en torno al 2 % de los de APKMirror y al 9 % de los sacados con adb de un móvil. Dos ejemplos son los split_config.arm64_v8a.apk de cakepop.games y com.huoyugame.ryz.
  • Bases y demás splits (idioma, densidad, módulos): ninguno.

Por qué fallan los splits de arquitectura de Google Play no lo sabemos, así que no lo afirmamos. Tampoco hemos podido reproducir el fallo de Netflix que aparecía en otras muestras: el APK de Netflix que tenemos es un universal de APKMirror y pasa -P 16.

Un caso concreto, con -v: el split de arquitectura de Photomath (com.microblink.photomath 8.48.0, split_config.arm64_v8a.apk, del .apkm de APKMirror):

$BT/zipalign -c -P 16 -v 4 split_config.arm64_v8a.apk
Verifying alignment of split_config.arm64_v8a.apk (4)...
      49 AndroidManifest.xml (OK - compressed)
    4096 lib/arm64-v8a/libcrashlytics-common.so (BAD - 4096)
  761856 lib/arm64-v8a/libcrashlytics-handler.so (BAD - 8192)
  950272 lib/arm64-v8a/libcrashlytics-trampoline.so (OK)
  962560 lib/arm64-v8a/libcrashlytics.so (BAD - 12288)
 1159168 lib/arm64-v8a/libimage_processing_util_jni.so (BAD - 12288)
 1188159 stamp-cert-sha256 (OK - compressed)
 1188244 META-INF/BNDLTOOL.SF (OK - compressed)
 1188702 META-INF/BNDLTOOL.RSA (OK - compressed)
 1189847 META-INF/MANIFEST.MF (OK - compressed)
Verification FAILED

Código de salida: 1. Con la alineación general de 4 bytes, esas mismas entradas dan (OK) y código de salida 0: mismas entradas, veredictos opuestos. El split está alineado a 4 KiB (la primera .so empieza justo en 4096), así que cumple la regla vieja; lo que no cumple es la nueva de 16 KiB. Con qué herramienta se construyó no lo podemos saber.

Si lees los offsets directamente del ZIP, ves de dónde salen los (BAD - n):

Entrada Offset de datos mód 4096 mód 16384
libcrashlytics-common.so 4.096 0 4.096
libcrashlytics-handler.so 761.856 0 8.192
libcrashlytics-trampoline.so 950.272 0 0
libcrashlytics.so 962.560 0 12.288
libimage_processing_util_jni.so 1.159.168 0 12.288

El número entre paréntesis del (BAD - n) es exactamente la última columna. Puedes sacar la tabla con python3 -I scripts/muestrario/cifras/alineacion_y_16k_1.py --offsets <apk> lib/.

Photomath no es un caso aislado. Casi todos los APK que fallan -P 16 por sus .so las tienen en múltiplo de 4.096: cumplen la regla vieja. Y en Google Play, la mitad de ellos tienen además sus ELF de 64 bits con p_align de 16.384 o más, así que les bastaría con realinear el ZIP. La otra mitad tendría que volver a enlazar sus bibliotecas.

5.2 La trampa de interpretar el resultado

Termux (com.termux, versión 0.119.0-beta.3, de F-Droid) también da Verification successful con -P 16. Y no es porque cumpla la regla de 16 KiB, sino porque no tiene ninguna entrada a la que se le aplique: sus 12 .so van comprimidas y declara extractNativeLibs=true. Las tres de arm64-v8a (liblocal-socket, libtermux-bootstrap y libtermux) tienen p_align de 4.096. Las dos últimas líneas de la salida:

114835355 META-INF/84D3000E.RSA (OK - compressed)
114836484 META-INF/MANIFEST.MF (OK - compressed)
Verification successful

zipalign -c no responde a «¿cumple este APK la regla de 16 KiB?». Responde a «¿están alineadas las entradas que debían estarlo?». No es lo mismo, y la segunda pregunta es más débil. Un APK con todas las .so comprimidas pasa siempre, porque no tiene ninguna sin comprimir, y aun así puede ser incompatible con dispositivos de 16 KiB por la alineación de sus segmentos ELF («sección 3.1 · Qué es»). Y no es raro: entre las apps con las .so de arm64-v8a comprimidas, más de un tercio de las de F-Droid tienen algún segmento por debajo de 16 KiB, y en el mercado chino, casi todas. Dos ejemplos que pasan zipalign -c -P 16 4 sin cumplir son org.sipdroid.sipua y org.vi_server.androidudpbus.

Tampoco te fíes de extractNativeLibs=true. Lo que manda es el método de cada entrada, no el atributo, y hay apps que lo declaran y aun así llevan alguna .so sin comprimir, que zipalign -P 16 sí comprueba.

5.3 Dónde se rompe la regla en la práctica

La regla de 16 KiB se rompe casi siempre en el mismo sitio: los splits de arquitectura de Google Play y los APK sueltos de otras fuentes. Esta tabla da, por tipo de pieza y fuente, cuántas fallan zipalign -c -P 16 4. Fíjate en las filas de «APK suelto» y «split de arquitectura»: en las demás no falla ninguna.

Tipo de pieza F-Droid IzzyOnDroid Google Play, más instaladas Google Play, sorteo Mercado chino
APK suelto 75/4.766 (1,6 %) 31/1.402 (2,2 %) 16/202 (7,9 %) — 19/100 (19,0 %)
base de un .apkm o de una carpeta de adb — — 0/386 0/315 —
otros splits (idioma, densidad, módulos) — — 0/5.938 0/578 —
split de arquitectura — — 22/962 (2,3 %) 25/282 (8,9 %) —
APK único de adb — — — 6/50 (12,0 %) —

Qué herramienta de empaquetado deja cada resultado no lo medimos, aunque la mayoría de los splits de arquitectura los firmó bundletool (BNDLTOOL.SF). Con zipalign -c 4, en cambio, apenas falla nada: 11 piezas, ninguna de Google Play.

Fuentes

  1. zipalign — Android Studio — https://developer.android.com/tools/zipalign Consultado el 12 de agosto de 2026. De aquí salen la recomendación de -P 16 de la «sección 3.3 · El comando» y la advertencia sobre el orden respecto a apksigner de la «sección 4 · El orden importa: alinear ANTES de firmar».
  2. Support 16 KB page sizes — Android Developers — https://developer.android.com/guide/practices/page-sizes Consultado el 18 de octubre de 2026; la página se actualizó el 16 de octubre. De aquí salen el umbral de targetSdkVersion 35 en dispositivos de 64 bits que resume la «sección 3.2 · Desde cuándo y a qué afecta» y el comando zipalign -c -P 16 -v 4 de las secciones «3» y «5».
  3. Behavior changes: Apps targeting Android 11 — Compressed resource files — https://developer.android.com/about/versions/11/behavior-changes-11 Consultado el 12 de agosto de 2026. De aquí sale la obligación de que resources.arsc vaya sin comprimir y alineado a 4 bytes, citada en la «sección 2 · La alineación de 4 bytes».
  4. apksigner — Android Studio — https://developer.android.com/tools/apksigner Consultado el 12 de agosto de 2026. De aquí sale la advertencia «If you use zipalign to align your APK, use it before signing the APK» de la «sección 4 · El orden importa: alinear ANTES de firmar». Consultada de nuevo el 18 de octubre, con fecha del 5 de marzo, no documenta --alignment-preserved ni --lib-page-alignment: esos salen de la fuente 9.
  5. zipalign de build-tools 37.0.0 — ejecutado el 12 de agosto de 2026, y su ayuda de nuevo el 18 de octubre. De aquí salen las líneas de la ayuda de la «sección 3.3 · El comando» y las salidas de las secciones «4.3» y «5.1». La salida de Photomath de la «sección 5.1 · Un caso que no cumple» se obtuvo con la misma versión sobre el muestrario de octubre de 2026 (fuente 11).
  6. AOSP — frameworks/base/core/jni/com_android_internal_content_NativeLibraryHelper.cpp en las etiquetas android-15.0.0_r1 y android-16.0.0_r1 — https://android.googlesource.com/platform/frameworks/base/+/refs/tags/android-16.0.0_r1/core/jni/com_android_internal_content_NativeLibraryHelper.cpp Consultado el 25 de septiembre de 2026. De aquí salen el rechazo con INSTALL_FAILED_INVALID_APK de una .so sin comprimir no alineada a la página del dispositivo y el modo de compatibilidad de 16 KiB de Android 16 (copyFileIfChanged), de la «sección 3.2 · Desde cuándo y a qué afecta».
  7. AOSP — tools/apksig/.../ApkSigner.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/ApkSigner.java Consultado el 18 de octubre de 2026. De aquí sale el registro de alineación de la «sección 1.1 · Dos formas de rellenar»: ALIGNMENT_ZIP_EXTRA_DATA_FIELD_HEADER_ID = 0xd935 y su tamaño mínimo de 6 bytes (líneas 75-86), y cómo descarta el relleno anterior y escribe el suyo (líneas 870-907).
  8. AOSP — build/make/tools/zipalign en la etiqueta android-17.0.0_r1 — https://android.googlesource.com/platform/build/+/refs/tags/android-17.0.0_r1/tools/zipalign/ZipFile.cpp y ZipEntry.cpp del mismo directorio. Consultado el 18 de octubre de 2026. De aquí sale el relleno con ceros de la «sección 1.1 · Dos formas de rellenar», que se añade detrás del extra field que ya traía la entrada: ZipFile::alignEntry (líneas 501-519) y ZipEntry::addPadding (líneas 198-227).
  9. apksigner sign -h de build-tools 36.0.0, 36.1.0 y 37.0.0, y https://android.googlesource.com/platform/tools/apksig/+/refs/tags/android-17.0.0_r1/src/apksigner/java/com/android/apksigner/ApkSignerTool.java — ejecutado y consultado el 18 de octubre de 2026. De aquí salen los valores por defecto de --alignment-preserved y --lib-page-alignment (ApkSignerTool.java, líneas 155-156 y 216-221), de las secciones «3.3» y «4.3», y que apksigner no tenga ninguna opción de recompresión, de la «sección 4.3 · El orden correcto».
  10. apksigner 0.9, zipalign y aapt2 de build-tools 37.0.0 — ejecutados el 18 de octubre de 2026 sobre un APK de prueba sin código generado con aapt2, firmado con apksigner sign y pasado después por zipalign -f -P 16 4. De aquí sale la comprobación de la «sección 4.2 · La demostración».
  11. Muestrario de octubre de 2026 — descrito en «El muestrario», Las cifras de esta página salen de scripts/muestrario/cifras/alineacion_y_16k_1.py y alineacion_y_16k_2.py, con zipalign 37.0.0 como referencia.