// MarshalText encodes the DEK's key ID and ciphertext
// as JSON.
func (d DEK) MarshalText() ([]byte, error) {
	type JSON struct {
		KeyID      string `json:"keyid"`
		Version    uint32 `json:"version,omitempty"`
		Ciphertext []byte `json:"ciphertext"`
	}
	return json.Marshal(JSON{
		KeyID:      d.KeyID,
		Version:    uint32(d.Version),
		Ciphertext: d.Ciphertext,
	})
}

        }
    }

    static class KeyInfo {
        String keyId
        String password
        String keyRingFilePath

        Map<String, String> asProperties(String name = null) {
            def prefix = name ? "signing.${name}." : "signing."
            def properties = [:]
            properties[prefix + "keyId"] = keyId
            properties[prefix + "password"] = password

		}
		return DEK{}, errKeyGenerationFailed(err)
	}
	return DEK{
		KeyID:      name,
		Plaintext:  dek.Plaintext,
		Ciphertext: dek.Ciphertext,
	}, nil
}

// ImportKey imports a cryptographic key into the KMS.
func (c *kesConn) ImportKey(ctx context.Context, keyID string, bytes []byte) error {
	return c.client.ImportKey(ctx, keyID, &kes.ImportKeyRequest{
		Key: bytes,
	})
}

		return
	}

	if GlobalKMS == nil {
		writeErrorResponseJSON(ctx, w, errorCodes.ToAPIErr(ErrKMSNotConfigured), r.URL)
		return
	}

	keyID := r.Form.Get("key-id")
	if keyID == "" {
		keyID = GlobalKMS.DefaultKey
	}
	response := madmin.KMSKeyStatus{
		KeyID: keyID,
	}

	kmsContext := kms.Context{"MinIO admin API": "KMSKeyStatusHandler"} // Context for a test key operation
	// 1. Generate a new key using the KMS.

		Version         = 1
	)
	var (
		header [5]byte
		buffer bytes.Buffer
	)
	json := jsoniter.ConfigCompatibleWithStandardLibrary
	metadata, err := json.Marshal(encryptedObject{
		KeyID:     key.KeyID,
		KMSKey:    key.Ciphertext,
		Algorithm: algorithm,
		Nonce:     nonce,
	})
	if err != nil {
		return nil, err
	}
	if len(metadata) > MaxMetadataSize {

	EncryptedData []byte `protobuf:"bytes,1,opt,name=encryptedData,proto3" json:"encryptedData,omitempty"`
	// KeyID is the KMS key ID used for encryption operations.
	// keyID must satisfy the following constraints:
	// 1. The keyID is not empty.
	// 2. The size of keyID is less than 1 kB.
	KeyID string `protobuf:"bytes,2,opt,name=keyID,proto3" json:"keyID,omitempty"`

        String keyId = null;
        String secretKey = null;
        String password = null;

        switch (args.length) {
            case 2:
                secretKey = args[0].toString();
                password = args[1].toString();
                break;
            case 3:
                keyId = args[0].toString();
                secretKey = args[1].toString();

signing.keyId=24875D73
signing.password=gradle

            entry("org", "foo", "1.0", "foo-1.0.pom").addVerifiedKey(KEY_1)
        }

        when:
        executeGrouping()

        then:
        verifier.configuration.trustedKeys*.keyId == [KEY_1]
        verifier.verificationMetadata.empty
    }

    def "groups entries which have the same module id"() {
        grouper {
            entry("org", "foo", "1.0", "foo-1.0.jar").addVerifiedKey(KEY_1)

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();