super(message, cause);
        }
        public EncryptionException(Throwable cause) {
            super(null, cause);
        }
    }

    EncryptionAlgorithm NONE = new EncryptionAlgorithm() {
        @Override
        public String getTransformation() {
            return "none";
        }

        @Override
        public String getAlgorithm() {
            return "none";

            }

            @Override
            public EncryptionAlgorithm getAlgorithm() {
                return SupportedEncryptionAlgorithm.this;
            }

            @Override
            public SecretKey getKey() {
                return key;
            }
        };
    }

    @Nonnull
    public static EncryptionAlgorithm byTransformation(String transformation) {

	}{
		{
			name: "feature gate is set to true, return ECDSA-P256",
			cfg: &ClusterConfiguration{
				FeatureGates: map[string]bool{
					features.PublicKeysECDSA: true,
				},
				EncryptionAlgorithm: EncryptionAlgorithmRSA4096,
			},
			expectedResult: EncryptionAlgorithmECDSAP256,
		},
		{
			name: "feature gate is set to false, return the default RSA-2048",
			cfg: &ClusterConfiguration{

                    get() = Hashing.newHasher().hash()
                override val isEncrypting: Boolean
                    get() = false
                override val encryptionAlgorithm: EncryptionAlgorithm
                    get() = EncryptionAlgorithm.NONE
            }
        ).string
    }

    private
    fun file(path: String) =
        testDirectoryProvider.file(path)

	// If we call Convert_v1beta3_ClusterConfiguration_To_kubeadm_ClusterConfiguration() these fields will receive
	// a default value, thus here we need to reset them back to empty.
	out.EncryptionAlgorithm = ""
	out.CertificateValidityPeriod = nil
	out.CACertificateValidityPeriod = nil
	// Set default timeouts.
	kubeadm.SetDefaultTimeouts(&out.Timeouts)
	return err
}

			},
			cfg: &kubeadmapi.InitConfiguration{
				ClusterConfiguration: kubeadmapi.ClusterConfiguration{
					EncryptionAlgorithm: kubeadmapi.EncryptionAlgorithmECDSAP256,
				},
			},
			expectedConfig: &pkiutil.CertConfig{
				Config: certutil.Config{
					NotBefore: now.Add(-backdate),
				},
				EncryptionAlgorithm: kubeadmapi.EncryptionAlgorithmECDSAP256,
			},
		},
		{
			name: "cert validity is set",

	}

	if obj.ImageRepository == "" {
		obj.ImageRepository = DefaultImageRepository
	}

	if obj.ClusterName == "" {
		obj.ClusterName = DefaultClusterName
	}

	if obj.EncryptionAlgorithm == "" {
		obj.EncryptionAlgorithm = DefaultEncryptionAlgorithm
	}

	if obj.CertificateValidityPeriod == nil {
		obj.CertificateValidityPeriod = &metav1.Duration{
			Duration: constants.CertificateValidityPeriod,
		}
	}

		Duration: 0,
	}
	obj.ControllerManager.ExtraEnvs = []kubeadm.EnvVar{}
	obj.APIServer.ExtraEnvs = []kubeadm.EnvVar{}
	obj.Scheduler.ExtraEnvs = []kubeadm.EnvVar{}
	obj.Etcd.Local.ExtraEnvs = []kubeadm.EnvVar{}
	obj.EncryptionAlgorithm = kubeadm.EncryptionAlgorithmRSA2048
	obj.Proxy.Disabled = false
	obj.CertificateValidityPeriod = &metav1.Duration{Duration: constants.CertificateValidityPeriod}

		DeprecationMessage: "The PublicKeysECDSA feature gate is deprecated and will be removed when v1beta3 is removed." +
			" v1beta4 supports a new option 'ClusterConfiguration.EncryptionAlgorithm'.",
	},
	RootlessControlPlane: {FeatureSpec: featuregate.FeatureSpec{Default: false, PreRelease: featuregate.Alpha},

    val keystoreDir: String? = options.getInternalString("org.gradle.configuration-cache.internal.key-store-dir", null)

    val encryptionAlgorithm: String = options.getInternalString("org.gradle.configuration-cache.internal.encryption-alg", SupportedEncryptionAlgorithm.AES_ECB_PADDING.transformation)

    /**