org.keycloak.keys.GeneratedRsaKeyProviderFactory クラス

org.keycloak.keys.GeneratedRsaKeyProviderFactory の継承関係図

org.keycloak.keys.GeneratedRsaKeyProviderFactory 連携図

公開メンバ関数
KeyProvider	create (KeycloakSession session, ComponentModel model)
boolean	createFallbackKeys (KeycloakSession session, KeyUse keyUse, String algorithm)
void	validateConfiguration (KeycloakSession session, RealmModel realm, ComponentModel model) throws ComponentValidationException
String	getHelpText ()
List< ProviderConfigProperty >	getConfigProperties ()
String	getId ()

静的公開メンバ関数
static final ProviderConfigurationBuilder	configurationBuilder ()

静的公開変数類
static final String	ID = "rsa-generated"

非公開メンバ関数
void	generateKeys (RealmModel realm, ComponentModel model, int size)
void	generateCertificate (RealmModel realm, ComponentModel model, KeyPair keyPair)

静的非公開変数類
static final Logger	logger = Logger.getLogger(GeneratedRsaKeyProviderFactory.class)
static final String	HELP_TEXT = "Generates RSA keys and creates a self-signed certificate"
static final List< ProviderConfigProperty >	CONFIG_PROPERTIES

詳解

著者

Stian Thorgersen

関数詳解

configurationBuilder()

static final ProviderConfigurationBuilder org.keycloak.keys.AbstractRsaKeyProviderFactory.configurationBuilder ( )

inlinestaticinherited

                                                                            {
        return ProviderConfigurationBuilder.create()
                .property(Attributes.PRIORITY_PROPERTY)
                .property(Attributes.ENABLED_PROPERTY)
                .property(Attributes.ACTIVE_PROPERTY)
                .property(Attributes.RS_ALGORITHM_PROPERTY);
    }

create()

KeyProvider org.keycloak.keys.GeneratedRsaKeyProviderFactory.create ( KeycloakSession  session, ComponentModel  model  )

inline

                                                                             {
        return new ImportedRsaKeyProvider(session.getContext().getRealm(), model);
    }

createFallbackKeys()

boolean org.keycloak.keys.GeneratedRsaKeyProviderFactory.createFallbackKeys ( KeycloakSession  session, KeyUse  keyUse, String  algorithm  )

inline

                                                                                                {
        if (keyUse.equals(KeyUse.SIG) && (algorithm.equals(Algorithm.RS256) || algorithm.equals(Algorithm.RS384) || algorithm.equals(Algorithm.RS512))) {
            RealmModel realm = session.getContext().getRealm();

            ComponentModel generated = new ComponentModel();
            generated.setName("fallback-" + algorithm);
            generated.setParentId(realm.getId());
            generated.setProviderId(ID);
            generated.setProviderType(KeyProvider.class.getName());

            MultivaluedHashMap<String, String> config = new MultivaluedHashMap<>();
            config.putSingle(Attributes.PRIORITY_KEY, "-100");
            config.putSingle(Attributes.ALGORITHM_KEY, algorithm);
            generated.setConfig(config);

            realm.addComponentModel(generated);

            return true;
        } else {
            return false;
        }
    }

generateCertificate()

void org.keycloak.keys.GeneratedRsaKeyProviderFactory.generateCertificate ( RealmModel  realm, ComponentModel  model, KeyPair  keyPair  )

inlineprivate

                                                                                              {
        try {
            Certificate certificate = CertificateUtils.generateV1SelfSignedCertificate(keyPair, realm.getName());
            model.put(Attributes.CERTIFICATE_KEY, PemUtils.encodeCertificate(certificate));
        } catch (Throwable t) {
            throw new ComponentValidationException("Failed to generate certificate", t);
        }
    }

generateKeys()

void org.keycloak.keys.GeneratedRsaKeyProviderFactory.generateKeys ( RealmModel  realm, ComponentModel  model, int  size  )

inlineprivate

                                                                                {
        KeyPair keyPair;
        try {
            keyPair = KeyUtils.generateRsaKeyPair(size);
            model.put(Attributes.PRIVATE_KEY_KEY, PemUtils.encodeKey(keyPair.getPrivate()));
        } catch (Throwable t) {
            throw new ComponentValidationException("Failed to generate keys", t);
        }

        generateCertificate(realm, model, keyPair);
    }

getConfigProperties()

List<ProviderConfigProperty> org.keycloak.keys.GeneratedRsaKeyProviderFactory.getConfigProperties ( )

inline

                                                              {
        return CONFIG_PROPERTIES;
    }

getHelpText()

String org.keycloak.keys.GeneratedRsaKeyProviderFactory.getHelpText ( )

inline

                                {
        return HELP_TEXT;
    }

getId()

String org.keycloak.keys.GeneratedRsaKeyProviderFactory.getId ( )

inline

                          {
        return ID;
    }

validateConfiguration()

void org.keycloak.keys.GeneratedRsaKeyProviderFactory.validateConfiguration ( KeycloakSession  session, RealmModel  realm, ComponentModel  model  ) throws ComponentValidationException

inline

                                                                                                                                           {
        super.validateConfiguration(session, realm, model);

        ConfigurationValidationHelper.check(model).checkList(Attributes.KEY_SIZE_PROPERTY, false);

        int size = model.get(Attributes.KEY_SIZE_KEY, 2048);

        if (!(model.contains(Attributes.PRIVATE_KEY_KEY) && model.contains(Attributes.CERTIFICATE_KEY))) {
            generateKeys(realm, model, size);

            logger.debugv("Generated keys for {0}", realm.getName());
        } else {
            PrivateKey privateKey = PemUtils.decodePrivateKey(model.get(Attributes.PRIVATE_KEY_KEY));
            int currentSize = ((RSAPrivateKey) privateKey).getModulus().bitLength();
            if (currentSize != size) {
                generateKeys(realm, model, size);

                logger.debugv("Key size changed, generating new keys for {0}", realm.getName());
            }
        }
    }

メンバ詳解

CONFIG_PROPERTIES

final List<ProviderConfigProperty> org.keycloak.keys.GeneratedRsaKeyProviderFactory.CONFIG_PROPERTIES

staticprivate

初期値:

= AbstractRsaKeyProviderFactory.configurationBuilder()
            .property(Attributes.KEY_SIZE_PROPERTY)
            .build()

HELP_TEXT

final String org.keycloak.keys.GeneratedRsaKeyProviderFactory.HELP_TEXT = "Generates RSA keys and creates a self-signed certificate"

staticprivate

ID

final String org.keycloak.keys.GeneratedRsaKeyProviderFactory.ID = "rsa-generated"

static

logger

final Logger org.keycloak.keys.GeneratedRsaKeyProviderFactory.logger = Logger.getLogger(GeneratedRsaKeyProviderFactory.class)

staticprivate

---

このクラス詳解は次のファイルから抽出されました:

• D:/AppData/doxygen/keycloak/rest-service/src/services/src/main/java/org/keycloak/keys/GeneratedRsaKeyProviderFactory.java