Symantec Visual Cafe for Java 2.5/symantec-visual-cafe-2.5-database-dev-edition.iso/VPage/Java.bin/CLASSES.ZIP/sun/tools/jar/JarVerifierStream.class

Java Class File | 1997-07-08 | 8.0 KB | 344 lines

package sun.tools.jar;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintStream;
import java.math.BigInteger;
import java.security.Identity;
import java.security.IdentityScope;
import java.security.KeyManagementException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.PublicKey;
import java.security.SignatureException;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;
import java.util.zip.ZipEntry;
import java.util.zip.ZipException;
import java.util.zip.ZipInputStream;
import sun.misc.BASE64Decoder;
import sun.misc.CharacterDecoder;
import sun.net.www.MessageHeader;
import sun.security.pkcs.PKCS7;
import sun.security.pkcs.SignerInfo;
import sun.security.provider.IdentityDatabase;
import sun.security.provider.SystemIdentity;
import sun.security.x509.X509Cert;

public class JarVerifierStream extends ZipInputStream {
   static boolean debug;
   private ZipEntry currentEntry;
   private Vector scopes = new Vector();
   private Hashtable nameToHash = new Hashtable();
   private MessageDigest md5;
   private MessageDigest sha;
   private Hashtable signatures = new Hashtable();
   private Hashtable verifiedSignatures = new Hashtable();
   private boolean parsingBlock = false;
   private boolean computingHashes = false;
   private ByteArrayOutputStream blockOut;
   private boolean parsingManifest = false;
   private Manifest manifest;
   private ByteArrayOutputStream manifestOut;

   public JarVerifierStream(InputStream var1) throws IOException {
      super(var1);
      IdentityScope var2 = IdentityScope.getSystemScope();
      if (var2 != null) {
         this.addScope(var2);
      }

      try {
         this.sha = MessageDigest.getInstance("SHA");
      } catch (NoSuchAlgorithmException var4) {
         debug("didn't find an implementation for SHA");
      }

      try {
         this.md5 = MessageDigest.getInstance("MD5");
      } catch (NoSuchAlgorithmException var3) {
         debug("didn't find an implementation for MD5");
      }
   }

   public synchronized ZipEntry getNextEntry() throws IOException {
      if (this.currentEntry != null) {
         this.computeHashes(this.currentEntry.getName());
      }

      this.computingHashes = false;
      if (this.currentEntry != null) {
         this.closeEntry();
      }

      this.currentEntry = super.getNextEntry();
      if (this.currentEntry == null) {
         this.computeSignatures();
         return null;
      } else {
         String var1 = this.currentEntry.getName().toUpperCase();
         if (Manifest.isManifestName(var1) && this.manifest == null) {
            this.parsingManifest = true;
            this.manifestOut = new ByteArrayOutputStream();
         }

         if (var1.endsWith("DSA") || var1.endsWith("RSA")) {
            this.parsingBlock = true;
            this.blockOut = new ByteArrayOutputStream();
         }

         return this.currentEntry;
      }
   }

   private void processData() throws ZipException, IOException {
      if (this.parsingManifest) {
         this.manifest = new Manifest(this.manifestOut.toByteArray());
         this.parsingManifest = false;
      }

      if (this.parsingBlock) {
         PKCS7 var1 = new PKCS7(this.blockOut.toByteArray());
         this.addBlock(var1);
         this.parsingBlock = false;
      }

   }

   public synchronized void closeEntry() throws ZipException, IOException {
      super.closeEntry();
      this.processData();
   }

   public int read() throws IOException {
      int var1 = super.read();
      if (var1 != -1) {
         if (this.parsingBlock) {
            this.blockOut.write(var1);
         }

         if (this.parsingManifest) {
            this.manifestOut.write(var1);
         }

         if (this.computingHashes) {
            this.sha.update((byte)var1);
         }
      }

      return var1;
   }

   public int read(byte[] var1, int var2, int var3) throws IOException {
      int var4 = super.read(var1, var2, var3);
      if (var4 != -1) {
         if (this.parsingBlock) {
            this.blockOut.write(var1, var2, var4);
         }

         if (this.parsingManifest) {
            this.manifestOut.write(var1, var2, var4);
         }

         if (this.computingHashes) {
            this.sha.update(var1);
         }
      }

      return var4;
   }

   private void addBlock(PKCS7 var1) throws IOException {
      byte[] var2 = var1.getContentInfo().getData();
      SignatureFile var3 = new SignatureFile(var2);
      this.signatures.put(var3, var1);
   }

   private void computeHashes(String var1) {
      byte[] var2 = this.sha.digest();
      byte[] var3 = this.md5.digest();
      BigInteger var4 = new BigInteger(1, var2);
      BigInteger var5 = new BigInteger(1, var3);
      BigInteger[] var6 = new BigInteger[]{var4, var5};
      this.nameToHash.put(var1, var6);
      this.md5.reset();
      this.sha.reset();
   }

   private void computeSignatures() {
      debug("computeSignatures::: invoke");
      Enumeration var1 = this.signatures.keys();

      while(var1.hasMoreElements()) {
         SignatureFile var2 = (SignatureFile)var1.nextElement();
         PKCS7 var3 = (PKCS7)this.signatures.get(var2);
         this.processSignature(var2, var3);
      }

   }

   private void processSignature(SignatureFile var1, PKCS7 var2) {
      MessageDigest var3;
      BASE64Decoder var4;
      SignerInfo[] var5;
      try {
         var5 = var2.verify();
         if (var5 == null) {
            return;
         }

         var4 = new BASE64Decoder();
         var3 = MessageDigest.getInstance("SHA");
      } catch (SignatureException var16) {
         debug("signature exception", var16);
         return;
      } catch (NoSuchAlgorithmException var17) {
         debug("algorithm not available", var17);
         return;
      }

      Enumeration var6 = var1.entries();

      while(var6.hasMoreElements()) {
         MessageHeader var8 = (MessageHeader)var6.nextElement();
         String var7;
         if ((var7 = var8.findValue("Name")) != null) {
            MessageHeader var9 = this.manifest.getEntry(var7);
            if (var9 != null) {
               String var10 = var8.findValue("SHA-Digest");

               byte[] var11;
               try {
                  var11 = ((CharacterDecoder)var4).decodeBuffer(var10);
               } catch (IOException var15) {
                  continue;
               }

               ByteArrayOutputStream var12 = new ByteArrayOutputStream();
               PrintStream var13 = new PrintStream(var12);
               var9.print(var13);
               byte[] var14 = var3.digest(var12.toByteArray());
               if (MessageDigest.isEqual(var14, var11)) {
                  this.addIdentities(var7, var5, var2);
               }
            }
         }
      }

   }

   private void addIdentities(String var1, SignerInfo[] var2, PKCS7 var3) {
      Vector var4 = (Vector)this.verifiedSignatures.get(var1);
      if (var4 == null) {
         var4 = new Vector();
      }

      Vector var5 = this.findIdentities(var2, var3);
      Enumeration var6 = var5.elements();

      while(var6.hasMoreElements()) {
         var4.addElement(var6.nextElement());
      }

      this.verifiedSignatures.put(var1, var4);
   }

   public void addScope(IdentityScope var1) {
      this.scopes.addElement(var1);
   }

   public void removeScope(IdentityScope var1) {
      this.scopes.removeElement(var1);
   }

   private Vector findIdentities(SignerInfo[] var1, PKCS7 var2) {
      Vector var3 = new Vector();
      Enumeration var4 = this.scopes.elements();

      while(var4.hasMoreElements()) {
         IdentityScope var5 = (IdentityScope)var4.nextElement();
         Identity[] var6 = this.findIdentities0(var1, var2, var5);
         if (var6 != null) {
            for(int var7 = 0; var7 < var6.length; ++var7) {
               var3.addElement(var6[var7]);
            }
         }
      }

      return var3;
   }

   private Identity[] findIdentities0(SignerInfo[] var1, PKCS7 var2, IdentityScope var3) {
      Vector var4 = new Vector();
      if (var3 instanceof IdentityDatabase) {
         IdentityDatabase var5 = (IdentityDatabase)var3;

         for(int var6 = 0; var6 < var1.length; ++var6) {
            SignerInfo var7 = var1[var6];
            X509Cert var8 = var7.getCertificate(var2);
            PublicKey var9 = var8.getPublicKey();
            Identity var10 = var5.getIdentity(var9);
            debug("Identity:::" + var10);
            if (var10 != null) {
               var4.addElement(var10);
            } else {
               try {
                  String var11 = var8.getPrincipal().getName();
                  var10 = new SystemIdentity(var11, var3);
                  var10.setPublicKey(var9);
                  var10.addCertificate(var8);
                  var4.addElement(var10);
                  var10.toString(true);
               } catch (KeyManagementException var12) {
               }
            }
         }

         if (var4.size() != 0) {
            Identity[] var13 = new Identity[var4.size()];
            var4.copyInto(var13);
            return var13;
         }
      }

      return null;
   }

   public Hashtable getVerifiedSignatures() {
      return this.verifiedSignatures;
   }

   public Enumeration getBlocks() {
      return this.signatures.elements();
   }

   public Hashtable getNameToHash() {
      return this.nameToHash;
   }

   public Manifest getManifest() {
      return this.manifest;
   }

   static void debug(String var0) {
      if (debug) {
         System.err.println("sun.tools.jar.JarVerifierStream:::" + var0);
      }

   }

   static void debug(String var0, Throwable var1) {
      if (debug) {
         var1.printStackTrace();
         debug(var0);
      }

   }

   public Hashtable getHashTable() {
      return this.nameToHash;
   }
}