public PGPSecretKey parseSecretKey()

in org.eclipse.jgit.gpg.bc/src/org/eclipse/jgit/gpg/bc/internal/keys/SExprParser.java [100:241]
117 lines of code
20 McCabe index (conditional complexity)

	public PGPSecretKey parseSecretKey(InputStream inputStream,
			PBEProtectionRemoverFactory keyProtectionRemoverFactory,
			PGPPublicKey pubKey) throws IOException, PGPException {
		SXprUtils.skipOpenParenthesis(inputStream);

		String type;

		type = SXprUtils.readString(inputStream, inputStream.read());
		if (type.equals("protected-private-key")
				|| type.equals("private-key")) {
			SXprUtils.skipOpenParenthesis(inputStream);

			String keyType = SXprUtils.readString(inputStream,
					inputStream.read());
			if (keyType.equals("ecc")) {
				SXprUtils.skipOpenParenthesis(inputStream);

				String curveID = SXprUtils.readString(inputStream,
						inputStream.read());
				String curveName = SXprUtils.readString(inputStream,
						inputStream.read());

				SXprUtils.skipCloseParenthesis(inputStream);

				byte[] qVal;

				SXprUtils.skipOpenParenthesis(inputStream);

				type = SXprUtils.readString(inputStream, inputStream.read());
				if (type.equals("q")) {
					qVal = SXprUtils.readBytes(inputStream, inputStream.read());
				} else {
					throw new PGPException("no q value found");
				}

				SXprUtils.skipCloseParenthesis(inputStream);

				BigInteger d = processECSecretKey(inputStream, curveID,
						curveName, qVal, keyProtectionRemoverFactory);

				if (curveName.startsWith("NIST ")) {
					curveName = curveName.substring("NIST ".length());
				}

				ECPublicBCPGKey basePubKey = new ECDSAPublicBCPGKey(
						ECNamedCurveTable.getOID(curveName),
						new BigInteger(1, qVal));
				ECPublicBCPGKey assocPubKey = (ECPublicBCPGKey) pubKey
						.getPublicKeyPacket().getKey();
				if (!basePubKey.getCurveOID().equals(assocPubKey.getCurveOID())
						|| !basePubKey.getEncodedPoint()
								.equals(assocPubKey.getEncodedPoint())) {
					throw new PGPException(
							"passed in public key does not match secret key");
				}

				return new PGPSecretKey(
						new SecretKeyPacket(pubKey.getPublicKeyPacket(),
								SymmetricKeyAlgorithmTags.NULL, null, null,
								new ECSecretBCPGKey(d).getEncoded()),
						pubKey);
			} else if (keyType.equals("dsa")) {
				BigInteger p = readBigInteger("p", inputStream);
				BigInteger q = readBigInteger("q", inputStream);
				BigInteger g = readBigInteger("g", inputStream);

				BigInteger y = readBigInteger("y", inputStream);

				BigInteger x = processDSASecretKey(inputStream, p, q, g, y,
						keyProtectionRemoverFactory);

				DSAPublicBCPGKey basePubKey = new DSAPublicBCPGKey(p, q, g, y);
				DSAPublicBCPGKey assocPubKey = (DSAPublicBCPGKey) pubKey
						.getPublicKeyPacket().getKey();
				if (!basePubKey.getP().equals(assocPubKey.getP())
						|| !basePubKey.getQ().equals(assocPubKey.getQ())
						|| !basePubKey.getG().equals(assocPubKey.getG())
						|| !basePubKey.getY().equals(assocPubKey.getY())) {
					throw new PGPException(
							"passed in public key does not match secret key");
				}
				return new PGPSecretKey(
						new SecretKeyPacket(pubKey.getPublicKeyPacket(),
								SymmetricKeyAlgorithmTags.NULL, null, null,
								new DSASecretBCPGKey(x).getEncoded()),
						pubKey);
			} else if (keyType.equals("elg")) {
				BigInteger p = readBigInteger("p", inputStream);
				BigInteger g = readBigInteger("g", inputStream);

				BigInteger y = readBigInteger("y", inputStream);

				BigInteger x = processElGamalSecretKey(inputStream, p, g, y,
						keyProtectionRemoverFactory);

				ElGamalPublicBCPGKey basePubKey = new ElGamalPublicBCPGKey(p, g,
						y);
				ElGamalPublicBCPGKey assocPubKey = (ElGamalPublicBCPGKey) pubKey
						.getPublicKeyPacket().getKey();
				if (!basePubKey.getP().equals(assocPubKey.getP())
						|| !basePubKey.getG().equals(assocPubKey.getG())
						|| !basePubKey.getY().equals(assocPubKey.getY())) {
					throw new PGPException(
							"passed in public key does not match secret key");
				}

				return new PGPSecretKey(
						new SecretKeyPacket(pubKey.getPublicKeyPacket(),
								SymmetricKeyAlgorithmTags.NULL, null, null,
								new ElGamalSecretBCPGKey(x).getEncoded()),
						pubKey);
			} else if (keyType.equals("rsa")) {
				BigInteger n = readBigInteger("n", inputStream);
				BigInteger e = readBigInteger("e", inputStream);

				BigInteger[] values = processRSASecretKey(inputStream, n, e,
						keyProtectionRemoverFactory);

				// TODO: type of RSA key?
				RSAPublicBCPGKey basePubKey = new RSAPublicBCPGKey(n, e);
				RSAPublicBCPGKey assocPubKey = (RSAPublicBCPGKey) pubKey
						.getPublicKeyPacket().getKey();
				if (!basePubKey.getModulus().equals(assocPubKey.getModulus())
						|| !basePubKey.getPublicExponent()
								.equals(assocPubKey.getPublicExponent())) {
					throw new PGPException(
							"passed in public key does not match secret key");
				}

				return new PGPSecretKey(new SecretKeyPacket(
						pubKey.getPublicKeyPacket(),
						SymmetricKeyAlgorithmTags.NULL, null, null,
						new RSASecretBCPGKey(values[0], values[1], values[2])
								.getEncoded()),
						pubKey);
			} else {
				throw new PGPException("unknown key type: " + keyType);
			}
		}

		throw new PGPException("unknown key type found");
	}