ASM: a very small and fast Java bytecode manipulation framework Copyright (c) 2000-2011 INRIA, France Telecom All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of the copyright holders nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
/*** * ASM: a very small and fast Java bytecode manipulation framework * Copyright (c) 2000-2011 INRIA, France Telecom * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the copyright holders nor the names of its * contributors may be used to endorse or promote products derived from * this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF * THE POSSIBILITY OF SUCH DAMAGE. */
package org.objectweb.asm.commons; import java.io.ByteArrayOutputStream; import java.io.DataOutput; import java.io.DataOutputStream; import java.io.IOException; import java.security.MessageDigest; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import org.objectweb.asm.ClassVisitor; import org.objectweb.asm.FieldVisitor; import org.objectweb.asm.MethodVisitor; import org.objectweb.asm.Opcodes;
A ClassVisitor that adds a serial version unique identifier to a class if missing. Here is typical usage of this class:
  ClassWriter cw = new ClassWriter(...);
  ClassVisitor sv = new SerialVersionUIDAdder(cw);
  ClassVisitor ca = new MyClassAdapter(sv);
  new ClassReader(orginalClass).accept(ca, false);
The SVUID algorithm can be found http://java.sun.com/j2se/1.4.2/docs/guide/serialization/spec/class.html:
The serialVersionUID is computed using the signature of a stream of bytes
that reflect the class definition. The National Institute of Standards and
Technology (NIST) Secure Hash Algorithm (SHA-1) is used to compute a
signature for the stream. The first two 32-bit quantities are used to form a
64-bit hash. A java.lang.DataOutputStream is used to convert primitive data
types to a sequence of bytes. The values input to the stream are defined by
the Java Virtual Machine (VM) specification for classes.
The sequence of items in the stream is as follows:
1. The class name written using UTF encoding.
2. The class modifiers written as a 32-bit integer.
3. The name of each interface sorted by name written using UTF encoding.
4. For each field of the class sorted by field name (except private static
and private transient fields):
1. The name of the field in UTF encoding.
2. The modifiers of the field written as a 32-bit integer.
3. The descriptor of the field in UTF encoding
5. If a class initializer exists, write out the following:
1. The name of the method, <clinit>, in UTF encoding.
2. The modifier of the method, java.lang.reflect.Modifier.STATIC,
written as a 32-bit integer.
3. The descriptor of the method, ()V, in UTF encoding.
6. For each non-private constructor sorted by method name and signature:
1. The name of the method, <init>, in UTF encoding.
2. The modifiers of the method written as a 32-bit integer.
3. The descriptor of the method in UTF encoding.
7. For each non-private method sorted by method name and signature:
1. The name of the method in UTF encoding.
2. The modifiers of the method written as a 32-bit integer.
3. The descriptor of the method in UTF encoding.
8. The SHA-1 algorithm is executed on the stream of bytes produced by
DataOutputStream and produces five 32-bit values sha[0..4].
9. The hash value is assembled from the first and second 32-bit values of
the SHA-1 message digest. If the result of the message digest, the five
32-bit words H0 H1 H2 H3 H4, is in an array of five int values named
sha, the hash value would be computed as follows:
long hash = ((sha[0] >>> 24) & 0xFF) |
((sha[0] >>> 16) & 0xFF) << 8 |
((sha[0] >>> 8) & 0xFF) << 16 |
((sha[0] >>> 0) & 0xFF) << 24 |
((sha[1] >>> 24) & 0xFF) << 32 |
((sha[1] >>> 16) & 0xFF) << 40 |
((sha[1] >>> 8) & 0xFF) << 48 |
((sha[1] >>> 0) & 0xFF) << 56;
Author:Rajendra Inamdar, Vishal Vishnoi
/** * A {@link ClassVisitor} that adds a serial version unique identifier to a * class if missing. Here is typical usage of this class: * * <pre> * ClassWriter cw = new ClassWriter(...); * ClassVisitor sv = new SerialVersionUIDAdder(cw); * ClassVisitor ca = new MyClassAdapter(sv); * new ClassReader(orginalClass).accept(ca, false); * </pre> * * The SVUID algorithm can be found <a href= * "http://java.sun.com/j2se/1.4.2/docs/guide/serialization/spec/class.html" * >http://java.sun.com/j2se/1.4.2/docs/guide/serialization/spec/class.html</a>: * * <pre> * The serialVersionUID is computed using the signature of a stream of bytes * that reflect the class definition. The National Institute of Standards and * Technology (NIST) Secure Hash Algorithm (SHA-1) is used to compute a * signature for the stream. The first two 32-bit quantities are used to form a * 64-bit hash. A java.lang.DataOutputStream is used to convert primitive data * types to a sequence of bytes. The values input to the stream are defined by * the Java Virtual Machine (VM) specification for classes. * * The sequence of items in the stream is as follows: * * 1. The class name written using UTF encoding. * 2. The class modifiers written as a 32-bit integer. * 3. The name of each interface sorted by name written using UTF encoding. * 4. For each field of the class sorted by field name (except private static * and private transient fields): * 1. The name of the field in UTF encoding. * 2. The modifiers of the field written as a 32-bit integer. * 3. The descriptor of the field in UTF encoding * 5. If a class initializer exists, write out the following: * 1. The name of the method, &lt;clinit&gt;, in UTF encoding. * 2. The modifier of the method, java.lang.reflect.Modifier.STATIC, * written as a 32-bit integer. * 3. The descriptor of the method, ()V, in UTF encoding. * 6. For each non-private constructor sorted by method name and signature: * 1. The name of the method, &lt;init&gt;, in UTF encoding. * 2. The modifiers of the method written as a 32-bit integer. * 3. The descriptor of the method in UTF encoding. * 7. For each non-private method sorted by method name and signature: * 1. The name of the method in UTF encoding. * 2. The modifiers of the method written as a 32-bit integer. * 3. The descriptor of the method in UTF encoding. * 8. The SHA-1 algorithm is executed on the stream of bytes produced by * DataOutputStream and produces five 32-bit values sha[0..4]. * * 9. The hash value is assembled from the first and second 32-bit values of * the SHA-1 message digest. If the result of the message digest, the five * 32-bit words H0 H1 H2 H3 H4, is in an array of five int values named * sha, the hash value would be computed as follows: * * long hash = ((sha[0] &gt;&gt;&gt; 24) &amp; 0xFF) | * ((sha[0] &gt;&gt;&gt; 16) &amp; 0xFF) &lt;&lt; 8 | * ((sha[0] &gt;&gt;&gt; 8) &amp; 0xFF) &lt;&lt; 16 | * ((sha[0] &gt;&gt;&gt; 0) &amp; 0xFF) &lt;&lt; 24 | * ((sha[1] &gt;&gt;&gt; 24) &amp; 0xFF) &lt;&lt; 32 | * ((sha[1] &gt;&gt;&gt; 16) &amp; 0xFF) &lt;&lt; 40 | * ((sha[1] &gt;&gt;&gt; 8) &amp; 0xFF) &lt;&lt; 48 | * ((sha[1] &gt;&gt;&gt; 0) &amp; 0xFF) &lt;&lt; 56; * </pre> * * @author Rajendra Inamdar, Vishal Vishnoi */
public class SerialVersionUIDAdder extends ClassVisitor {
Flag that indicates if we need to compute SVUID.
/** * Flag that indicates if we need to compute SVUID. */
private boolean computeSVUID;
Set to true if the class already has SVUID.
/** * Set to true if the class already has SVUID. */
private boolean hasSVUID;
Classes access flags.
/** * Classes access flags. */
private int access;
Internal name of the class
/** * Internal name of the class */
private String name;
Interfaces implemented by the class.
/** * Interfaces implemented by the class. */
private String[] interfaces;
Collection of fields. (except private static and private transient fields)
/** * Collection of fields. (except private static and private transient * fields) */
private Collection<Item> svuidFields;
Set to true if the class has static initializer.
/** * Set to true if the class has static initializer. */
private boolean hasStaticInitializer;
Collection of non-private constructors.
/** * Collection of non-private constructors. */
private Collection<Item> svuidConstructors;
Collection of non-private methods.
/** * Collection of non-private methods. */
private Collection<Item> svuidMethods;
Creates a new SerialVersionUIDAdder. Subclasses must not use this constructor. Instead, they must use the SerialVersionUIDAdder(int, ClassVisitor) version.
Params:
  • cv – a ClassVisitor to which this visitor will delegate calls.
/** * Creates a new {@link SerialVersionUIDAdder}. <i>Subclasses must not use * this constructor</i>. Instead, they must use the * {@link #SerialVersionUIDAdder(int, ClassVisitor)} version. * * @param cv * a {@link ClassVisitor} to which this visitor will delegate * calls. */
public SerialVersionUIDAdder(final ClassVisitor cv) { this(Opcodes.ASM4, cv); }
Creates a new SerialVersionUIDAdder.
Params:
  • api – the ASM API version implemented by this visitor. Must be one of Opcodes.ASM4.
  • cv – a ClassVisitor to which this visitor will delegate calls.
/** * Creates a new {@link SerialVersionUIDAdder}. * * @param api * the ASM API version implemented by this visitor. Must be one * of {@link Opcodes#ASM4}. * @param cv * a {@link ClassVisitor} to which this visitor will delegate * calls. */
protected SerialVersionUIDAdder(final int api, final ClassVisitor cv) { super(api, cv); svuidFields = new ArrayList<Item>(); svuidConstructors = new ArrayList<Item>(); svuidMethods = new ArrayList<Item>(); } // ------------------------------------------------------------------------ // Overriden methods // ------------------------------------------------------------------------ /* * Visit class header and get class name, access , and interfaces * information (step 1,2, and 3) for SVUID computation. */ @Override public void visit(final int version, final int access, final String name, final String signature, final String superName, final String[] interfaces) { computeSVUID = (access & Opcodes.ACC_INTERFACE) == 0; if (computeSVUID) { this.name = name; this.access = access; this.interfaces = interfaces; } super.visit(version, access, name, signature, superName, interfaces); } /* * Visit the methods and get constructor and method information (step 5 and * 7). Also determine if there is a class initializer (step 6). */ @Override public MethodVisitor visitMethod(final int access, final String name, final String desc, final String signature, final String[] exceptions) { if (computeSVUID) { if ("<clinit>".equals(name)) { hasStaticInitializer = true; } /* * Remembers non private constructors and methods for SVUID * computation For constructor and method modifiers, only the * ACC_PUBLIC, ACC_PRIVATE, ACC_PROTECTED, ACC_STATIC, ACC_FINAL, * ACC_SYNCHRONIZED, ACC_NATIVE, ACC_ABSTRACT and ACC_STRICT flags * are used. */ int mods = access & (Opcodes.ACC_PUBLIC | Opcodes.ACC_PRIVATE | Opcodes.ACC_PROTECTED | Opcodes.ACC_STATIC | Opcodes.ACC_FINAL | Opcodes.ACC_SYNCHRONIZED | Opcodes.ACC_NATIVE | Opcodes.ACC_ABSTRACT | Opcodes.ACC_STRICT); // all non private methods if ((access & Opcodes.ACC_PRIVATE) == 0) { if ("<init>".equals(name)) { svuidConstructors.add(new Item(name, mods, desc)); } else if (!"<clinit>".equals(name)) { svuidMethods.add(new Item(name, mods, desc)); } } } return super.visitMethod(access, name, desc, signature, exceptions); } /* * Gets class field information for step 4 of the algorithm. Also determines * if the class already has a SVUID. */ @Override public FieldVisitor visitField(final int access, final String name, final String desc, final String signature, final Object value) { if (computeSVUID) { if ("serialVersionUID".equals(name)) { // since the class already has SVUID, we won't be computing it. computeSVUID = false; hasSVUID = true; } /* * Remember field for SVUID computation For field modifiers, only * the ACC_PUBLIC, ACC_PRIVATE, ACC_PROTECTED, ACC_STATIC, * ACC_FINAL, ACC_VOLATILE, and ACC_TRANSIENT flags are used when * computing serialVersionUID values. */ if ((access & Opcodes.ACC_PRIVATE) == 0 || (access & (Opcodes.ACC_STATIC | Opcodes.ACC_TRANSIENT)) == 0) { int mods = access & (Opcodes.ACC_PUBLIC | Opcodes.ACC_PRIVATE | Opcodes.ACC_PROTECTED | Opcodes.ACC_STATIC | Opcodes.ACC_FINAL | Opcodes.ACC_VOLATILE | Opcodes.ACC_TRANSIENT); svuidFields.add(new Item(name, mods, desc)); } } return super.visitField(access, name, desc, signature, value); }
Handle a bizarre special case. Nested classes (static classes declared inside another class) that are protected have their access bit set to public in their class files to deal with some odd reflection situation. Our SVUID computation must do as the JVM does and ignore access bits in the class file in favor of the access bits InnerClass attribute.
/** * Handle a bizarre special case. Nested classes (static classes declared * inside another class) that are protected have their access bit set to * public in their class files to deal with some odd reflection situation. * Our SVUID computation must do as the JVM does and ignore access bits in * the class file in favor of the access bits InnerClass attribute. */
@Override public void visitInnerClass(final String aname, final String outerName, final String innerName, final int attr_access) { if ((name != null) && name.equals(aname)) { this.access = attr_access; } super.visitInnerClass(aname, outerName, innerName, attr_access); } /* * Add the SVUID if class doesn't have one */ @Override public void visitEnd() { // compute SVUID and add it to the class if (computeSVUID && !hasSVUID) { try { addSVUID(computeSVUID()); } catch (Throwable e) { throw new RuntimeException("Error while computing SVUID for " + name, e); } } super.visitEnd(); } // ------------------------------------------------------------------------ // Utility methods // ------------------------------------------------------------------------
Returns true if the class already has a SVUID field. The result of this method is only valid when visitEnd is or has been called.
Returns:true if the class already has a SVUID field.
/** * Returns true if the class already has a SVUID field. The result of this * method is only valid when visitEnd is or has been called. * * @return true if the class already has a SVUID field. */
public boolean hasSVUID() { return hasSVUID; } protected void addSVUID(long svuid) { FieldVisitor fv = super.visitField(Opcodes.ACC_FINAL + Opcodes.ACC_STATIC, "serialVersionUID", "J", null, new Long( svuid)); if (fv != null) { fv.visitEnd(); } }
Computes and returns the value of SVUID.
Throws:
Returns:Returns the serial version UID
/** * Computes and returns the value of SVUID. * * @return Returns the serial version UID * @throws IOException * if an I/O error occurs */
protected long computeSVUID() throws IOException { ByteArrayOutputStream bos; DataOutputStream dos = null; long svuid = 0; try { bos = new ByteArrayOutputStream(); dos = new DataOutputStream(bos); /* * 1. The class name written using UTF encoding. */ dos.writeUTF(name.replace('/', '.')); /* * 2. The class modifiers written as a 32-bit integer. */ dos.writeInt(access & (Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL | Opcodes.ACC_INTERFACE | Opcodes.ACC_ABSTRACT)); /* * 3. The name of each interface sorted by name written using UTF * encoding. */ Arrays.sort(interfaces); for (int i = 0; i < interfaces.length; i++) { dos.writeUTF(interfaces[i].replace('/', '.')); } /* * 4. For each field of the class sorted by field name (except * private static and private transient fields): * * 1. The name of the field in UTF encoding. 2. The modifiers of the * field written as a 32-bit integer. 3. The descriptor of the field * in UTF encoding * * Note that field signatures are not dot separated. Method and * constructor signatures are dot separated. Go figure... */ writeItems(svuidFields, dos, false); /* * 5. If a class initializer exists, write out the following: 1. The * name of the method, <clinit>, in UTF encoding. 2. The modifier of * the method, java.lang.reflect.Modifier.STATIC, written as a * 32-bit integer. 3. The descriptor of the method, ()V, in UTF * encoding. */ if (hasStaticInitializer) { dos.writeUTF("<clinit>"); dos.writeInt(Opcodes.ACC_STATIC); dos.writeUTF("()V"); } // if.. /* * 6. For each non-private constructor sorted by method name and * signature: 1. The name of the method, <init>, in UTF encoding. 2. * The modifiers of the method written as a 32-bit integer. 3. The * descriptor of the method in UTF encoding. */ writeItems(svuidConstructors, dos, true); /* * 7. For each non-private method sorted by method name and * signature: 1. The name of the method in UTF encoding. 2. The * modifiers of the method written as a 32-bit integer. 3. The * descriptor of the method in UTF encoding. */ writeItems(svuidMethods, dos, true); dos.flush(); /* * 8. The SHA-1 algorithm is executed on the stream of bytes * produced by DataOutputStream and produces five 32-bit values * sha[0..4]. */ byte[] hashBytes = computeSHAdigest(bos.toByteArray()); /* * 9. The hash value is assembled from the first and second 32-bit * values of the SHA-1 message digest. If the result of the message * digest, the five 32-bit words H0 H1 H2 H3 H4, is in an array of * five int values named sha, the hash value would be computed as * follows: * * long hash = ((sha[0] >>> 24) & 0xFF) | ((sha[0] >>> 16) & 0xFF) * << 8 | ((sha[0] >>> 8) & 0xFF) << 16 | ((sha[0] >>> 0) & 0xFF) << * 24 | ((sha[1] >>> 24) & 0xFF) << 32 | ((sha[1] >>> 16) & 0xFF) << * 40 | ((sha[1] >>> 8) & 0xFF) << 48 | ((sha[1] >>> 0) & 0xFF) << * 56; */ for (int i = Math.min(hashBytes.length, 8) - 1; i >= 0; i--) { svuid = (svuid << 8) | (hashBytes[i] & 0xFF); } } finally { // close the stream (if open) if (dos != null) { dos.close(); } } return svuid; }
Returns the SHA-1 message digest of the given value.
Params:
  • value – the value whose SHA message digest must be computed.
Returns:the SHA-1 message digest of the given value.
/** * Returns the SHA-1 message digest of the given value. * * @param value * the value whose SHA message digest must be computed. * @return the SHA-1 message digest of the given value. */
protected byte[] computeSHAdigest(final byte[] value) { try { return MessageDigest.getInstance("SHA").digest(value); } catch (Exception e) { throw new UnsupportedOperationException(e.toString()); } }
Sorts the items in the collection and writes it to the data output stream
Params:
  • itemCollection – collection of items
  • dos – a DataOutputStream value
  • dotted – a boolean value
Throws:
/** * Sorts the items in the collection and writes it to the data output stream * * @param itemCollection * collection of items * @param dos * a <code>DataOutputStream</code> value * @param dotted * a <code>boolean</code> value * @exception IOException * if an error occurs */
private static void writeItems(final Collection<Item> itemCollection, final DataOutput dos, final boolean dotted) throws IOException { int size = itemCollection.size(); Item[] items = itemCollection.toArray(new Item[size]); Arrays.sort(items); for (int i = 0; i < size; i++) { dos.writeUTF(items[i].name); dos.writeInt(items[i].access); dos.writeUTF(dotted ? items[i].desc.replace('/', '.') : items[i].desc); } } // ------------------------------------------------------------------------ // Inner classes // ------------------------------------------------------------------------ private static class Item implements Comparable<Item> { final String name; final int access; final String desc; Item(final String name, final int access, final String desc) { this.name = name; this.access = access; this.desc = desc; } public int compareTo(final Item other) { int retVal = name.compareTo(other.name); if (retVal == 0) { retVal = desc.compareTo(other.desc); } return retVal; } @Override public boolean equals(final Object o) { if (o instanceof Item) { return compareTo((Item) o) == 0; } return false; } @Override public int hashCode() { return (name + desc).hashCode(); } } }