jdkkeyfactory.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:   JDKKeyFactory.java

package org.bouncycastle.jce.provider;

import java.io.*;
import java.security.*;
import java.security.interfaces.*;
import java.security.spec.*;
import javax.crypto.interfaces.DHPrivateKey;
import javax.crypto.interfaces.DHPublicKey;
import org.bouncycastle.asn1.*;
import org.bouncycastle.asn1.pkcs.PKCSObjectIdentifiers;
import org.bouncycastle.asn1.pkcs.PrivateKeyInfo;
import org.bouncycastle.asn1.x509.*;
import org.bouncycastle.asn1.x9.X9ObjectIdentifiers;
import org.bouncycastle.jce.interfaces.ElGamalPrivateKey;
import org.bouncycastle.jce.interfaces.ElGamalPublicKey;
import org.bouncycastle.jce.spec.ECPrivateKeySpec;
import org.bouncycastle.jce.spec.ECPublicKeySpec;

// Referenced classes of package org.bouncycastle.jce.provider:
//			JCEECPrivateKey, JCEECPublicKey, JCERSAPublicKey

public abstract class JDKKeyFactory extends KeyFactorySpi
{
	public static class EC extends JDKKeyFactory
	{

		String algorithm;

		protected PrivateKey engineGeneratePrivate(KeySpec keySpec)
			throws InvalidKeySpecException
		{
			if (!(keySpec instanceof PKCS8EncodedKeySpec))
				break MISSING_BLOCK_LABEL_38;
			return JDKKeyFactory.createPrivateKeyFromDERStream(new ByteArrayInputStream(((PKCS8EncodedKeySpec)keySpec).getEncoded()));
			Exception e;
			e;
			throw new InvalidKeySpecException(e.toString());
			if (keySpec instanceof ECPrivateKeySpec)
				return new JCEECPrivateKey(algorithm, (ECPrivateKeySpec)keySpec);
			else
				throw new InvalidKeySpecException("Unknown KeySpec type.");
		}

		protected PublicKey engineGeneratePublic(KeySpec keySpec)
			throws InvalidKeySpecException
		{
			if (!(keySpec instanceof X509EncodedKeySpec))
				break MISSING_BLOCK_LABEL_38;
			return JDKKeyFactory.createPublicKeyFromDERStream(new ByteArrayInputStream(((X509EncodedKeySpec)keySpec).getEncoded()));
			Exception e;
			e;
			throw new InvalidKeySpecException(e.toString());
			if (keySpec instanceof ECPublicKeySpec)
				return new JCEECPublicKey(algorithm, (ECPublicKeySpec)keySpec);
			else
				throw new InvalidKeySpecException("Unknown KeySpec type.");
		}

		public EC()
		{
			this("EC");
		}

		public EC(String algorithm)
		{
			this.algorithm = algorithm;
		}
	}

	public static class ECDSA extends EC
	{

		public ECDSA()
		{
			super("ECDSA");
		}
	}


	public JDKKeyFactory()
	{
	}

	protected KeySpec engineGetKeySpec(Key key, Class spec)
		throws InvalidKeySpecException
	{
		if (spec.isAssignableFrom(java/security/spec/PKCS8EncodedKeySpec) && key.getFormat().equals("PKCS#8"))
			return new PKCS8EncodedKeySpec(key.getEncoded());
		if (spec.isAssignableFrom(java/security/spec/X509EncodedKeySpec) && key.getFormat().equals("X.509"))
			return new X509EncodedKeySpec(key.getEncoded());
		if (spec.isAssignableFrom(java/security/spec/RSAPublicKeySpec) && (key instanceof RSAPublicKey))
		{
			RSAPublicKey k = (RSAPublicKey)key;
			return new RSAPublicKeySpec(k.getModulus(), k.getPublicExponent());
		}
		if (spec.isAssignableFrom(java/security/spec/RSAPrivateKeySpec) && (key instanceof RSAPrivateKey))
		{
			RSAPrivateKey k = (RSAPrivateKey)key;
			return new RSAPrivateKeySpec(k.getModulus(), k.getPrivateExponent());
		}
		if (spec.isAssignableFrom(java/security/spec/RSAPrivateCrtKeySpec) && (key instanceof RSAPrivateCrtKey))
		{
			RSAPrivateCrtKey k = (RSAPrivateCrtKey)key;
			return new RSAPrivateCrtKeySpec(k.getModulus(), k.getPublicExponent(), k.getPrivateExponent(), k.getPrimeP(), k.getPrimeQ(), k.getPrimeExponentP(), k.getPrimeExponentQ(), k.getCrtCoefficient());
		} else
		{
			throw new RuntimeException((new StringBuilder()).append("not implemented yet ").append(key).append(" ").append(spec).toString());
		}
	}

	protected Key engineTranslateKey(Key key)
		throws InvalidKeyException
	{
		if (key instanceof RSAPublicKey)
			return new JCERSAPublicKey((RSAPublicKey)key);
		if (!(key instanceof RSAPrivateCrtKey) && !(key instanceof RSAPrivateKey) && !(key instanceof DHPublicKey) && !(key instanceof DHPrivateKey) && !(key instanceof DSAPublicKey) && !(key instanceof DSAPrivateKey) && !(key instanceof ElGamalPublicKey))
			if (!(key instanceof ElGamalPrivateKey));
		throw new InvalidKeyException("key type unknown");
	}

	static PublicKey createPublicKeyFromDERStream(InputStream in)
		throws IOException
	{
		return createPublicKeyFromPublicKeyInfo(new SubjectPublicKeyInfo((ASN1Sequence)(ASN1Sequence)(new DERInputStream(in)).readObject()));
	}

	static PublicKey createPublicKeyFromPublicKeyInfo(SubjectPublicKeyInfo info)
	{
		AlgorithmIdentifier algId = info.getAlgorithmId();
		if (algId.getObjectId().equals(PKCSObjectIdentifiers.rsaEncryption) || algId.getObjectId().equals(X509ObjectIdentifiers.id_ea_rsa))
			return new JCERSAPublicKey(info);
		if (algId.getObjectId().equals(X9ObjectIdentifiers.id_ecPublicKey))
			return new JCEECPublicKey(info);
		else
			throw new RuntimeException("algorithm identifier in key not recognised");
	}

	static PrivateKey createPrivateKeyFromDERStream(InputStream in)
		throws IOException
	{
		return createPrivateKeyFromPrivateKeyInfo(new PrivateKeyInfo((ASN1Sequence)(ASN1Sequence)(new DERInputStream(in)).readObject()));
	}

	static PrivateKey createPrivateKeyFromPrivateKeyInfo(PrivateKeyInfo info)
	{
		AlgorithmIdentifier algId = info.getAlgorithmId();
		if (algId.getObjectId().equals(X9ObjectIdentifiers.id_ecPublicKey))
			return new JCEECPrivateKey(info);
		else
			throw new RuntimeException("algorithm identifier in key not recognised");
	}
}