derobjectidentifier.java

java 文件下载器。可自定义

// Decompiled by Jad v1.5.8e2. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://kpdus.tripod.com/jad.html
// Decompiler options: packimports(3) fieldsfirst ansi space 
// Source File Name:   DERObjectIdentifier.java

package org.bouncycastle.asn1;

import java.io.*;
import java.math.BigInteger;

// Referenced classes of package org.bouncycastle.asn1:
//			ASN1Object, ASN1OctetString, ASN1TaggedObject, DEROutputStream, 
//			OIDTokenizer, DERObject

public class DERObjectIdentifier extends ASN1Object
{

	String identifier;

	public static DERObjectIdentifier getInstance(Object obj)
	{
		if (obj == null || (obj instanceof DERObjectIdentifier))
			return (DERObjectIdentifier)obj;
		if (obj instanceof ASN1OctetString)
			return new DERObjectIdentifier(((ASN1OctetString)obj).getOctets());
		if (obj instanceof ASN1TaggedObject)
			return getInstance(((ASN1TaggedObject)obj).getObject());
		else
			throw new IllegalArgumentException((new StringBuilder()).append("illegal object in getInstance: ").append(obj.getClass().getName()).toString());
	}

	public static DERObjectIdentifier getInstance(ASN1TaggedObject obj, boolean explicit)
	{
		return getInstance(obj.getObject());
	}

	DERObjectIdentifier(byte bytes[])
	{
		StringBuffer objId = new StringBuffer();
		long value = 0L;
		BigInteger bigValue = null;
		boolean first = true;
		for (int i = 0; i != bytes.length; i++)
		{
			int b = bytes[i] & 0xff;
			if (value < 0x80000000000000L)
			{
				value = value * 128L + (long)(b & 0x7f);
				if ((b & 0x80) != 0)
					continue;
				if (first)
				{
					switch ((int)value / 40)
					{
					case 0: // '\0'
						objId.append('0');
						break;

					case 1: // '\001'
						objId.append('1');
						value -= 40L;
						break;

					default:
						objId.append('2');
						value -= 80L;
						break;
					}
					first = false;
				}
				objId.append('.');
				objId.append(value);
				value = 0L;
				continue;
			}
			if (bigValue == null)
				bigValue = BigInteger.valueOf(value);
			bigValue = bigValue.shiftLeft(7);
			bigValue = bigValue.or(BigInteger.valueOf(b & 0x7f));
			if ((b & 0x80) == 0)
			{
				objId.append('.');
				objId.append(bigValue);
				bigValue = null;
				value = 0L;
			}
		}

		identifier = objId.toString();
	}

	public DERObjectIdentifier(String identifier)
	{
		if (!isValidIdentifier(identifier))
		{
			throw new IllegalArgumentException((new StringBuilder()).append("string ").append(identifier).append(" not an OID").toString());
		} else
		{
			this.identifier = identifier;
			return;
		}
	}

	public String getId()
	{
		return identifier;
	}

	private void writeField(OutputStream out, long fieldValue)
		throws IOException
	{
		if (fieldValue >= 128L)
		{
			if (fieldValue >= 16384L)
			{
				if (fieldValue >= 0x200000L)
				{
					if (fieldValue >= 0x10000000L)
					{
						if (fieldValue >= 0x800000000L)
						{
							if (fieldValue >= 0x40000000000L)
							{
								if (fieldValue >= 0x2000000000000L)
								{
									if (fieldValue >= 0x100000000000000L)
										out.write((int)(fieldValue >> 56) | 0x80);
									out.write((int)(fieldValue >> 49) | 0x80);
								}
								out.write((int)(fieldValue >> 42) | 0x80);
							}
							out.write((int)(fieldValue >> 35) | 0x80);
						}
						out.write((int)(fieldValue >> 28) | 0x80);
					}
					out.write((int)(fieldValue >> 21) | 0x80);
				}
				out.write((int)(fieldValue >> 14) | 0x80);
			}
			out.write((int)(fieldValue >> 7) | 0x80);
		}
		out.write((int)fieldValue & 0x7f);
	}

	private void writeField(OutputStream out, BigInteger fieldValue)
		throws IOException
	{
		int byteCount = (fieldValue.bitLength() + 6) / 7;
		if (byteCount == 0)
		{
			out.write(0);
		} else
		{
			BigInteger tmpValue = fieldValue;
			byte tmp[] = new byte[byteCount];
			for (int i = byteCount - 1; i >= 0; i--)
			{
				tmp[i] = (byte)(tmpValue.intValue() & 0x7f | 0x80);
				tmpValue = tmpValue.shiftRight(7);
			}

			tmp[byteCount - 1] &= 0x7f;
			out.write(tmp);
		}
	}

	void encode(DEROutputStream out)
		throws IOException
	{
		OIDTokenizer tok = new OIDTokenizer(identifier);
		ByteArrayOutputStream bOut = new ByteArrayOutputStream();
		DEROutputStream dOut = new DEROutputStream(bOut);
		writeField(bOut, Integer.parseInt(tok.nextToken()) * 40 + Integer.parseInt(tok.nextToken()));
		while (tok.hasMoreTokens()) 
		{
			String token = tok.nextToken();
			if (token.length() < 18)
				writeField(bOut, Long.parseLong(token));
			else
				writeField(bOut, new BigInteger(token));
		}
		dOut.close();
		byte bytes[] = bOut.toByteArray();
		out.writeEncoded(6, bytes);
	}

	public int hashCode()
	{
		return identifier.hashCode();
	}

	boolean asn1Equals(DERObject o)
	{
		if (!(o instanceof DERObjectIdentifier))
			return false;
		else
			return identifier.equals(((DERObjectIdentifier)o).identifier);
	}

	public String toString()
	{
		return getId();
	}

	private static boolean isValidIdentifier(String identifier)
	{
		if (identifier.length() < 3 || identifier.charAt(1) != '.')
			return false;
		char first = identifier.charAt(0);
		if (first < '0' || first > '2')
			return false;
		boolean periodAllowed = false;
		for (int i = identifier.length() - 1; i >= 2; i--)
		{
			char ch = identifier.charAt(i);
			if ('0' <= ch && ch <= '9')
			{
				periodAllowed = true;
				continue;
			}
			if (ch == '.')
			{
				if (!periodAllowed)
					return false;
				periodAllowed = false;
			} else
			{
				return false;
			}
		}

		return periodAllowed;
	}
}