if (object instanceof PGPPublicKey) {
            return (PGPPublicKey) object;
        } else if (object instanceof PGPPublicKeyRing) {
            return ((PGPPublicKeyRing) object).getPublicKey();
        }
        throw new IllegalStateException("Unexpected key in cache: " + object.getClass());
    }

    @Override
    public void write(Encoder encoder, PGPPublicKey key) throws Exception {

                secretKey = it.secretKey
            }
        }
        return secretKey
    }

    static PGPPublicKey readPublicKey(File keyringsDir) {
        def keyring = new File(keyringsDir, "pubring.gpg")
        PGPPublicKey publicKey = null
        keyring.withInputStream {
            new PGPPublicKeyRingCollection(it, new BcKeyFingerprintCalculator()).each {

        List<PGPPublicKey> strippedKeys = StreamSupport
            .stream(keyring.spliterator(), false)
            .map(key -> stripKey(key, fingerprintCalculator))
            .collect(Collectors.toList());

        return new PGPPublicKeyRing(strippedKeys);
    }

    @SuppressWarnings("unchecked")
    private static PGPPublicKey stripKey(PGPPublicKey key, KeyFingerPrintCalculator fingerprintCalculator) {

        private final List<PGPPublicKey> trustedKeys;
        private final List<PGPPublicKey> validKeys;
        private final List<PGPPublicKey> failedKeys;
        private final List<String> ignoredKeys;
        private final boolean hasNoSignatures;

                            if (!verified) {
                                result.failed(pgpPublicKey);
                            } else {
                                boolean trusted = trustedKeys.contains(fingerprint) || trustedKeys.contains(toLongIdHexString(pgpPublicKey.getKeyID()));
                                result.verified(pgpPublicKey, trusted);
                            }

            }

            @Override
            public void publicKey(PGPPublicKey publicKey) {

            }
        });
    }

    private void collectUserIds(Set<String> userIds, PGPPublicKey userkey) {
        userIds.addAll(PGPUtils.getUserIDs(userkey));
    }

    public static class SignatureError {
        private final PGPPublicKey publicKey;
        private final FailureKind kind;

                    for (PGPPublicKeyRing keyring : keyrings) {
                        Iterator<PGPPublicKey> it = keyring.getPublicKeys();
                        while (it.hasNext()) {
                            PGPPublicKey key = it.next();
                            Fingerprint fingerprint = Fingerprint.of(key);
                            keyToKeyringBuilder.put(fingerprint, keyring);

 */
package org.gradle.api.internal.artifacts.verification.signatures;

import org.bouncycastle.openpgp.PGPPublicKey;

public interface SignatureVerificationResultBuilder {
    void missingKey(String keyId);
    void verified(PGPPublicKey key, boolean trusted);
    void failed(PGPPublicKey pgpPublicKey);
    void ignored(String keyId);

    void noSignatures();

 * limitations under the License.
 */
package org.gradle.security.internal;

import com.google.common.collect.ImmutableList;
import org.bouncycastle.openpgp.PGPPublicKey;
import org.bouncycastle.openpgp.PGPPublicKeyRing;
import org.gradle.api.logging.Logger;
import org.gradle.api.logging.Logging;

import java.util.List;

        private final File file;
        private final File signatureFile;
        private List<String> missingKeys = null;
        private List<PGPPublicKey> trustedKeys = null;
        private List<PGPPublicKey> validNotTrusted = null;
        private List<PGPPublicKey> failedKeys = null;
        private List<String> ignoredKeys = null;
        private boolean hasValidSignatures = true;