mirror of git://gcc.gnu.org/git/gcc.git
513 lines
14 KiB
Java
513 lines
14 KiB
Java
/* OID.java -- numeric representation of an object identifier
|
|
Copyright (C) 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
|
|
|
|
This file is part of GNU Classpath.
|
|
|
|
GNU Classpath is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2, or (at your option)
|
|
any later version.
|
|
|
|
GNU Classpath is distributed in the hope that it will be useful, but
|
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GNU Classpath; see the file COPYING. If not, write to the
|
|
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
02110-1301 USA.
|
|
|
|
Linking this library statically or dynamically with other modules is
|
|
making a combined work based on this library. Thus, the terms and
|
|
conditions of the GNU General Public License cover the whole
|
|
combination.
|
|
|
|
As a special exception, the copyright holders of this library give you
|
|
permission to link this library with independent modules to produce an
|
|
executable, regardless of the license terms of these independent
|
|
modules, and to copy and distribute the resulting executable under
|
|
terms of your choice, provided that you also meet, for each linked
|
|
independent module, the terms and conditions of the license of that
|
|
module. An independent module is a module which is not derived from
|
|
or based on this library. If you modify this library, you may extend
|
|
this exception to your version of the library, but you are not
|
|
obligated to do so. If you do not wish to do so, delete this
|
|
exception statement from your version. */
|
|
|
|
|
|
package gnu.java.security;
|
|
|
|
import gnu.java.lang.CPStringBuilder;
|
|
|
|
import gnu.java.security.der.DEREncodingException;
|
|
|
|
import java.io.ByteArrayOutputStream;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.util.StringTokenizer;
|
|
|
|
/**
|
|
* This immutable class represents an object identifier, or OID.
|
|
*
|
|
* <p>OIDs are represented as a series of hierarchical tokens, each of
|
|
* which is usually represented as a single, unsigned integer. The
|
|
* hierarchy works so that later tokens are considered within the group
|
|
* of earlier tokens. Thus, the OID for the Serpent block cipher,
|
|
* 1.3.6.1.4.1.11591.13.2, is maintained by the GNU project, whose OID
|
|
* is 1.3.6.1.4.1.11591 (which is, in turn, part of bigger, more general
|
|
* bodies; the topmost, 1, stands for the OIDs assigned by the
|
|
* International Standards Organization, ISO).
|
|
*
|
|
* <p>OIDs can be represented in a variety of ways, including the
|
|
* dotted-decimal form we use here.
|
|
*
|
|
* <p>OIDs may be relative, in which case the first two elements of the
|
|
* OID are omitted.
|
|
*
|
|
* @author Casey Marshall (csm@gnu.org)
|
|
*/
|
|
public class OID implements Cloneable, Comparable, java.io.Serializable
|
|
{
|
|
|
|
// Fields.
|
|
// ------------------------------------------------------------------------
|
|
|
|
/* Serial version id for serialization. */
|
|
static final long serialVersionUID = 5722492029044597779L;
|
|
|
|
/**
|
|
* The numeric ID structure.
|
|
*/
|
|
private int[] components;
|
|
|
|
/**
|
|
* The string representation of this OID, in dotted-decimal format.
|
|
*/
|
|
private transient String strRep;
|
|
|
|
/**
|
|
* The DER encoding of this OID.
|
|
*/
|
|
private transient byte[] der;
|
|
|
|
/**
|
|
* Whether or not this OID is relative.
|
|
*/
|
|
private boolean relative;
|
|
|
|
// Constructors.
|
|
// ------------------------------------------------------------------------
|
|
|
|
/**
|
|
* Create a new OID from the given byte array. The argument (which can
|
|
* neither be null nor zero-length) is copied to prevent subsequent
|
|
* modification.
|
|
*
|
|
* @param components The numeric IDs.
|
|
* @throws IllegalArgumentException If <i>components</i> is null or empty.
|
|
*/
|
|
public OID(int[] components)
|
|
{
|
|
this(components, false);
|
|
}
|
|
|
|
/**
|
|
* Create a new OID from the given byte array. The argument (which can
|
|
* neither be null nor zero-length) is copied to prevent subsequent
|
|
* modification.
|
|
*
|
|
* @param components The numeric IDs.
|
|
* @param relative The relative flag.
|
|
* @throws IllegalArgumentException If <i>components</i> is null or empty.
|
|
*/
|
|
public OID(int[] components, boolean relative)
|
|
{
|
|
if (components == null || components.length == 0)
|
|
throw new IllegalArgumentException();
|
|
this.components = (int[]) components.clone();
|
|
this.relative = relative;
|
|
}
|
|
|
|
/**
|
|
* Create a new OID from the given dotted-decimal representation.
|
|
*
|
|
* @param strRep The string representation of the OID.
|
|
* @throws IllegalArgumentException If the string does not contain at
|
|
* least one integer.
|
|
* @throws NumberFormatException If the string does not contain only
|
|
* numbers and periods ('.').
|
|
*/
|
|
public OID(String strRep)
|
|
{
|
|
this(strRep, false);
|
|
}
|
|
|
|
/**
|
|
* Create a new OID from the given dotted-decimal representation.
|
|
*
|
|
* @param strRep The string representation of the OID.
|
|
* @param relative The relative flag.
|
|
* @throws IllegalArgumentException If the string does not contain at
|
|
* least one integer.
|
|
* @throws NumberFormatException If the string does not contain only
|
|
* numbers and periods ('.').
|
|
*/
|
|
public OID(String strRep, boolean relative)
|
|
{
|
|
this.relative = relative;
|
|
this.strRep = strRep;
|
|
components = fromString(strRep);
|
|
}
|
|
|
|
/**
|
|
* Construct a new OID from the DER bytes in an input stream. This method
|
|
* does not read the tag or the length field from the input stream, so
|
|
* the caller must supply the number of octets in this OID's encoded
|
|
* form.
|
|
*
|
|
* @param derIn The DER input stream.
|
|
* @param len The number of bytes in the encoded form.
|
|
* @throws IOException If an error occurs reading the OID.
|
|
*/
|
|
public OID(InputStream derIn, int len) throws IOException
|
|
{
|
|
this(derIn, len, false);
|
|
}
|
|
|
|
/**
|
|
* Construct a new OID from the DER bytes in an input stream. This method
|
|
* does not read the tag or the length field from the input stream, so
|
|
* the caller must supply the number of octets in this OID's encoded
|
|
* form.
|
|
*
|
|
* @param derIn The DER input stream.
|
|
* @param len The number of bytes in the encoded form.
|
|
* @param relative The relative flag.
|
|
* @throws IOException If an error occurs reading the OID.
|
|
*/
|
|
public OID(InputStream derIn, int len, boolean relative) throws IOException
|
|
{
|
|
der = new byte[len];
|
|
derIn.read(der);
|
|
this.relative = relative;
|
|
try
|
|
{
|
|
components = fromDER(der, relative);
|
|
}
|
|
catch (ArrayIndexOutOfBoundsException aioobe)
|
|
{
|
|
aioobe.printStackTrace();
|
|
throw aioobe;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Construct a new OID from the given DER bytes.
|
|
*
|
|
* @param encoded The DER encoded OID.
|
|
* @throws IOException If an error occurs reading the OID.
|
|
*/
|
|
public OID(byte[] encoded) throws IOException
|
|
{
|
|
this(encoded, false);
|
|
}
|
|
|
|
/**
|
|
* Construct a new OID from the given DER bytes.
|
|
*
|
|
* @param encoded The encoded relative OID.
|
|
* @param relative The relative flag.
|
|
*/
|
|
public OID(byte[] encoded, boolean relative) throws IOException
|
|
{
|
|
der = (byte[]) encoded.clone();
|
|
this.relative = relative;
|
|
try
|
|
{
|
|
components = fromDER(der, relative);
|
|
}
|
|
catch (ArrayIndexOutOfBoundsException aioobe)
|
|
{
|
|
aioobe.printStackTrace();
|
|
throw aioobe;
|
|
}
|
|
}
|
|
|
|
// Instance methods.
|
|
// ------------------------------------------------------------------------
|
|
|
|
/**
|
|
* Return the numeric IDs of this OID. The value returned is copied to
|
|
* prevent modification.
|
|
*
|
|
* @return The IDs in a new integer array.
|
|
*/
|
|
public int[] getIDs()
|
|
{
|
|
return (int[]) components.clone();
|
|
}
|
|
|
|
/**
|
|
* Get the DER encoding of this OID, minus the tag and length fields.
|
|
*
|
|
* @return The DER bytes.
|
|
*/
|
|
public byte[] getDER()
|
|
{
|
|
if (der == null)
|
|
{
|
|
ByteArrayOutputStream bout = new ByteArrayOutputStream();
|
|
int i = 0;
|
|
if (!relative)
|
|
{
|
|
int b = components[i++] * 40 + (components.length > 1
|
|
? components[i++] : 0);
|
|
encodeSubID(bout, b);
|
|
}
|
|
for ( ; i < components.length; i++)
|
|
encodeSubID(bout, components[i]);
|
|
der = bout.toByteArray();
|
|
}
|
|
return (byte[]) der.clone();
|
|
}
|
|
|
|
/**
|
|
* Get the parent OID of this OID. That is, if this OID is "1.2.3.4",
|
|
* then the parent OID will be "1.2.3". If this OID is a top-level
|
|
* OID, this method returns null.
|
|
*
|
|
* @return The parent OID, or null.
|
|
*/
|
|
public OID getParent()
|
|
{
|
|
if (components.length == 1)
|
|
return null;
|
|
int[] parent = new int[components.length - 1];
|
|
System.arraycopy(components, 0, parent, 0, parent.length);
|
|
return new OID(parent);
|
|
}
|
|
|
|
public OID getChild(int id)
|
|
{
|
|
int[] child = new int[components.length + 1];
|
|
System.arraycopy(components, 0, child, 0, components.length);
|
|
child[child.length - 1] = id;
|
|
return new OID(child);
|
|
}
|
|
|
|
/**
|
|
* Get the root OID of this OID. That is, the first two components.
|
|
*
|
|
* @return The root OID.
|
|
*/
|
|
public OID getRoot()
|
|
{
|
|
if (components.length <= 2)
|
|
return this;
|
|
int[] root = new int[2];
|
|
root[0] = components[0];
|
|
root[1] = components[1];
|
|
return new OID(root);
|
|
}
|
|
|
|
public boolean isRelative()
|
|
{
|
|
return relative;
|
|
}
|
|
|
|
/**
|
|
* Returns a copy of this OID.
|
|
*
|
|
* @return The copy.
|
|
*/
|
|
public Object clone()
|
|
{
|
|
try
|
|
{
|
|
return super.clone();
|
|
}
|
|
catch (CloneNotSupportedException cnse)
|
|
{
|
|
InternalError ie = new InternalError();
|
|
ie.initCause(cnse);
|
|
throw ie;
|
|
}
|
|
}
|
|
|
|
/* Nice idea, but possibly too expensive for whatever benefit it
|
|
* provides.
|
|
|
|
public String getShortName()
|
|
{
|
|
return OIDTable.getShortName(this);
|
|
}
|
|
|
|
public String getLongName()
|
|
{
|
|
return OIDTable.getLongName(this);
|
|
}
|
|
|
|
*/
|
|
|
|
/**
|
|
* Returns the value of this OID in dotted-decimal format.
|
|
*
|
|
* @return The string representation.
|
|
*/
|
|
public String toString()
|
|
{
|
|
if (strRep != null)
|
|
return strRep;
|
|
else
|
|
{
|
|
CPStringBuilder buf = new CPStringBuilder();
|
|
for (int i = 0; i < components.length; i++)
|
|
{
|
|
buf.append((long) components[i] & 0xFFFFFFFFL);
|
|
if (i < components.length - 1)
|
|
buf.append('.');
|
|
}
|
|
return (strRep = buf.toString());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Computes a hash code for this OID.
|
|
*
|
|
* @return The hash code.
|
|
*/
|
|
public int hashCode()
|
|
{
|
|
int ret = 0;
|
|
for (int i = 0; i < components.length; i++)
|
|
ret += components[i] << (i & 31);
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* Tests whether or not this OID equals another.
|
|
*
|
|
* @return Whether or not this OID equals the other.
|
|
*/
|
|
public boolean equals(Object o)
|
|
{
|
|
if (!(o instanceof OID))
|
|
return false;
|
|
return java.util.Arrays.equals(components, ((OID) o).components);
|
|
}
|
|
|
|
/**
|
|
* Compares this OID to another. The comparison is essentially
|
|
* lexicographic, where the two OIDs are compared until their
|
|
* first difference, then that difference is returned. If one OID is
|
|
* shorter, but all elements equal between the two for the shorter
|
|
* length, then the shorter OID is lesser than the longer.
|
|
*
|
|
* @param o The object to compare.
|
|
* @return An integer less than, equal to, or greater than zero if
|
|
* this object is less than, equal to, or greater than the
|
|
* argument.
|
|
* @throws ClassCastException If <i>o</i> is not an OID.
|
|
*/
|
|
public int compareTo(Object o)
|
|
{
|
|
if (equals(o))
|
|
return 0;
|
|
int[] components2 = ((OID) o).components;
|
|
int len = Math.min(components.length, components2.length);
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
if (components[i] != components2[i])
|
|
return (components[i] < components2[i]) ? -1 : 1;
|
|
}
|
|
if (components.length == components2.length)
|
|
return 0;
|
|
return (components.length < components2.length) ? -1 : 1;
|
|
}
|
|
|
|
// Own methods.
|
|
// ------------------------------------------------------------------------
|
|
|
|
private static int[] fromDER(byte[] der, boolean relative)
|
|
throws DEREncodingException
|
|
{
|
|
// cannot be longer than this.
|
|
int[] components = new int[der.length + 1];
|
|
int count = 0;
|
|
int i = 0;
|
|
if (!relative && i < der.length)
|
|
{
|
|
// Non-relative OIDs have the first two arcs coded as:
|
|
//
|
|
// i = first_arc * 40 + second_arc;
|
|
//
|
|
int j = (der[i] & 0xFF);
|
|
components[count++] = j / 40;
|
|
components[count++] = j % 40;
|
|
i++;
|
|
}
|
|
while (i < der.length)
|
|
{
|
|
int j = 0;
|
|
do
|
|
{
|
|
j = der[i++] & 0xFF;
|
|
components[count] <<= 7;
|
|
components[count] |= j & 0x7F;
|
|
if (i >= der.length && (j & 0x80) != 0)
|
|
throw new DEREncodingException("malformed OID");
|
|
}
|
|
while ((j & 0x80) != 0);
|
|
count++;
|
|
}
|
|
if (count == components.length)
|
|
return components;
|
|
int[] ret = new int[count];
|
|
System.arraycopy(components, 0, ret, 0, count);
|
|
return ret;
|
|
}
|
|
|
|
private static int[] fromString(String strRep) throws NumberFormatException
|
|
{
|
|
if (strRep.startsWith("OID.") || strRep.startsWith("oid."))
|
|
strRep = strRep.substring(4);
|
|
StringTokenizer tok = new StringTokenizer(strRep, ".");
|
|
if (tok.countTokens() == 0)
|
|
throw new IllegalArgumentException();
|
|
int[] components = new int[tok.countTokens()];
|
|
int i = 0;
|
|
while (tok.hasMoreTokens())
|
|
{
|
|
components[i++] = Integer.parseInt(tok.nextToken());
|
|
}
|
|
return components;
|
|
}
|
|
|
|
private static void encodeSubID(ByteArrayOutputStream out, int id)
|
|
{
|
|
if (id < 128)
|
|
{
|
|
out.write(id);
|
|
}
|
|
else if (id < 16384)
|
|
{
|
|
out.write((id >>> 7) | 0x80);
|
|
out.write(id & 0x7F);
|
|
}
|
|
else if (id < 2097152)
|
|
{
|
|
out.write((id >>> 14) | 0x80);
|
|
out.write(((id >>> 7) | 0x80) & 0xFF);
|
|
out.write(id & 0x7F);
|
|
}
|
|
else if (id < 268435456)
|
|
{
|
|
out.write( (id >>> 21) | 0x80);
|
|
out.write(((id >>> 14) | 0x80) & 0xFF);
|
|
out.write(((id >>> 7) | 0x80) & 0xFF);
|
|
out.write(id & 0x7F);
|
|
}
|
|
}
|
|
}
|