import org.bouncycastle.bcpg.PublicKeyPacket; //导入依赖的package包/类
public static String getAgreementAlgorithm(PublicKeyPacket pubKeyData)
{
    ECDHPublicBCPGKey ecKey = (ECDHPublicBCPGKey)pubKeyData.getKey();

    switch (ecKey.getHashAlgorithm())
    {
    case HashAlgorithmTags.SHA256:
        return "ECCDHwithSHA256CKDF";
    case HashAlgorithmTags.SHA384:
        return "ECCDHwithSHA384CKDF";
    case HashAlgorithmTags.SHA512:
        return "ECCDHwithSHA512CKDF";
    default:
        throw new IllegalArgumentException("Unknown hash algorithm specified: " + ecKey.getHashAlgorithm());
    }
}
 

import org.bouncycastle.bcpg.PublicKeyPacket; //导入依赖的package包/类
public static byte[] createUserKeyingMaterial(PublicKeyPacket pubKeyData, KeyFingerPrintCalculator fingerPrintCalculator)
    throws IOException, PGPException
{
    ByteArrayOutputStream pOut = new ByteArrayOutputStream();
    ECDHPublicBCPGKey ecKey = (ECDHPublicBCPGKey)pubKeyData.getKey();
    byte[] encOid = ecKey.getCurveOID().getEncoded();

    pOut.write(encOid, 1, encOid.length - 1);
    pOut.write(pubKeyData.getAlgorithm());
    pOut.write(0x03);
    pOut.write(0x01);
    pOut.write(ecKey.getHashAlgorithm());
    pOut.write(ecKey.getSymmetricKeyAlgorithm());
    pOut.write(ANONYMOUS_SENDER);
    pOut.write(fingerPrintCalculator.calculateFingerprint(pubKeyData));

    return pOut.toByteArray();
}
 

import org.bouncycastle.bcpg.PublicKeyPacket; //导入依赖的package包/类
PGPPublicKey(
    PublicKeyPacket publicPk,
    TrustPacket     trustPk,
    List            keySigs,
    List            ids,
    List            idTrusts,
    List            idSigs,
    KeyFingerPrintCalculator fingerPrintCalculator)
    throws PGPException
{
    this.publicPk = publicPk;
    this.trustPk = trustPk;
    this.keySigs = keySigs;
    this.ids = ids;
    this.idTrusts = idTrusts;
    this.idSigs = idSigs;

    init(fingerPrintCalculator);
}
 

import org.bouncycastle.bcpg.PublicKeyPacket; //导入依赖的package包/类
private static PGPPrivateKey mockPrivateKey(
    boolean altId,
    boolean altBcpgKeyFormat,
    boolean altBcpgKeyEncoded,
    boolean altPublicKeyPacketEncoded)
    throws IOException {
  String bcpgKeyFormat = altBcpgKeyFormat ? "alternate" : "bcpgFormat";
  String bcpgKeyEncoded = altBcpgKeyEncoded ? "alternate" : "bcpgEncoded";
  String publicKeyPacketEncoded = altPublicKeyPacketEncoded ? "alternate" : "packetEncoded";

  BCPGKey bcpgKey = mock(BCPGKey.class);
  PublicKeyPacket publicKeyPacket = mock(PublicKeyPacket.class);
  when(bcpgKey.getFormat()).thenReturn(bcpgKeyFormat);
  when(bcpgKey.getEncoded()).thenReturn(bcpgKeyEncoded.getBytes(UTF_8));
  when(publicKeyPacket.getEncoded()).thenReturn(publicKeyPacketEncoded.getBytes(UTF_8));
  return new PGPPrivateKey(altId ? 2 : 1, publicKeyPacket, bcpgKey);
}
 

import org.bouncycastle.bcpg.PublicKeyPacket; //导入依赖的package包/类
public PGPPrivateKey(
    long              keyID,
    PublicKeyPacket   publicKeyPacket,
    BCPGKey           privateKeyDataPacket)
{
    this.keyID = keyID;
    this.publicKeyPacket = publicKeyPacket;
    this.privateKeyDataPacket = privateKeyDataPacket;
}
 

import org.bouncycastle.bcpg.PublicKeyPacket; //导入依赖的package包/类
static PGPPublicKey readSubkey(BCPGInputStream in, KeyFingerPrintCalculator fingerPrintCalculator)
    throws IOException, PGPException
{
    PublicKeyPacket pk = (PublicKeyPacket)in.readPacket();
    TrustPacket     kTrust = readOptionalTrustPacket(in);

    // PGP 8 actually leaves out the signature.
    List sigList = readSignaturesAndTrust(in);

    return new PGPPublicKey(pk, kTrust, sigList, fingerPrintCalculator);
}
 

import org.bouncycastle.bcpg.PublicKeyPacket; //导入依赖的package包/类
@VisibleForTesting
static boolean compare(PublicKeyPacket a, PublicKeyPacket b) {
  if (a == null || b == null) {
    return a == null && b == null;
  }
  try {
    return Arrays.equals(a.getEncoded(), b.getEncoded());
  } catch (IOException e) {
    logger.severefmt("ComparatorKeyring error: PublicKeyPacket.getEncoded failed: %s", e);
    return false;
  }
}
 

import org.bouncycastle.bcpg.PublicKeyPacket; //导入依赖的package包/类
@Override
public void printPublicKey ( final OutputStream out ) throws IOException
{
    final ArmoredOutputStream armoredOutput = new ArmoredOutputStream ( out );
    final PublicKeyPacket pubKey = this.privateKey.getPublicKeyPacket ();
    pubKey.encode ( new BCPGOutputStream ( armoredOutput ) );
    armoredOutput.close ();
}
 

import org.bouncycastle.bcpg.PublicKeyPacket; //导入依赖的package包/类
public PublicKeyPacket getPublicKeyPacket()
{
    return publicKeyPacket;
}
 

import org.bouncycastle.bcpg.PublicKeyPacket; //导入依赖的package包/类
/**
 * Parse a secret key from one of the GPG S expression keys.
 *
 * @return a secret key object.
 */
public static PGPSecretKey parseSecretKeyFromSExpr(InputStream inputStream, PBEProtectionRemoverFactory keyProtectionRemoverFactory, KeyFingerPrintCalculator fingerPrintCalculator)
    throws IOException, PGPException
{
    SXprUtils.skipOpenParenthesis(inputStream);

    String type;

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

        String curveName;

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

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

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

            SXprUtils.skipCloseParenthesis(inputStream);
        }
        else
        {
            throw new PGPException("no curve details found");
        }

        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");
        }

        PublicKeyPacket pubPacket = new PublicKeyPacket(PublicKeyAlgorithmTags.ECDSA, new Date(), new ECDSAPublicBCPGKey(ECNamedCurveTable.getOID(curveName), new BigInteger(1, qVal)));

        SXprUtils.skipCloseParenthesis(inputStream);

        byte[] dValue = getDValue(inputStream, keyProtectionRemoverFactory, curveName);
        // TODO: check SHA-1 hash.

        return new PGPSecretKey(new SecretKeyPacket(pubPacket, SymmetricKeyAlgorithmTags.NULL, null, null, new ECSecretBCPGKey(new BigInteger(1, dValue)).getEncoded()), new PGPPublicKey(pubPacket, fingerPrintCalculator));
    }

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

import org.bouncycastle.bcpg.PublicKeyPacket; //导入依赖的package包/类
byte[] calculateFingerprint(PublicKeyPacket publicPk)
throws PGPException;
 

import org.bouncycastle.bcpg.PublicKeyPacket; //导入依赖的package包/类
public PublicKeyPacket getPublicKeyPacket()
{
    return publicPk;
}
 

import org.bouncycastle.bcpg.PublicKeyPacket; //导入依赖的package包/类
public PGPPublicKeyRing(
    InputStream    in,
    KeyFingerPrintCalculator fingerPrintCalculator)
    throws IOException
{
    this.keys = new ArrayList();

    BCPGInputStream pIn = wrap(in);

    int initialTag = pIn.nextPacketTag();
    if (initialTag != PacketTags.PUBLIC_KEY && initialTag != PacketTags.PUBLIC_SUBKEY)
    {
        throw new IOException(
            "public key ring doesn't start with public key tag: " +
            "tag 0x" + Integer.toHexString(initialTag));
    }

    PublicKeyPacket pubPk = (PublicKeyPacket)pIn.readPacket();
    TrustPacket     trustPk = readOptionalTrustPacket(pIn);

    // direct signatures and revocations
    List keySigs = readSignaturesAndTrust(pIn);

    List ids = new ArrayList();
    List idTrusts = new ArrayList();
    List idSigs = new ArrayList();
    readUserIDs(pIn, ids, idTrusts, idSigs);

    try
    {
        keys.add(new PGPPublicKey(pubPk, trustPk, keySigs, ids, idTrusts, idSigs, fingerPrintCalculator));

        // Read subkeys
        while (pIn.nextPacketTag() == PacketTags.PUBLIC_SUBKEY)
        {
            keys.add(readSubkey(pIn, fingerPrintCalculator));
        }
    }
    catch (PGPException e)
    {
        throw new IOException("processing exception: " + e.toString());
    }
}