Java PGPSignatureSubpacketVector.getKeyFlags方法代码示例

import org.bouncycastle.openpgp.PGPSignatureSubpacketVector; //导入方法依赖的package包/类
/**
 * Usage flags as Bouncy castle {@link PGPKeyFlags} bits.
 */
public int getUsageFlags() throws PGPException {
    if (publicKey == null) return 0;

    int flags = 0;
    // actually only need POSITIVE_CERTIFICATION (for master key)
    // and SUBKEY_BINDING (for subkeys)
    Iterator<PGPSignature> signatures = publicKey.getSignatures();
    while (signatures.hasNext()) {
        PGPSignature signature = signatures.next();
        PGPSignatureSubpacketVector hashedSubPackets =
            signature.getHashedSubPackets();

        if (hashedSubPackets != null)
            flags |= hashedSubPackets.getKeyFlags();
    }
    return flags;
}
 

import org.bouncycastle.openpgp.PGPSignatureSubpacketVector; //导入方法依赖的package包/类
/**
 * Checks whether one of the signatures of the key has one of the expected
 * key flags
 * 
 * @param key
 * @return {@link Boolean#TRUE} if key has one of the expected flag,
 *         <code>null</code> if the key does not have any key flags,
 *         {@link Boolean#FALSE} if the key has none of the expected flags
 */
private static Boolean hasOneOfExpectedKeyFlags(PGPPublicKey key, int[] expectedKeyFlags) {
    boolean containsKeyFlags = false;
    for (@SuppressWarnings("unchecked")
    Iterator<PGPSignature> itsig = key.getSignatures(); itsig.hasNext();) {
        PGPSignature sig = itsig.next();
        PGPSignatureSubpacketVector subPacks = sig.getHashedSubPackets();
        if (subPacks != null) {
            int keyFlag = subPacks.getKeyFlags();
            if (keyFlag > 0 && !containsKeyFlags) {
                containsKeyFlags = true;
            }
            for (int expectdKeyFlag : expectedKeyFlags) {
                int result = keyFlag & expectdKeyFlag;
                if (result == expectdKeyFlag) {
                    return Boolean.TRUE;
                }
            }
        }
    }
    if (containsKeyFlags) {
        return Boolean.FALSE;
    }
    return null; // no key flag
}
 

import org.bouncycastle.openpgp.PGPSignatureSubpacketVector; //导入方法依赖的package包/类
private Set<PgpKeyFlag> getPgpKeyFlags() {
	final EnumSet<PgpKeyFlag> result = EnumSet.noneOf(PgpKeyFlag.class);

	final PgpKeyId masterKeyId = masterKey == null ? getPgpKeyId() : masterKey.getPgpKeyId();

	final Iterator<?> sigIt = publicKey.getSignatures();
	while (sigIt.hasNext()) {
		final PGPSignature signature = (PGPSignature) sigIt.next();
		if (signature.getKeyID() != masterKeyId.longValue())
			continue;

		// It seems, the signature type is not always the way it should be (to my understanding).
		// To look for PGPSignature.SUBKEY_BINDING works fine, but PGPSignature.PRIMARYKEY_BINDING seems to
		// never be used. I thus do not filter by signature-type at all, anymore, but collect all keyFlags
		// from all signatures made by the master-key.

		final PGPSignatureSubpacketVector hashedSubPackets = signature.getHashedSubPackets();
		if (hashedSubPackets != null) {
			final int keyFlags = hashedSubPackets.getKeyFlags();
			result.addAll(getPgpKeyFlags(keyFlags));
		}
	}
	return result;
}
 

import org.bouncycastle.openpgp.PGPSignatureSubpacketVector; //导入方法依赖的package包/类
/**
 * Check if the PGPSignature contains sub keys that suit our usage. We need 
 * sub keys that are suitable for encrypting storage. 
 * @param sig - PGPSignature
 * @param keyUsage - Usage type - Encrypt storage or communication
 * @return true if a sub key for encrypting storage is found else false 
 */
private boolean isMatchingUsage(PGPSignature sig, int keyUsage) {
    if (sig.hasSubpackets()) {
        PGPSignatureSubpacketVector sv = sig.getHashedSubPackets();
        if (sv.hasSubpacket(CryptDecryptUtil.KEY_FLAGS)) {
        	if ((sv.getKeyFlags() == 0 && keyUsage == 0)) {
        		return false;
        	}
        }
    }
    return true;
}
 

import org.bouncycastle.openpgp.PGPSignatureSubpacketVector; //导入方法依赖的package包/类
private static int getKeyFlags(PGPPublicKey key) {
    @SuppressWarnings("unchecked")
    Iterator<PGPSignature> sigs = key.getSignatures();
    while (sigs.hasNext()) {
        PGPSignature sig = sigs.next();
        PGPSignatureSubpacketVector subpackets = sig.getHashedSubPackets();
        if (subpackets != null)
            return subpackets.getKeyFlags();
    }
    return 0;
}
 

import org.bouncycastle.openpgp.PGPSignatureSubpacketVector; //导入方法依赖的package包/类
static boolean hasFlag(final PGPSignature signature, final int flag) {
    if (signature.hasSubpackets()) {
        PGPSignatureSubpacketVector subpacketVector = signature.getHashedSubPackets();
        if (subpacketVector.hasSubpacket(SignatureSubpacketTags.KEY_FLAGS)) {
            if ((subpacketVector.getKeyFlags() & flag) > 0) {
                return true;
            }
        }
    }
    return false;
}