org.gluu.oxtrust.action.ManageCertificateAction クラス

org.gluu.oxtrust.action.ManageCertificateAction の継承関係図

org.gluu.oxtrust.action.ManageCertificateAction 連携図

公開メンバ関数
String	init ()
void	getCert (String fileName)
void	getCert (TrustStoreCertificate trustStoreCertificate)
String	generateCSR (String fileName) throws IOException
boolean	compare (String fileName)
boolean	certPresent (String filename)
String	getIdpCertFN ()
String	getTomcatCertFN ()
String	getTempCertDir ()
HashMap< String, String >	getIssuer ()
HashMap< String, String >	getSubject ()
void	setUploadMarker (String uploadMarker)
void	setUploadMarker (TrustStoreCertificate trustStoreCertificate)
String	update ()
void	cancel ()
void	certUpload (FileUploadEvent event)
void	keyUpload (FileUploadEvent event)
void	addPublicCertificate ()
void	removePublicCertificate (TrustStoreCertificate removeTrustStoreCertificate)
boolean	isInitialized ()
boolean	isCertsManagePossible ()
TrustStoreConfiguration	getTrustStoreConfiguration ()
List< TrustStoreCertificate >	getTrustStoreCertificates ()

静的公開変数類
static final String	BEGIN_CERT_REQ = "-----BEGIN CERTIFICATE REQUEST-----"
static final String	END_CERT_REQ = "-----END CERTIFICATE REQUEST-----"

変数
String	tomcatCertFN
String	idpCertFN

非公開メンバ関数
void	loadCert (X509Certificate cert)
KeyPair	getKeyPair (String fileName)
boolean	prepareTempWorkspace ()
boolean	updateTrustCertificates ()
boolean	updateCertificates ()
void	tirggerTrustStoreUpdate ()
void	updateCert (UploadedFile item)
void	updateTrsutStoreCert (UploadedFile item)
void	updateKey (UploadedFile item)

非公開変数類
Logger	log
OrganizationService	organizationService
FacesMessages	facesMessages
SSLService	sslService
AppConfiguration	appConfiguration
ApplianceService	applianceService
Identity	identity
TrustStoreConfiguration	trustStoreConfiguration
List< TrustStoreCertificate >	trustStoreCertificates
String	orgInumFN
HashMap< String, String >	issuer
HashMap< String, String >	subject
String	uploadMarker
TrustStoreCertificate	trustStoreCertificateUploadMarker
boolean	certsMmanagePossible
boolean	initialized
boolean	wereAnyChanges

静的非公開変数類
static final long	serialVersionUID = 4012709440384265524L

詳解

Manages SSL certificates

著者

Oleksiy Tataryn

Yuriy Movchan Date: 03/03/2014

関数詳解

addPublicCertificate()

void org.gluu.oxtrust.action.ManageCertificateAction.addPublicCertificate ( )

inline

                                           {
                TrustStoreCertificate trustStoreCertificate = new TrustStoreCertificate();
                trustStoreCertificate.setAddedAt(new Date());
                trustStoreCertificate.setAddedBy(identity.getUser().getDn());

                this.trustStoreCertificates.add(trustStoreCertificate);
        }

cancel()

void org.gluu.oxtrust.action.ManageCertificateAction.cancel ( )

inline

                             {
        }

certPresent()

boolean org.gluu.oxtrust.action.ManageCertificateAction.certPresent ( String  filename )

inline

                                                    {
                KeyPair pair = getKeyPair(filename);
                X509Certificate cert = sslService.getPEMCertificate(getTempCertDir() + filename);

                boolean filesPresent = (pair != null) && (cert != null);

                return filesPresent;
        }

certUpload()

void org.gluu.oxtrust.action.ManageCertificateAction.certUpload ( FileUploadEvent  event )

inline

                                                      {
                if (this.trustStoreCertificateUploadMarker == null) {
                        updateCert(event.getUploadedFile());
                } else {
                        updateTrsutStoreCert(event.getUploadedFile());
                }
        }

compare()

boolean org.gluu.oxtrust.action.ManageCertificateAction.compare ( String  fileName )

inline

                                                {
                KeyPair pair = getKeyPair(fileName);
                X509Certificate cert = sslService.getPEMCertificate(getTempCertDir() + fileName);

                boolean noFilesPresent = (pair == null) && (cert == null);

                boolean filesPresent = (pair != null) && (cert != null);
                boolean filesValid = false;
                if (filesPresent) {
                        filesValid = (pair.getPublic() != null) && (pair.getPublic().equals(cert.getPublicKey()));
                }

                boolean compareResult = (noFilesPresent || (filesPresent && filesValid));
                log.debug(fileName + " compare result: " + compareResult);
                return compareResult;
        }

generateCSR()

String org.gluu.oxtrust.action.ManageCertificateAction.generateCSR ( String  fileName ) throws IOException

inline

                                                                      {
                if (Security.getProvider(BouncyCastleProvider.PROVIDER_NAME) == null) {
                        Security.addProvider(new BouncyCastleProvider());
                }

                KeyPair pair = getKeyPair(fileName);
                boolean result = false;
                if (pair != null) {
                        String url = appConfiguration.getIdpUrl().replaceFirst(".*//", "");
                        String csrPrincipal = String.format("CN=%s", url);
                        X500Principal principal = new X500Principal(csrPrincipal);

                        PKCS10CertificationRequest csr = null;
                        try {
                                csr = new PKCS10CertificationRequest("SHA1withRSA", principal, pair.getPublic(), null, pair.getPrivate());
                        } catch (GeneralSecurityException e) {
                                log.error(e.getMessage(), e);
                                return OxTrustConstants.RESULT_FAILURE;
                        }

                        // Form download responce
                        StringBuilder response = new StringBuilder();

                        response.append(BEGIN_CERT_REQ + "\n");
                        response.append(WordUtils.wrap(new String(Base64.encode(csr.getEncoded(ASN1Encoding.DER))), 64, "\n", true) + "\n");
                        response.append(END_CERT_REQ + "\n");

                        FacesContext facesContext = FacesContext.getCurrentInstance();
                        result = ResponseHelper.downloadFile("csr.pem", OxTrustConstants.CONTENT_TYPE_TEXT_PLAIN, response.toString().getBytes(),
                                        facesContext);
                }

                return result ? OxTrustConstants.RESULT_SUCCESS : OxTrustConstants.RESULT_FAILURE;
        }

getCert() [1/2]

void org.gluu.oxtrust.action.ManageCertificateAction.getCert ( String  fileName )

inline

Fills issuer and subject maps with data about currently selected certificate

                                             {
                X509Certificate cert = sslService.getPEMCertificate(getTempCertDir() + fileName);
                loadCert(cert);
        }

getCert() [2/2]

void org.gluu.oxtrust.action.ManageCertificateAction.getCert ( TrustStoreCertificate  trustStoreCertificate )

inline

Fills issuer and subject maps with data about currently selected certificate

                                                                         {
                this.issuer = new HashMap<String, String>();
                this.subject = new HashMap<String, String>();

                if (trustStoreCertificate != null) {
                        X509Certificate cert = sslService
                                        .getPEMCertificate(new ByteArrayInputStream(trustStoreCertificate.getCertificate().getBytes()));
                        loadCert(cert);
                }
        }

getIdpCertFN()

String org.gluu.oxtrust.action.ManageCertificateAction.getIdpCertFN ( )

inline

                                     {
                return idpCertFN;
        }

getIssuer()

HashMap<String, String> org.gluu.oxtrust.action.ManageCertificateAction.getIssuer ( )

inline

                                                   {
                return issuer;
        }

getKeyPair()

KeyPair org.gluu.oxtrust.action.ManageCertificateAction.getKeyPair ( String  fileName )

inlineprivate

                                                    {
                KeyPair pair = null;
                JCERSAPrivateCrtKey privateKey = null;
                PEMParser r = null;
                FileReader fileReader = null;

                File keyFile = new File(getTempCertDir() + fileName.replace("crt", "key"));
                if (keyFile.isFile()) {
                        try {
                                fileReader = new FileReader(keyFile);
                                r = new PEMParser(
                                                fileReader /*
                                                                         * , new PasswordFinder() { public char[]
                                                                         * getPassword() { // Since keys are stored
                                                                         * without a password this // function
                                                                         * should not be called. return null; } }
                                                                         */);

                                Object keys = r.readObject();
                                if (keys == null) {
                                        log.error(" Unable to read keys from: " + keyFile.getAbsolutePath());
                                        return null;
                                }

                                if (keys instanceof KeyPair) {
                                        pair = (KeyPair) keys;
                                        log.debug(keyFile.getAbsolutePath() + "contains KeyPair");
                                } else if (keys instanceof JCERSAPrivateCrtKey) {

                                        privateKey = (JCERSAPrivateCrtKey) keys;
                                        log.debug(keyFile.getAbsolutePath() + "contains JCERSAPrivateCrtKey");
                                        BigInteger exponent = privateKey.getPublicExponent();
                                        BigInteger modulus = privateKey.getModulus();

                                        RSAPublicKeySpec publicKeySpec = new java.security.spec.RSAPublicKeySpec(modulus, exponent);
                                        PublicKey publicKey = null;
                                        try {
                                                KeyFactory keyFactory = KeyFactory.getInstance("RSA");

                                                publicKey = keyFactory.generatePublic(publicKeySpec);
                                        } catch (Exception e) {
                                                e.printStackTrace();
                                        }

                                        pair = new KeyPair(publicKey, privateKey);
                                } else {
                                        log.error(keyFile.getAbsolutePath() + " Contains unsupported key type: " + keys.getClass().getName());
                                        return null;
                                }

                        } catch (IOException e) {
                                log.error(e.getMessage(), e);
                                return null;
                        } finally {
                                try {
                                        r.close();
                                        fileReader.close();
                                } catch (Exception e) {
                                        log.error(e.getMessage(), e);
                                        return null;
                                }
                        }
                } else {
                        log.error("Key file does not exist : " + keyFile.getAbsolutePath());
                }
                log.debug("KeyPair successfully extracted from: " + keyFile.getAbsolutePath());
                return pair;
        }

getSubject()

HashMap<String, String> org.gluu.oxtrust.action.ManageCertificateAction.getSubject ( )

inline

                                                    {
                return subject;
        }

getTempCertDir()

String org.gluu.oxtrust.action.ManageCertificateAction.getTempCertDir ( )

inline

                                       {
                return appConfiguration.getTempCertDir() + File.separator;
        }

getTomcatCertFN()

String org.gluu.oxtrust.action.ManageCertificateAction.getTomcatCertFN ( )

inline

                                        {
                return tomcatCertFN;
        }

getTrustStoreCertificates()

List<TrustStoreCertificate> org.gluu.oxtrust.action.ManageCertificateAction.getTrustStoreCertificates ( )

inline

                                                                       {
                return trustStoreCertificates;
        }

getTrustStoreConfiguration()

TrustStoreConfiguration org.gluu.oxtrust.action.ManageCertificateAction.getTrustStoreConfiguration ( )

inline

                                                                    {
                return trustStoreConfiguration;
        }

init()

String org.gluu.oxtrust.action.ManageCertificateAction.init ( )

inline

                             {
                if (this.initialized) {
                        return OxTrustConstants.RESULT_SUCCESS;
                }

                this.wereAnyChanges = false;

                this.certsMmanagePossible = prepareTempWorkspace();

                this.orgInumFN = StringHelper.removePunctuation(organizationService.getOrganizationInum());
                this.tomcatCertFN = orgInumFN + "-java.crt";
                this.idpCertFN = orgInumFN + "-shib.crt";

                try {
                        GluuAppliance appliance = applianceService.getAppliance();

                        if (appliance == null) {
                                return OxTrustConstants.RESULT_FAILURE;
                        }

                        trustStoreConfiguration = appliance.getTrustStoreConfiguration();
                        if (trustStoreConfiguration == null) {
                                trustStoreConfiguration = new TrustStoreConfiguration();
                        }

                        trustStoreCertificates = appliance.getTrustStoreCertificates();
                        if (trustStoreCertificates == null) {
                                trustStoreCertificates = new ArrayList<TrustStoreCertificate>();
                        }
                } catch (Exception ex) {
                        log.error("Failed to load appliance configuration", ex);

                        return OxTrustConstants.RESULT_FAILURE;
                }

                this.initialized = true;

                return OxTrustConstants.RESULT_SUCCESS;
        }

isCertsManagePossible()

boolean org.gluu.oxtrust.action.ManageCertificateAction.isCertsManagePossible ( )

inline

                                               {
                return certsMmanagePossible;
        }

isInitialized()

boolean org.gluu.oxtrust.action.ManageCertificateAction.isInitialized ( )

inline

                                       {
                return initialized;
        }

keyUpload()

void org.gluu.oxtrust.action.ManageCertificateAction.keyUpload ( FileUploadEvent  event )

inline

                                                     {
                updateKey(event.getUploadedFile());
        }

loadCert()

void org.gluu.oxtrust.action.ManageCertificateAction.loadCert ( X509Certificate  cert )

inlineprivate

                                                    {
                if (cert != null) {
                        String issuerDN = cert.getIssuerX500Principal().getName();
                        String[] values = issuerDN.split("(?<!\\\\),");
                        for (String value : values) {
                                String[] keyValue = value.split("=");
                                issuer.put(keyValue[0], keyValue[1]);
                        }
                        String subjectDN = cert.getSubjectX500Principal().getName();
                        values = subjectDN.split("(?<!\\\\),");
                        for (String value : values) {
                                String[] keyValue = value.split("=");
                                subject.put(keyValue[0], keyValue[1]);
                        }
                        subject.put("validUntil", StringHelper.toString(cert.getNotAfter()));
                        subject.put("validAfter", StringHelper.toString(cert.getNotBefore()));
                }
        }

prepareTempWorkspace()

boolean org.gluu.oxtrust.action.ManageCertificateAction.prepareTempWorkspace ( )

inlineprivate

                                               {
                String tempDirFN = appConfiguration.getTempCertDir();
                String dirFN = appConfiguration.getCertDir();
                File certDir = new File(dirFN);
                if (tempDirFN == null || dirFN == null || !certDir.isDirectory() || StringHelper.isEmpty(tempDirFN)) {

                        return false;
                } else {
                        File tempDir = new File(tempDirFN);
                        // If tempDir exists - empty it, if not - create. If exists, but
                        // isFile - write an error and return false.
                        if (tempDir.isDirectory()) {
                                File[] files = tempDir.listFiles();
                                for (File file : files) {
                                        if (file.isFile()) {
                                                file.delete();
                                        }
                                }
                        } else {
                                if (tempDir.exists()) {
                                        log.error("Temporary certifcates path exists but is not a directory");
                                        return false;
                                } else {
                                        tempDir.mkdirs();
                                }
                        }

                        File[] files = certDir.listFiles();
                        for (File file : files) {
                                if (file.isFile()) {
                                        try {
                                                FileHelper.copy(file, new File(tempDirFN + File.separator + file.getName()));
                                        } catch (IOException e) {
                                                log.error("Unable to populate temp certs directory: ", e);
                                                return false;
                                        }
                                }
                        }
                }

                return true;
        }

removePublicCertificate()

void org.gluu.oxtrust.action.ManageCertificateAction.removePublicCertificate ( TrustStoreCertificate  removeTrustStoreCertificate )

inline

                                                                                               {
                for (Iterator<TrustStoreCertificate> iterator = this.trustStoreCertificates.iterator(); iterator.hasNext();) {
                        TrustStoreCertificate trustStoreCertificate = iterator.next();
                        if (System.identityHashCode(removeTrustStoreCertificate) == System.identityHashCode(trustStoreCertificate)) {
                                iterator.remove();
                                return;
                        }
                }
        }

setUploadMarker() [1/2]

void org.gluu.oxtrust.action.ManageCertificateAction.setUploadMarker ( String  uploadMarker )

inline

                                                         {
                this.uploadMarker = uploadMarker;
                this.trustStoreCertificateUploadMarker = null;
        }

setUploadMarker() [2/2]

void org.gluu.oxtrust.action.ManageCertificateAction.setUploadMarker ( TrustStoreCertificate  trustStoreCertificate )

inline

                                                                                 {
                this.uploadMarker = null;
                this.trustStoreCertificateUploadMarker = trustStoreCertificate;
        }

tirggerTrustStoreUpdate()

void org.gluu.oxtrust.action.ManageCertificateAction.tirggerTrustStoreUpdate ( )

inlineprivate

                                               {
                String certDirFileName = appConfiguration.getCertDir();
                File certDir = new File(certDirFileName);

                if (this.wereAnyChanges) {
                        File pkcs12 = new File(certDir, orgInumFN + "-java.pkcs12");
                        File pem = new File(certDir, orgInumFN + "-java.pem");
                        File jks = new File(certDir, orgInumFN + "-java.jks");

                        log.info("Deleting %s : %s", orgInumFN + "-java.pkcs12", pkcs12.delete());
                        log.info("Deleting %s : %s", orgInumFN + "-java.pem", pem.delete());
                        log.info("Deleting %s : %s", orgInumFN + "-java.jks", jks.delete());

                        applianceService.restartServices();

                        facesMessages.add(FacesMessage.SEVERITY_WARN,
                                        "Certificates were updated and appliance service will be restarted. Please log in again in 5 minutes.");

                        this.wereAnyChanges = false;
                }
        }

update()

String org.gluu.oxtrust.action.ManageCertificateAction.update ( )

inline

                               {
                if (!isCertsManagePossible()) {
                        return OxTrustConstants.RESULT_FAILURE;
                }

                boolean isUpdateTrustCertificates = updateTrustCertificates();
                boolean isUpdatedCertificates = updateCertificates();
                boolean result = isUpdateTrustCertificates && isUpdatedCertificates;

                if (result) {
                        tirggerTrustStoreUpdate();
                }

                return result ? OxTrustConstants.RESULT_SUCCESS : OxTrustConstants.RESULT_FAILURE;
        }

updateCert()

void org.gluu.oxtrust.action.ManageCertificateAction.updateCert ( UploadedFile  item )

inlineprivate

                                                   {
                InputStream is = null;
                OutputStream os = null;
                try {
                        is = item.getInputStream();
                        os = new FileOutputStream(getTempCertDir() + this.uploadMarker);
                        BufferedOutputStream bos = new BufferedOutputStream(os);

                        IOUtils.copy(is, bos);
                        bos.flush();
                } catch (IOException ex) {
                        log.error("Failed to upload certicicate", ex);
                } finally {
                        IOUtils.closeQuietly(is);
                        IOUtils.closeQuietly(os);
                }
        }

updateCertificates()

boolean org.gluu.oxtrust.action.ManageCertificateAction.updateCertificates ( )

inlineprivate

Updates certificates from temporary working directory to production and restarts services.

戻り値

true if update was successful. false if update was aborted due to some error (perhaps permissions issue.)

                                             {
                if (!compare(tomcatCertFN) || !compare(idpCertFN)) {
                        facesMessages.add(FacesMessage.SEVERITY_ERROR, "Certificates and private keys should match. Certificate update aborted.");
                        return false;
                }

                String tempDirFN = appConfiguration.getTempCertDir();
                String dirFN = appConfiguration.getCertDir();
                File certDir = new File(dirFN);
                File tempDir = new File(tempDirFN);
                if (tempDirFN == null || dirFN == null || !certDir.isDirectory() || !tempDir.isDirectory()) {
                        facesMessages.add(FacesMessage.SEVERITY_ERROR, "Certificate update aborted due to filesystem error");
                        return false;
                } else {
                        File[] files = tempDir.listFiles();
                        for (File file : files) {
                                try {
                                        if (file.isFile() && !FileUtils.contentEquals(file, new File(dirFN + File.separator + file.getName()))) {
                                                FileHelper.copy(file, new File(dirFN + File.separator + file.getName()));
                                                this.wereAnyChanges = true;
                                        }
                                } catch (IOException e) {
                                        facesMessages.add(FacesMessage.SEVERITY_FATAL,
                                                        "Certificate update failed. Certificates may have been corrupted. Please contact a Gluu administrator for help.");
                                        log.error("Error occured on certificates update:", e);
                                }
                        }
                }

                return true;
        }

updateKey()

void org.gluu.oxtrust.action.ManageCertificateAction.updateKey ( UploadedFile  item )

inlineprivate

                                                  {
                InputStream is = null;
                OutputStream os = null;
                try {
                        is = item.getInputStream();
                        os = new FileOutputStream(getTempCertDir() + this.uploadMarker.replace("crt", "key"));
                        BufferedOutputStream bos = new BufferedOutputStream(os);

                        IOUtils.copy(is, bos);
                        bos.flush();
                } catch (IOException ex) {
                        log.error("Failed to upload key", ex);
                } finally {
                        IOUtils.closeQuietly(is);
                        IOUtils.closeQuietly(os);
                }
        }

updateTrsutStoreCert()

void org.gluu.oxtrust.action.ManageCertificateAction.updateTrsutStoreCert ( UploadedFile  item )

inlineprivate

                                                             {
                InputStream is = null;
                try {
                        is = item.getInputStream();
                        String certificate = IOUtils.toString(is);
                        this.trustStoreCertificateUploadMarker.setCertificate(certificate);

                        this.trustStoreCertificateUploadMarker.setAddedAt(new Date());
                        this.trustStoreCertificateUploadMarker.setAddedBy(identity.getUser().getDn());

                } catch (IOException ex) {
                        log.error("Failed to upload key", ex);
                } finally {
                        IOUtils.closeQuietly(is);
                }
        }

updateTrustCertificates()

boolean org.gluu.oxtrust.action.ManageCertificateAction.updateTrustCertificates ( )

inlineprivate

                                                  {
                try {
                        // Reload entry to include latest changes
                        GluuAppliance tmpAppliance = applianceService.getAppliance();

                        TrustStoreConfiguration currTrustStoreConfiguration = tmpAppliance.getTrustStoreConfiguration();
                        List<TrustStoreCertificate> currTrustStoreCertificates = tmpAppliance.getTrustStoreCertificates();
                        if (currTrustStoreCertificates == null) {
                                currTrustStoreCertificates = new ArrayList<TrustStoreCertificate>(0);
                        }

                        if (!trustStoreConfiguration.equals(currTrustStoreConfiguration)
                                        || !trustStoreCertificates.equals(currTrustStoreCertificates)) {
                                this.wereAnyChanges = true;
                        }

                        tmpAppliance.setTrustStoreConfiguration(trustStoreConfiguration);

                        if (trustStoreCertificates.size() == 0) {
                                tmpAppliance.setTrustStoreCertificates(null);
                        } else {
                                tmpAppliance.setTrustStoreCertificates(trustStoreCertificates);
                        }

                        applianceService.updateAppliance(tmpAppliance);
                } catch (BasePersistenceException ex) {
                        log.error("Failed to update appliance configuration", ex);
                        facesMessages.add(FacesMessage.SEVERITY_ERROR, "Failed to update appliance");
                        return false;
                }

                return true;
        }

メンバ詳解

appConfiguration

AppConfiguration org.gluu.oxtrust.action.ManageCertificateAction.appConfiguration

private

applianceService

ApplianceService org.gluu.oxtrust.action.ManageCertificateAction.applianceService

private

BEGIN_CERT_REQ

final String org.gluu.oxtrust.action.ManageCertificateAction.BEGIN_CERT_REQ = "-----BEGIN CERTIFICATE REQUEST-----"

static

certsMmanagePossible

boolean org.gluu.oxtrust.action.ManageCertificateAction.certsMmanagePossible

private

END_CERT_REQ

final String org.gluu.oxtrust.action.ManageCertificateAction.END_CERT_REQ = "-----END CERTIFICATE REQUEST-----"

static

facesMessages

FacesMessages org.gluu.oxtrust.action.ManageCertificateAction.facesMessages

private

identity

Identity org.gluu.oxtrust.action.ManageCertificateAction.identity

private

idpCertFN

String org.gluu.oxtrust.action.ManageCertificateAction.idpCertFN

package

initialized

boolean org.gluu.oxtrust.action.ManageCertificateAction.initialized

private

issuer

HashMap<String, String> org.gluu.oxtrust.action.ManageCertificateAction.issuer

private

log

Logger org.gluu.oxtrust.action.ManageCertificateAction.log

private

organizationService

OrganizationService org.gluu.oxtrust.action.ManageCertificateAction.organizationService

private

orgInumFN

String org.gluu.oxtrust.action.ManageCertificateAction.orgInumFN

private

serialVersionUID

final long org.gluu.oxtrust.action.ManageCertificateAction.serialVersionUID = 4012709440384265524L

staticprivate

sslService

SSLService org.gluu.oxtrust.action.ManageCertificateAction.sslService

private

subject

HashMap<String, String> org.gluu.oxtrust.action.ManageCertificateAction.subject

private

tomcatCertFN

String org.gluu.oxtrust.action.ManageCertificateAction.tomcatCertFN

package

trustStoreCertificates

List<TrustStoreCertificate> org.gluu.oxtrust.action.ManageCertificateAction.trustStoreCertificates

private

trustStoreCertificateUploadMarker

TrustStoreCertificate org.gluu.oxtrust.action.ManageCertificateAction.trustStoreCertificateUploadMarker

private

trustStoreConfiguration

TrustStoreConfiguration org.gluu.oxtrust.action.ManageCertificateAction.trustStoreConfiguration

private

uploadMarker

String org.gluu.oxtrust.action.ManageCertificateAction.uploadMarker

private

wereAnyChanges

boolean org.gluu.oxtrust.action.ManageCertificateAction.wereAnyChanges

private

---

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

• D:/AppData/OpenId/gluu/src/oxTrust/server/src/main/java/org/gluu/oxtrust/action/ManageCertificateAction.java