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]

    @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);
    }

				t.Errorf("Test case %d: Expected %s but got %s", i+1, tc.expectedErr, err)
			}
			continue
		}

		if tc.keyID != "" && tc.keyID != ssec.KeyID() {
			t.Errorf("Test case %d: Expected bucket encryption KeyID %s but got %s", i+1, tc.keyID, ssec.KeyID())
		}

		if expectedXML, err := xml.Marshal(tc.expectedConfig); err != nil || !bytes.Equal(expectedXML, []byte(tc.inputXML)) {

		}
	}
}

var decryptKeyTests = []struct {
	KeyID      string
	Plaintext  string
	Ciphertext string
	Context    Context
}{
	{
		KeyID:      "my-key",
		Plaintext:  "zmS7NrG765UZ0ZN85oPjybelxqVvpz01vxsSpOISy2M=",