.getTrustedKeys()
            .stream()
            .map(DependencyVerificationConfiguration.TrustedKey::getKeyId)
            .forEach(keysToExport::add);
        verifier.getConfiguration()
            .getIgnoredKeys()
            .stream()
            .map(IgnoredKey::getKeyId)
            .forEach(keysToExport::add);
        verifier.getVerificationMetadata()
            .stream()

     */
    byte[] sign(InputStream toSign);

    /**
     * Returns the id of the key that will be used for signing.
     *
     * @return The key id
     */
    @Input
    @Optional
    String getKeyId();

                for (PGPSecretKeyRing keyring : new JcaPGPSecretKeyRingCollection(in)) {
                    for (PGPSecretKey key : keyring) {
                        if (expectedKeyId.equals(new PgpKeyId(key.getKeyID()))) {
                            return factory.createSignatory(name, key, password);
                        }
                    }
                }
            }
            return null;

            }
        }
        args.add("--no-tty");
        args.add("--batch");
        args.add("--detach-sign");
        return args;
    }

    @Override
    public String getKeyId() {
        return keyName;
    }

     */
    private void findMatchingKey(long id, PGPPublicKeyRing keyRing, PublicKeyResultBuilder builder) {
        for (PGPPublicKey publicKey : keyRing) {
            if (publicKey.getKeyID() == id) {
                builder.publicKey(publicKey);
                return;
            }
        }
    }

    /**
     * A response was sent from the server. This is a keyring, we need to find

                }
            }
        }
        return null;
    }

    private boolean hasId(PgpKeyId keyId, PGPSecretKey secretKey) {
        return new PgpKeyId(secretKey.getKeyID()).equals(keyId);
    }

    protected PgpKeyId normalizeKeyId(String keyId) {
        try {
            return new PgpKeyId(keyId);
        } catch (IllegalArgumentException e) {

                Collection<PgpEntry> pgpKeys = e.getValue().stream()
                    .filter(entry -> verificationsBuilder.getTrustedKeys().stream()
                        .filter(trustedKey -> trustedKey.getKeyId().equals(e.getKey()))
                        .noneMatch(entry::checkAndMarkSatisfiedBy))
                    .collect(Collectors.toList());
                if (pgpKeys.size() > 1) {

var xxx_messageInfo_EncryptedObject proto.InternalMessageInfo

func (m *EncryptedObject) GetEncryptedData() []byte {
	if m != nil {
		return m.EncryptedData
	}
	return nil
}

func (m *EncryptedObject) GetKeyID() string {
	if m != nil {
		return m.KeyID
	}
	return ""
}

func (m *EncryptedObject) GetEncryptedDEKSource() []byte {
	if m != nil {
		return m.EncryptedDEKSource
	}
	return nil
}