Java PGPPublicKeyRing.getPublicKeys方法代码示例

import org.spongycastle.openpgp.PGPPublicKeyRing; //导入方法依赖的package包/类
public PGPPubkeyEncryptionUtil(String pubkeyBlock){
    InputStream in = new ByteArrayInputStream(pubkeyBlock.getBytes());
    publicKey = null;
    try {
        in = PGPUtil.getDecoderStream(in);
        JcaPGPPublicKeyRingCollection pgpPub = new JcaPGPPublicKeyRingCollection(in);
        in.close();
        Iterator<PGPPublicKeyRing> rIt = pgpPub.getKeyRings();
        while (publicKey == null && rIt.hasNext()) {
            PGPPublicKeyRing keyRing = rIt.next();
            Iterator<PGPPublicKey> kIt = keyRing.getPublicKeys();
            while (publicKey == null && kIt.hasNext()) {
                PGPPublicKey k = kIt.next();
                if (k.isEncryptionKey()) {
                    publicKey = k;
                }
            }
        }
    } catch (Exception e){
        Log.e(LOGCATTAG, e.toString());
    }
}
 

import org.spongycastle.openpgp.PGPPublicKeyRing; //导入方法依赖的package包/类
public static PGPPublicKey readPublicKeyFromCol(InputStream in) throws IOException, PGPException {
    in = PGPUtil.getDecoderStream(in);
    PGPPublicKeyRingCollection pgpPub = new PGPPublicKeyRingCollection(in, new BcKeyFingerprintCalculator());
    PGPPublicKey key = null;
    Iterator<PGPPublicKeyRing> keyRings = pgpPub.getKeyRings();
    while (key == null && keyRings.hasNext()) {
        PGPPublicKeyRing keyRing = keyRings.next();
        Iterator<PGPPublicKey> keys = keyRing.getPublicKeys();
        while (keys.hasNext()) {
            PGPPublicKey k = keys.next();
            if (k.isEncryptionKey()) {
                key = k;
                break;
            }
        }
    }
    if (key == null)
        throw new PGPException("Can't find a valid encryption key in key ring.");

    return key;
}
 

import org.spongycastle.openpgp.PGPPublicKeyRing; //导入方法依赖的package包/类
public static PGPPublicKey getEncryptionKey(PGPPublicKeyRing publicKeyring) {
    @SuppressWarnings("unchecked")
    Iterator<PGPPublicKey> iter = publicKeyring.getPublicKeys();
    while (iter.hasNext()) {
        PGPPublicKey pk = iter.next();
        if (!pk.isMasterKey()) {
            int keyFlags = getKeyFlags(pk);
            if ((keyFlags & PGPKeyFlags.CAN_ENCRYPT_COMMS) == PGPKeyFlags.CAN_ENCRYPT_COMMS)
                return pk;

        }
    }

    // legacy key format support
    return getLegacyEncryptionKey(publicKeyring);
}
 

import org.spongycastle.openpgp.PGPPublicKeyRing; //导入方法依赖的package包/类
/**
 * Searches for the master (signing) key in the given public keyring and
 * signs it with our master key.
 * @return the same public keyring with the signed key. This is suitable to
 * be imported directly into GnuPG.
 * @see #signPublicKey(PGPPublicKey, String)
 */
@SuppressWarnings("unchecked")
public PGPPublicKeyRing signPublicKey(byte[] publicKeyring, String id)
        throws PGPException, IOException, SignatureException {

    PGPObjectFactory reader = new PGPObjectFactory(publicKeyring);
    Object o = reader.nextObject();
    while (o != null) {
        if (o instanceof PGPPublicKeyRing) {
            PGPPublicKeyRing pubRing = (PGPPublicKeyRing) o;
            Iterator<PGPPublicKey> iter = pubRing.getPublicKeys();
            while (iter.hasNext()) {
                PGPPublicKey pk = iter.next();
                if (pk.isMasterKey()) {
                    PGPPublicKey signed = signPublicKey(pk, id);
                    return PGPPublicKeyRing.insertPublicKey(pubRing, signed);
                }
            }
        }
        o = reader.nextObject();
    }

    throw new PGPException("invalid keyring data.");
}
 

import org.spongycastle.openpgp.PGPPublicKeyRing; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
public static PGPPublicKey extractPublicKeyFromBytes(byte[] keyBlock) throws IOException, PGPException {
	PGPPublicKeyRingCollection keyringCol = new PGPPublicKeyRingCollection(PGPUtil.getDecoderStream(new ByteArrayInputStream(Base64.decode(keyBlock, Base64.DEFAULT))));
	PGPPublicKey key = null;
	Iterator<PGPPublicKeyRing> rIt = keyringCol.getKeyRings();
	while(key == null && rIt.hasNext()) {
		PGPPublicKeyRing keyring = (PGPPublicKeyRing) rIt.next();
		Iterator<PGPPublicKey> kIt = keyring.getPublicKeys();
		while(key == null && kIt.hasNext()) {
			PGPPublicKey k = (PGPPublicKey) kIt.next();
			if(k.isEncryptionKey())
				key = k;
		}
	}
	
	if(key == null) {
		throw new IllegalArgumentException("there isn't an encryption key here.");
	}

	return key;
}
 

import org.spongycastle.openpgp.PGPPublicKeyRing; //导入方法依赖的package包/类
/**
 * A simple routine that opens a key ring file and loads the first available key
 * suitable for encryption.
 *
 * @param input data stream containing the public key data
 * @return the first public key found.
 * @throws IOException
 * @throws PGPException
 */
static PGPPublicKey readPublicKey(InputStream input) throws IOException, PGPException
{
    PGPPublicKeyRingCollection pgpPub = new PGPPublicKeyRingCollection(
            PGPUtil.getDecoderStream(input), new JcaKeyFingerprintCalculator());

    //
    // we just loop through the collection till we find a key suitable for encryption, in the real
    // world you would probably want to be a bit smarter about this.
    //

    Iterator keyRingIter = pgpPub.getKeyRings();
    while (keyRingIter.hasNext())
    {
        PGPPublicKeyRing keyRing = (PGPPublicKeyRing)keyRingIter.next();

        Iterator keyIter = keyRing.getPublicKeys();
        while (keyIter.hasNext())
        {
            PGPPublicKey key = (PGPPublicKey)keyIter.next();

            if (key.isEncryptionKey())
            {
                return key;
            }
        }
    }

    throw new IllegalArgumentException("Can't find encryption key in key ring.");
}
 

import org.spongycastle.openpgp.PGPPublicKeyRing; //导入方法依赖的package包/类
@Override
public PGPPublicKey getPublicKey(File file) throws Exception {
    InputStream input=new FileInputStream(file);
    JcaPGPPublicKeyRingCollection pgpPub = new JcaPGPPublicKeyRingCollection(PGPUtil.getDecoderStream(input));
    PGPPublicKey pubKey = null;

    @SuppressWarnings("unchecked")
    Iterator<PGPPublicKeyRing> keyRingIterator = pgpPub.getKeyRings();
    while (keyRingIterator.hasNext() && pubKey == null) {
        PGPPublicKeyRing keyRing = keyRingIterator.next();

        @SuppressWarnings("unchecked")
        Iterator<PGPPublicKey> keyIterator = keyRing.getPublicKeys();
        while (keyIterator.hasNext()) {
            PGPPublicKey key = keyIterator.next();

            if (key.isEncryptionKey()) {
                pubKey = key;
                break;
            }
        }
    }

    if(pubKey != null) {
        return pubKey;
    }
    else {
        throw new IllegalArgumentException("Can't find encryption key in key ring.");
    }
}
 

import org.spongycastle.openpgp.PGPPublicKeyRing; //导入方法依赖的package包/类
private static PGPPublicKey getPublicKey(PGPPublicKeyRing publicKeyRing) {
    Iterator<?> kIt = publicKeyRing.getPublicKeys();
    while (kIt.hasNext()) {
        PGPPublicKey k = (PGPPublicKey) kIt.next();
        if (k.isEncryptionKey()) {
            return k;
        }
    }
    return null;
}
 

import org.spongycastle.openpgp.PGPPublicKeyRing; //导入方法依赖的package包/类
/** Returns the first master key found in the given public keyring. */
public static PGPPublicKey getMasterKey(PGPPublicKeyRing publicKeyring) {
    @SuppressWarnings("unchecked")
    Iterator<PGPPublicKey> iter = publicKeyring.getPublicKeys();
    while (iter.hasNext()) {
        PGPPublicKey pk = iter.next();
        if (pk.isMasterKey())
            return pk;
    }

    return null;
}
 

import org.spongycastle.openpgp.PGPPublicKeyRing; //导入方法依赖的package包/类
public static PGPPublicKey getSigningKey(PGPPublicKeyRing publicKeyring) {
    @SuppressWarnings("unchecked")
    Iterator<PGPPublicKey> iter = publicKeyring.getPublicKeys();
    while (iter.hasNext()) {
        PGPPublicKey pk = iter.next();
        if (!pk.isMasterKey()) {
            int keyFlags = getKeyFlags(pk);
            if ((keyFlags & PGPKeyFlags.CAN_SIGN) == PGPKeyFlags.CAN_SIGN)
                return pk;
        }
    }

    // legacy key format support
    return getLegacySigningKey(publicKeyring);
}
 

import org.spongycastle.openpgp.PGPPublicKeyRing; //导入方法依赖的package包/类
private static PGPPublicKey getLegacyEncryptionKey(PGPPublicKeyRing publicKeyring) {
    @SuppressWarnings("unchecked")
    Iterator<PGPPublicKey> iter = publicKeyring.getPublicKeys();
    while (iter.hasNext()) {
        PGPPublicKey pk = iter.next();
        if (!pk.isMasterKey() && pk.isEncryptionKey())
            return pk;
    }

    return null;
}
 

import org.spongycastle.openpgp.PGPPublicKeyRing; //导入方法依赖的package包/类
private static PGPPublicKey getLegacySigningKey(PGPPublicKeyRing publicKeyring) {
    @SuppressWarnings("unchecked")
    Iterator<PGPPublicKey> iter = publicKeyring.getPublicKeys();
    while (iter.hasNext()) {
        PGPPublicKey pk = iter.next();
        if (pk.isMasterKey())
            return pk;
    }

    return null;
}
 

import org.spongycastle.openpgp.PGPPublicKeyRing; //导入方法依赖的package包/类
public static PGPPublicKey getEncryptionKey(PGPPublicKeyRing publicKeyring) {
    @SuppressWarnings("unchecked")
    Iterator<PGPPublicKey> iter = publicKeyring.getPublicKeys();
    while (iter.hasNext()) {
        PGPPublicKey pk = iter.next();
        if (pk.isEncryptionKey())
            return pk;
    }

    return null;
}
 

import org.spongycastle.openpgp.PGPPublicKeyRing; //导入方法依赖的package包/类
/**
    * A simple routine that opens a key ring file and loads the first available key
    * suitable for encryption.
    * 
    * @param input
    * @return
    * @throws IOException
    * @throws PGPException
    */
   @SuppressWarnings("rawtypes")
static PGPPublicKey readPublicKey(InputStream input) throws IOException, PGPException
   {
       PGPPublicKeyRingCollection pgpPub = new PGPPublicKeyRingCollection(
           PGPUtil.getDecoderStream(input));

       //
       // we just loop through the collection till we find a key suitable for encryption, in the real
       // world you would probably want to be a bit smarter about this.
       //

       Iterator keyRingIter = pgpPub.getKeyRings();
       while (keyRingIter.hasNext())
       {
           PGPPublicKeyRing keyRing = (PGPPublicKeyRing)keyRingIter.next();

           Iterator keyIter = keyRing.getPublicKeys();
           while (keyIter.hasNext())
           {
               PGPPublicKey key = (PGPPublicKey)keyIter.next();

               if (key.isEncryptionKey())
               {
                   return key;
               }
           }
       }

       throw new IllegalArgumentException("Can't find encryption key in key ring.");
   }
 

import org.spongycastle.openpgp.PGPPublicKeyRing; //导入方法依赖的package包/类
static X509Certificate createCertificate(PGPPublicKeyRing publicKeyRing, PGPPrivateKey privateKey)
    throws InvalidKeyException, IllegalStateException, NoSuchAlgorithmException,
    SignatureException, CertificateException, NoSuchProviderException, PGPException, IOException, OperatorCreationException {

    X500NameBuilder x500NameBuilder = new X500NameBuilder();

    /*
     * The X.509 Name to be the subject DN is prepared.
     * The CN is extracted from the Secret Key user ID.
     */

    x500NameBuilder.addRDN(BCStyle.O, DN_COMMON_PART_O);

    PGPPublicKey publicKey = null;

    @SuppressWarnings("unchecked")
    Iterator<PGPPublicKey> iter = publicKeyRing.getPublicKeys();
    while (iter.hasNext()) {
        PGPPublicKey pk = iter.next();
        if (pk.isMasterKey()) {
            publicKey = pk;
            break;
        }
    }

    if (publicKey == null)
        throw new IllegalArgumentException("no master key found");

    List<String> xmppAddrs = new LinkedList<>();
    for (@SuppressWarnings("unchecked") Iterator<String> it = publicKey.getUserIDs(); it.hasNext();) {
        String attrib = it.next();
        x500NameBuilder.addRDN(BCStyle.CN, attrib);
        // extract email for the subjectAltName
        PGPUserID uid = PGPUserID.parse(attrib);
        if (uid != null && uid.getEmail() != null)
            xmppAddrs.add(uid.getEmail());
    }

    X500Name x509name = x500NameBuilder.build();

    /*
     * To check the signature from the certificate on the recipient side,
     * the creation time needs to be embedded in the certificate.
     * It seems natural to make this creation time be the "not-before"
     * date of the X.509 certificate.
     * Unlimited PGP keys have a validity of 0 second. In this case,
     * the "not-after" date will be the same as the not-before date.
     * This is something that needs to be checked by the service
     * receiving this certificate.
     */
    Date creationTime = publicKey.getCreationTime();
    Date validTo = null;
    if (publicKey.getValidSeconds()>0)
       validTo = new Date(creationTime.getTime() + 1000L * publicKey.getValidSeconds());

    return createCertificate(
            PGP.convertPublicKey(publicKey),
            PGP.convertPrivateKey(privateKey),
            x509name,
            creationTime, validTo,
            xmppAddrs,
            publicKeyRing.getEncoded());
}