java - unable - ¿Cómo desarmo un tarro?

jarsigner verify

Question

¿Hay una manera de anular la firma de un archivo jar java? Tengo algunos archivos jar firmados que trato de usar en mi entorno de desarrollo, pero tengo excepciones de seguridad, por lo que quiero anular el registro de esos archivos jar y puedo firmarlos más adelante cuando esté listo para implementarme.

Answer 1

No sé la respuesta, pero esto es lo que haría:

1. Descomprima el archivo jar o los archivos en cuestión (los archivos jar son solo zip)
2. Busque en el directorio META-INF algo que no sea MANIFEST-MF.
3. Eliminar esas cosas.
4. Abra MANIFEST-MF y elimine las cosas que parecían estar relacionadas con la firma.
5. rejar

Answer 2

Si los frascos fueron desarrollados por usted en ese momento, puede confiar en ellos y probablemente no necesite firmarlos. Sin embargo, si los obtuvo de afuera en ese momento, debe investigar por qué viene la excepción de seguridad, antes de usarlos.

Answer 3

Si observa la herramienta jarsigner y lo que hace, genera 3 cosas: 1) el archivo .SF (archivo de firma) 2) un archivo de bloque de firma basado en el algoritmo utilizado (por ejemplo, .RSA, .DSA, etc.) 3 ) modificación o creación de un archivo MANIFEST.MF

Resumen: Para "anular la firma de un jar" simplemente borre los primeros 2 archivos (.sf y .dsa / rsa FILE). Elimine el archivo MANIFEST.MF, o ábralo y elimine todos los Hashes enumerados para cada archivo .class y otros archivos que se enumeran allí.

Por lo tanto, si elimina TODO en el directorio META-INF, corre el riesgo de eliminar otros recursos del contenedor que podrían ser necesarios (es decir, archivos de propiedades, etc.). Este "enfoque de escopeta" de eliminar todo lo que "parece estar relacionado con la firma" es perjudicial y no sigue el principio de: primero no hacer daño (a su archivo .jar).

Consulte aquí: docs.oracle.com/javase/8/docs/technotes/tools/windows/…

https://docs.oracle.com/javase/tutorial/deployment/jar/intro.html

Entendiendo la firma y verificación

"... Cuando firma un archivo JAR, su clave pública se coloca dentro del archivo junto con un certificado asociado para que esté fácilmente disponible para que la use cualquier persona que desee verificar su firma ... Recopilación y el archivo de firma

Cuando firma un archivo JAR, a cada archivo del archivo se le asigna una entrada de resumen en el manifiesto del archivo. Aquí hay un ejemplo de cómo podría ser una entrada de este tipo:

Nombre: test / classes / ClassOne.class SHA1-Digest: TD1GZt8G11dXY2p4olSZPc5Rj64 =

Cuando se firma un archivo JAR, se genera automáticamente un archivo de firma y se coloca en el directorio META-INF del archivo JAR, el mismo directorio que contiene el manifiesto del archivo. Los archivos de firma tienen nombres de archivo con una extensión .SF.

El archivo de bloque de firma

Además del archivo de firma, un archivo de bloque de firma se coloca automáticamente en el directorio META-INF cuando se firma un archivo JAR. A diferencia del archivo de manifiesto o el archivo de firma, los archivos de bloque de firma no son legibles por el usuario.

El archivo de bloque de firma contiene dos elementos esenciales para la verificación:

La firma digital para el archivo JAR que se generó con la clave privada del firmante. El certificado que contiene la clave pública del firmante, para ser utilizado por cualquier persona que desee verificar el archivo JAR firmado. Los nombres de los archivos de bloque de firma normalmente tienen una extensión .DSA que indica que se crearon. por el algoritmo de firma digital por defecto. Otras extensiones de nombre de archivo son posibles si se usan claves asociadas con algún otro algoritmo estándar para firmar.

Answer 4

Veo que una respuesta ya está aceptada, pero creo que esto podría ser útil de todos modos:

He preparado algo (en parte de otras publicaciones) para automatizar la tarea.
Viene sin garantía alguna, pero funciona para mí :)
Copia el archivo Jar al eliminar la información de la firma.
Tenga en cuenta, el MANIFEST se queda solo con la sección PRINCIPAL!

Use javac JarUnsigner.java para crear el archivo .class
Use java -cp <class dir> JarUnsigner <inJar> <outJar>

import java.io.BufferedReader;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Enumeration;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.util.zip.ZipOutputStream;

public class JarUnsigner {

  private static final String MANIFEST = "META-INF/MANIFEST.MF";

  public static void main(String[] args){

    if (args.length!=2){
      System.out.println("Arguments: <infile.jar> <outfile.jar>");
      System.exit(1);
    }
    String infile = args[0];
    String outfile = args[1];
    if ((new File(outfile)).exists()){
      System.out.println("Output file already exists:" + outfile);
      System.exit(1);
    }
    try{
      ZipFile zipFile = new ZipFile(infile);
      final ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(outfile));
      for (Enumeration e = zipFile.entries(); e.hasMoreElements();) {
        ZipEntry entryIn = (ZipEntry) e.nextElement();

        if (! exclude_file( entryIn.getName() ) ) {

          /* copy the entry as-is */
          zos.putNextEntry( new ZipEntry( entryIn.getName() ));
          InputStream is = zipFile.getInputStream(entryIn);
          byte[] buf = new byte[1024];
          int len;
          while ((len = (is.read(buf))) > 0) {
            zos.write(buf, 0, len);
          }
          zos.closeEntry();

        } else {

          if (MANIFEST.equals(entryIn.getName())){
            /* if MANIFEST, adjust the entry */
            zos.putNextEntry(new ZipEntry(MANIFEST));

            // manifest entries until first empty line. i.e. the ''MainAttributes'' section
            // (this method is used so to keep the formatting exactly the same)
            InputStream mIS = zipFile.getInputStream(entryIn);
            BufferedReader in = new BufferedReader(new InputStreamReader(mIS));
            String line = in.readLine();
            byte[] mNL = "/n".getBytes("UTF-8");
            while( line != null && !line.trim().isEmpty() ) {
              zos.write( line.getBytes("UTF-8"));
              zos.write( mNL );
              line = in.readLine();
            }
            zos.write( mNL );
            zos.closeEntry();

          }else{
            /* else: Leave out the Signature files */
          }

        }

      }
      zos.close();
      System.out.println("Successfully unsigned " + outfile);

    }catch(IOException ex){
      System.err.println("Error for file: " + infile);
      ex.printStackTrace();
      System.exit(1);
    }
  }

  /**
   * Exclude .SF signature file
   * Exclude .RSA and DSA (signed version of .SF file) 
   * Exclude SIG-  files  (unknown sign types for signed .SF file)
   * Exclude Manifest file
   * @param filename
   * @return 
   */
  public static boolean exclude_file(String filename){
    return filename.equals("META-INF/MANIFEST.MF") ||
           filename.startsWith("META-INF/SIG-") || 
           filename.startsWith("META-INF/") && ( filename.endsWith(".SF") || filename.endsWith(".RSA") || filename.endsWith(".DSA") );
  }

}

Utilízalo en ANT para anular la firma de un montón de tarros de la siguiente manera:

<apply executable="java" dest="${output-dir}"> 
  <arg value="-cp" />
  <arg value="${dev-dir}" />
  <arg value="JarUnsigner" />
  <srcfile/> 
  <targetfile/>
  <fileset dir="${input-dir}" includes="*.jar"/> 
  <mapper type="glob" from="*.jar" to="*.jar"/> <!-- uses "dest"-->
</apply> 

Answer 5

Verifiqué exitosamente la respuesta de DwB con una pequeña modificación: As ¿Hay una forma rápida de eliminar un archivo de un Jar / war sin tener que extraer el jar y volver a crearlo? estados, borrar solo de la herramienta jar no es posible. Necesitaba hacer solo un pequeño cambio en el script de construcción propietario y no quería volver a enterrar todo el archivo.

Me di cuenta de que no era posible anular la firma cuando solo hice un archivo .RSA importante de tamaño cero. Esto solo se puede lograr con el comando jar u :

cd %JAR_DIR%
jar xvf myapp.jar META-INF/MYAPP.RSA
type nul > META-INF/MYAPP.RSA
jar uvf myapp.jar META-INF/MYAPP.RSA
rmdir /S/Q META-INF

Answer 6

Para eliminar la firma de un archivo jar, elimine el directorio META-INF de este. Un archivo jar es un archivo zip, así que en Linux puedes hacer esto:

zip -d file.jar ''META-INF/*.SF'' ''META-INF/*.RSA''

Si tiene muchos archivos jar para anular la firma, el siguiente comando realiza esto en cada archivo jar en el directorio actual y a continuación:

find . -name ''*.jar'' -exec zip -d ''{}'' ''META-INF/*.SF'' ''META-INF/*.RSA'' '';''