private final String asHex;

    public PgpKeyId(long keyId) {
        asLong = keyId;
        asHex = toHex(keyId);
    }

    public PgpKeyId(PGPPublicKey keyId) {
        this(keyId.getKeyID());
    }

    public PgpKeyId(PGPSignature signature) {
        this(signature.getKeyID());
    }

    public PgpKeyId(String keyId) {
        asLong = toLong(keyId);
        asHex = toHex(asLong);
    }

		if err := json.Unmarshal(b, &ctx); err != nil {
			return "", nil, err
		}
	}

	keyID := h.Get(xhttp.AmzServerSideEncryptionKmsID)
	spaces := strings.HasPrefix(keyID, " ") || strings.HasSuffix(keyID, " ")
	if spaces {
		return "", nil, ErrInvalidEncryptionKeyID
	}
	return strings.TrimPrefix(keyID, ARNPrefix), ctx, nil
}

// IsEncrypted returns true if the object metadata indicates

    protected void addSignatory(String name, String keyId, String secretKey, String password) {
        signatories.put(name, createSignatory(name, keyId, secretKey, password));
    }

    private PgpSignatory createSignatory(String name, String keyId, String secretKey, String password) {
        try (InputStream in = PGPUtil.getDecoderStream(new ByteArrayInputStream(secretKey.getBytes(UTF_8)))) {
            if (keyId == null) {

	ver                string
	socketPath         string
	keyID              string
}

// NewBase64Plugin is a constructor for Base64Plugin.
func NewBase64Plugin(t testing.TB, socketPath string) *Base64Plugin {
	server := grpc.NewServer()
	result := &Base64Plugin{
		grpcServer: server,
		mu:         &sync.Mutex{},
		ver:        kmsapiVersion,
		socketPath: socketPath,
		keyID:      "1",
	}

        given:
        project.ext.'signing.keyId' = keyId
        project.ext.'signing.password' = password
        project.ext.'signing.secretKeyRingFile' = secretKeyRingFile

        when:
        def signatory = factory.createSignatory(project, false)

        then:
        !signatory

        where:
        keyId        | password       | secretKeyRingFile

                if (request.queryString.startsWith("op=get&options=mr&search=0x")) {
                    String keyId = request.queryString - "op=get&options=mr&search=0x"
                    if (KeyServer.this.keyFiles.containsKey(keyId)) {
                        KeyServer.this.fileHandler("/pks/lookup", KeyServer.this.keyFiles[keyId]).handle(request, response)
                    } else {
                        response.sendError(404, "not found")

        }
    }

    def addSigningProperties(keyId, secretKeyRingFile, password) {
        addPrefixedSigningProperties(null, keyId, secretKeyRingFile, password)
    }

    def addPrefixedSigningProperties(prefix, keyId, secretKeyRingFile, password) {
        def truePrefix = prefix ? "${prefix}." : ""
        def properties = [:]
        def values = [keyId: keyId, secretKeyRingFile: secretKeyRingFile, password: password]

			}
		}
		if !bytes.Equal(dataKey, test.DataKey) {
			t.Errorf("Test %d: got data key '%v' - want data key '%v'", i, dataKey, test.DataKey)
		}
		if keyID != test.KeyID {
			t.Errorf("Test %d: got key-ID '%v' - want key-ID '%v'", i, keyID, test.KeyID)
		}
		if sealedKey.Algorithm != test.SealedKey.Algorithm {

    @Override
    public void missingKey(String keyId) {
        ignoredKeys.add(keyId);
        entry.missing();
    }

    @Override
    public void verified(PGPPublicKey key, boolean trusted) {
        String keyId = Fingerprint.of(key).toString();
        entry.addVerifiedKey(keyId);
    }

    @Override
    public void failed(PGPPublicKey key) {
        String keyId = Fingerprint.of(key).toString();

    }

    public Set<String> getFailed() {
        return failed;
    }

    public void keyDeclaredGlobally(String keyId) {
        keysDeclaredGlobally.add(keyId);
    }

    public boolean doesNotDeclareKeyGlobally(String keyId) {
        return !keysDeclaredGlobally.contains(keyId);
    }

    public boolean hasArtifactLevelKeys() {
        return !trustedKeys.equals(keysDeclaredGlobally);
    }