org.xdi.oxauth.comp.CryptoProviderTest クラス

org.xdi.oxauth.comp.CryptoProviderTest の継承関係図

org.xdi.oxauth.comp.CryptoProviderTest 連携図

公開メンバ関数
void	configuration ()
void	testGenerateKeyNone ()
void	testGenerateKeyHS256 ()
void	testGenerateKeyHS384 ()
void	testGenerateKeyHS512 ()
void	testSignHS256 ()
void	testVerifyHS256 ()
void	testSignHS384 ()
void	testVerifyHS384 ()
void	testSignHS512 ()
void	testVerifyHS512 ()
void	testGenerateKeyRS256 ()
void	testSignRS256 ()
void	testVerifyRS256 ()
void	testDeleteKeyRS256 ()
void	testGenerateKeyRS384 ()
void	testSignRS384 ()
void	testVerifyRS384 ()
void	testDeleteKeyRS384 ()
void	testGenerateKeyRS512 ()
void	testSignRS512 ()
void	testVerifyRS512 ()
void	testDeleteKeyRS512 ()
void	testGenerateKeyES256 ()
void	testSignES256 ()
void	testVerifyES256 ()
void	testDeleteKeyES256 ()
void	testGenerateKeyES384 ()
void	testSignES384 ()
void	testVerifyES384 ()
void	testDeleteKeyES384 ()
void	testGenerateKeyES512 ()
void	testSignES512 ()
void	testVerifyES512 ()
void	testDeleteKeyES512 ()
void	initTestSuite (ITestContext context) throws FileNotFoundException, IOException

静的公開メンバ関数
static Archive<?>	createDeployment ()

静的公開変数類
static FileConfiguration	testData

非公開変数類
ConfigurationFactory	configurationFactory
final String	SIGNING_INPUT = "Signing Input"
final String	SHARED_SECRET = "secret"

静的非公開変数類
static AbstractCryptoProvider	cryptoProvider
static Long	expirationTime
static String	hs256Signature
static String	hs384Signature
static String	hs512Signature
static String	rs256Key
static String	rs256Signature
static String	rs384Key
static String	rs384Signature
static String	rs512Key
static String	rs512Signature
static String	es256Key
static String	es256Signature
static String	es384Key
static String	es384Signature
static String	es512Key
static String	es512Signature

詳解

著者

Javier Rojas Blum

バージョン

August 8, 2016

関数詳解

configuration()

void org.xdi.oxauth.comp.CryptoProviderTest.configuration ( )

inline

                                    {
                try {
                        AppConfiguration appConfiguration = configurationFactory.getAppConfiguration();
                        assertNotNull(appConfiguration);

                        cryptoProvider = CryptoProviderFactory.getCryptoProvider(appConfiguration);
                        assertNotNull(cryptoProvider);

                        GregorianCalendar calendar = new GregorianCalendar(TimeZone.getTimeZone("UTC"));
                        calendar.add(GregorianCalendar.MINUTE, 5);
                        expirationTime = calendar.getTimeInMillis();
                } catch (Exception e) {
                        fail(e.getMessage(), e);
                }
        }

createDeployment()

static Archive<?> org.xdi.oxauth.ConfigurableTest.createDeployment ( )

inlinestaticinherited

                                                    {
                return Deployments.createDeployment();
        }

initTestSuite()

void org.xdi.oxauth.ConfigurableTest.initTestSuite ( ITestContext  context ) throws FileNotFoundException, IOException

inlineinherited

                                                                                                  {
        Reporter.log("Invoked init test suite method", true);

        String propertiesFile = context.getCurrentXmlTest().getParameter("propertiesFile");
                if (StringHelper.isEmpty(propertiesFile)) {
                        propertiesFile = "target/test-classes/testng.properties";
                }

                // Load test parameters
                FileInputStream conf = new FileInputStream(propertiesFile);
        Properties prop;
        try {
                        prop = new Properties();
                        prop.load(conf);
                } finally {
                        IOUtils.closeQuietly(conf);
                }

                Map<String, String> parameters = new HashMap<String, String>();
                for (Entry<Object, Object> entry : prop.entrySet()) {
                        Object key = entry.getKey();
                        Object value = entry.getValue();

                        if (StringHelper.isEmptyString(key) || StringHelper.isEmptyString(value)) {
                                continue;
                        }
                        parameters.put(key.toString(), value.toString());
                }

                // Overrided test parameters
                context.getSuite().getXmlSuite().setParameters(parameters);
        }

testDeleteKeyES256()

void org.xdi.oxauth.comp.CryptoProviderTest.testDeleteKeyES256 ( )

inline

                                         {
                try {
                        cryptoProvider.deleteKey(es256Key);
                } catch (Exception e) {
                        fail(e.getMessage(), e);
                }
        }

testDeleteKeyES384()

void org.xdi.oxauth.comp.CryptoProviderTest.testDeleteKeyES384 ( )

inline

                                         {
                try {
                        cryptoProvider.deleteKey(es384Key);
                } catch (Exception e) {
                        fail(e.getMessage(), e);
                }
        }

testDeleteKeyES512()

void org.xdi.oxauth.comp.CryptoProviderTest.testDeleteKeyES512 ( )

inline

                                         {
                try {
                        cryptoProvider.deleteKey(es512Key);
                } catch (Exception e) {
                        fail(e.getMessage(), e);
                }
        }

testDeleteKeyRS256()

void org.xdi.oxauth.comp.CryptoProviderTest.testDeleteKeyRS256 ( )

inline

                                         {
                try {
                        cryptoProvider.deleteKey(rs256Key);
                } catch (Exception e) {
                        fail(e.getMessage(), e);
                }
        }

testDeleteKeyRS384()

void org.xdi.oxauth.comp.CryptoProviderTest.testDeleteKeyRS384 ( )

inline

                                         {
                try {
                        cryptoProvider.deleteKey(rs384Key);
                } catch (Exception e) {
                        fail(e.getMessage(), e);
                }
        }

testDeleteKeyRS512()

void org.xdi.oxauth.comp.CryptoProviderTest.testDeleteKeyRS512 ( )

inline

                                         {
                try {
                        cryptoProvider.deleteKey(rs512Key);
                } catch (Exception e) {
                        fail(e.getMessage(), e);
                }
        }

testGenerateKeyES256()

void org.xdi.oxauth.comp.CryptoProviderTest.testGenerateKeyES256 ( )

inline

                                           {
                try {
                        JSONObject response = cryptoProvider.generateKey(SignatureAlgorithm.ES256, expirationTime);
                        es256Key = response.optString(KEY_ID);
                } catch (Exception e) {
                        fail(e.getMessage(), e);
                }
        }

testGenerateKeyES384()

void org.xdi.oxauth.comp.CryptoProviderTest.testGenerateKeyES384 ( )

inline

                                           {
                try {
                        JSONObject response = cryptoProvider.generateKey(SignatureAlgorithm.ES384, expirationTime);
                        es384Key = response.optString(KEY_ID);
                } catch (Exception e) {
                        fail(e.getMessage(), e);
                }
        }

testGenerateKeyES512()

void org.xdi.oxauth.comp.CryptoProviderTest.testGenerateKeyES512 ( )

inline

                                           {
                try {
                        JSONObject response = cryptoProvider.generateKey(SignatureAlgorithm.ES512, expirationTime);
                        es512Key = response.optString(KEY_ID);
                } catch (Exception e) {
                        fail(e.getMessage(), e);
                }
        }

testGenerateKeyHS256()

void org.xdi.oxauth.comp.CryptoProviderTest.testGenerateKeyHS256 ( )

inline

                                           {
                boolean algorithmNotSupported = false;

                try {
                        cryptoProvider.generateKey(SignatureAlgorithm.HS256, expirationTime);
                } catch (Exception e) {
                        algorithmNotSupported = true;
                }

                assertTrue(algorithmNotSupported);
        }

testGenerateKeyHS384()

void org.xdi.oxauth.comp.CryptoProviderTest.testGenerateKeyHS384 ( )

inline

                                           {
                boolean algorithmNotSupported = false;

                try {
                        cryptoProvider.generateKey(SignatureAlgorithm.HS384, expirationTime);
                } catch (Exception e) {
                        algorithmNotSupported = true;
                }

                assertTrue(algorithmNotSupported);
        }

testGenerateKeyHS512()

void org.xdi.oxauth.comp.CryptoProviderTest.testGenerateKeyHS512 ( )

inline

                                           {
                boolean algorithmNotSupported = false;

                try {
                        cryptoProvider.generateKey(SignatureAlgorithm.HS512, expirationTime);
                } catch (Exception e) {
                        algorithmNotSupported = true;
                }

                assertTrue(algorithmNotSupported);
        }

testGenerateKeyNone()

void org.xdi.oxauth.comp.CryptoProviderTest.testGenerateKeyNone ( )

inline

                                          {
                boolean algorithmNotSupported = false;

                try {
                        cryptoProvider.generateKey(SignatureAlgorithm.NONE, expirationTime);
                } catch (Exception e) {
                        algorithmNotSupported = true;
                }

                assertTrue(algorithmNotSupported);
        }

testGenerateKeyRS256()

void org.xdi.oxauth.comp.CryptoProviderTest.testGenerateKeyRS256 ( )

inline

                                           {
                try {
                        JSONObject response = cryptoProvider.generateKey(SignatureAlgorithm.RS256, expirationTime);
                        rs256Key = response.optString(KEY_ID);
                } catch (Exception e) {
                        fail(e.getMessage(), e);
                }
        }

testGenerateKeyRS384()

void org.xdi.oxauth.comp.CryptoProviderTest.testGenerateKeyRS384 ( )

inline

                                           {
                try {
                        JSONObject response = cryptoProvider.generateKey(SignatureAlgorithm.RS384, expirationTime);
                        rs384Key = response.optString(KEY_ID);
                } catch (Exception e) {
                        fail(e.getMessage(), e);
                }
        }

testGenerateKeyRS512()

void org.xdi.oxauth.comp.CryptoProviderTest.testGenerateKeyRS512 ( )

inline

                                           {
                try {
                        JSONObject response = cryptoProvider.generateKey(SignatureAlgorithm.RS512, expirationTime);
                        rs512Key = response.optString(KEY_ID);
                } catch (Exception e) {
                        fail(e.getMessage(), e);
                }
        }

testSignES256()

void org.xdi.oxauth.comp.CryptoProviderTest.testSignES256 ( )

inline

                                    {
                try {
                        es256Signature = cryptoProvider.sign(SIGNING_INPUT, es256Key, null, SignatureAlgorithm.ES256);
                        assertNotNull(es256Signature);
                } catch (Exception e) {
                        fail(e.getMessage(), e);
                }
        }

testSignES384()

void org.xdi.oxauth.comp.CryptoProviderTest.testSignES384 ( )

inline

                                    {
                try {
                        es384Signature = cryptoProvider.sign(SIGNING_INPUT, es384Key, null, SignatureAlgorithm.ES384);
                        assertNotNull(es384Signature);
                } catch (Exception e) {
                        fail(e.getMessage(), e);
                }
        }

testSignES512()

void org.xdi.oxauth.comp.CryptoProviderTest.testSignES512 ( )

inline

                                    {
                try {
                        es512Signature = cryptoProvider.sign(SIGNING_INPUT, es512Key, null, SignatureAlgorithm.ES512);
                        assertNotNull(es512Signature);
                } catch (Exception e) {
                        fail(e.getMessage(), e);
                }
        }

testSignHS256()

void org.xdi.oxauth.comp.CryptoProviderTest.testSignHS256 ( )

inline

                                    {
                try {
                        hs256Signature = cryptoProvider.sign(SIGNING_INPUT, null, SHARED_SECRET, SignatureAlgorithm.HS256);
                        assertNotNull(hs256Signature);
                } catch (Exception e) {
                        fail(e.getMessage(), e);
                }
        }

testSignHS384()

void org.xdi.oxauth.comp.CryptoProviderTest.testSignHS384 ( )

inline

                                    {
                try {
                        hs384Signature = cryptoProvider.sign(SIGNING_INPUT, null, SHARED_SECRET, SignatureAlgorithm.HS384);
                        assertNotNull(hs384Signature);
                } catch (Exception e) {
                        fail(e.getMessage(), e);
                }
        }

testSignHS512()

void org.xdi.oxauth.comp.CryptoProviderTest.testSignHS512 ( )

inline

                                    {
                try {
                        hs512Signature = cryptoProvider.sign(SIGNING_INPUT, null, SHARED_SECRET, SignatureAlgorithm.HS512);
                        assertNotNull(hs512Signature);
                } catch (Exception e) {
                        fail(e.getMessage(), e);
                }
        }

testSignRS256()

void org.xdi.oxauth.comp.CryptoProviderTest.testSignRS256 ( )

inline

                                    {
                try {
                        rs256Signature = cryptoProvider.sign(SIGNING_INPUT, rs256Key, null, SignatureAlgorithm.RS256);
                        assertNotNull(rs256Signature);
                } catch (Exception e) {
                        fail(e.getMessage(), e);
                }
        }

testSignRS384()

void org.xdi.oxauth.comp.CryptoProviderTest.testSignRS384 ( )

inline

                                    {
                try {
                        rs384Signature = cryptoProvider.sign(SIGNING_INPUT, rs384Key, null, SignatureAlgorithm.RS384);
                        assertNotNull(rs384Signature);
                } catch (Exception e) {
                        fail(e.getMessage(), e);
                }
        }

testSignRS512()

void org.xdi.oxauth.comp.CryptoProviderTest.testSignRS512 ( )

inline

                                    {
                try {
                        rs512Signature = cryptoProvider.sign(SIGNING_INPUT, rs512Key, null, SignatureAlgorithm.RS512);
                        assertNotNull(rs512Signature);
                } catch (Exception e) {
                        fail(e.getMessage(), e);
                }
        }

testVerifyES256()

void org.xdi.oxauth.comp.CryptoProviderTest.testVerifyES256 ( )

inline

                                      {
                try {
                        boolean signatureVerified = cryptoProvider.verifySignature(SIGNING_INPUT, es256Signature, es256Key, null,
                                        null, SignatureAlgorithm.ES256);
                        assertTrue(signatureVerified);
                } catch (Exception e) {
                        fail(e.getMessage(), e);
                }
        }

testVerifyES384()

void org.xdi.oxauth.comp.CryptoProviderTest.testVerifyES384 ( )

inline

                                      {
                try {
                        boolean signatureVerified = cryptoProvider.verifySignature(SIGNING_INPUT, es384Signature, es384Key, null,
                                        null, SignatureAlgorithm.ES384);
                        assertTrue(signatureVerified);
                } catch (Exception e) {
                        fail(e.getMessage(), e);
                }
        }

testVerifyES512()

void org.xdi.oxauth.comp.CryptoProviderTest.testVerifyES512 ( )

inline

                                      {
                try {
                        boolean signatureVerified = cryptoProvider.verifySignature(SIGNING_INPUT, es512Signature, es512Key, null,
                                        null, SignatureAlgorithm.ES512);
                        assertTrue(signatureVerified);
                } catch (Exception e) {
                        fail(e.getMessage(), e);
                }
        }

testVerifyHS256()

void org.xdi.oxauth.comp.CryptoProviderTest.testVerifyHS256 ( )

inline

                                      {
                try {
                        boolean signatureVerified = cryptoProvider.verifySignature(SIGNING_INPUT, hs256Signature, null, null,
                                        SHARED_SECRET, SignatureAlgorithm.HS256);
                        assertTrue(signatureVerified);
                } catch (Exception e) {
                        fail(e.getMessage(), e);
                }
        }

testVerifyHS384()

void org.xdi.oxauth.comp.CryptoProviderTest.testVerifyHS384 ( )

inline

                                      {
                try {
                        boolean signatureVerified = cryptoProvider.verifySignature(SIGNING_INPUT, hs384Signature, null, null,
                                        SHARED_SECRET, SignatureAlgorithm.HS384);
                        assertTrue(signatureVerified);
                } catch (Exception e) {
                        fail(e.getMessage(), e);
                }
        }

testVerifyHS512()

void org.xdi.oxauth.comp.CryptoProviderTest.testVerifyHS512 ( )

inline

                                      {
                try {
                        boolean signatureVerified = cryptoProvider.verifySignature(SIGNING_INPUT, hs512Signature, null, null,
                                        SHARED_SECRET, SignatureAlgorithm.HS512);
                        assertTrue(signatureVerified);
                } catch (Exception e) {
                        fail(e.getMessage(), e);
                }
        }

testVerifyRS256()

void org.xdi.oxauth.comp.CryptoProviderTest.testVerifyRS256 ( )

inline

                                      {
                try {
                        boolean signatureVerified = cryptoProvider.verifySignature(SIGNING_INPUT, rs256Signature, rs256Key, null,
                                        null, SignatureAlgorithm.RS256);
                        assertTrue(signatureVerified);
                } catch (Exception e) {
                        fail(e.getMessage(), e);
                }
        }

testVerifyRS384()

void org.xdi.oxauth.comp.CryptoProviderTest.testVerifyRS384 ( )

inline

                                      {
                try {
                        boolean signatureVerified = cryptoProvider.verifySignature(SIGNING_INPUT, rs384Signature, rs384Key, null,
                                        null, SignatureAlgorithm.RS384);
                        assertTrue(signatureVerified);
                } catch (Exception e) {
                        fail(e.getMessage(), e);
                }
        }

testVerifyRS512()

void org.xdi.oxauth.comp.CryptoProviderTest.testVerifyRS512 ( )

inline

                                      {
                try {
                        boolean signatureVerified = cryptoProvider.verifySignature(SIGNING_INPUT, rs512Signature, rs512Key, null,
                                        null, SignatureAlgorithm.RS512);
                        assertTrue(signatureVerified);
                } catch (Exception e) {
                        fail(e.getMessage(), e);
                }
        }

メンバ詳解

configurationFactory

ConfigurationFactory org.xdi.oxauth.comp.CryptoProviderTest.configurationFactory

private

cryptoProvider

AbstractCryptoProvider org.xdi.oxauth.comp.CryptoProviderTest.cryptoProvider

staticprivate

es256Key

String org.xdi.oxauth.comp.CryptoProviderTest.es256Key

staticprivate

es256Signature

String org.xdi.oxauth.comp.CryptoProviderTest.es256Signature

staticprivate

es384Key

String org.xdi.oxauth.comp.CryptoProviderTest.es384Key

staticprivate

es384Signature

String org.xdi.oxauth.comp.CryptoProviderTest.es384Signature

staticprivate

es512Key

String org.xdi.oxauth.comp.CryptoProviderTest.es512Key

staticprivate

es512Signature

String org.xdi.oxauth.comp.CryptoProviderTest.es512Signature

staticprivate

expirationTime

Long org.xdi.oxauth.comp.CryptoProviderTest.expirationTime

staticprivate

hs256Signature

String org.xdi.oxauth.comp.CryptoProviderTest.hs256Signature

staticprivate

hs384Signature

String org.xdi.oxauth.comp.CryptoProviderTest.hs384Signature

staticprivate

hs512Signature

String org.xdi.oxauth.comp.CryptoProviderTest.hs512Signature

staticprivate

rs256Key

String org.xdi.oxauth.comp.CryptoProviderTest.rs256Key

staticprivate

rs256Signature

String org.xdi.oxauth.comp.CryptoProviderTest.rs256Signature

staticprivate

rs384Key

String org.xdi.oxauth.comp.CryptoProviderTest.rs384Key

staticprivate

rs384Signature

String org.xdi.oxauth.comp.CryptoProviderTest.rs384Signature

staticprivate

rs512Key

String org.xdi.oxauth.comp.CryptoProviderTest.rs512Key

staticprivate

rs512Signature

String org.xdi.oxauth.comp.CryptoProviderTest.rs512Signature

staticprivate

SHARED_SECRET

final String org.xdi.oxauth.comp.CryptoProviderTest.SHARED_SECRET = "secret"

private

SIGNING_INPUT

final String org.xdi.oxauth.comp.CryptoProviderTest.SIGNING_INPUT = "Signing Input"

private

testData

FileConfiguration org.xdi.oxauth.ConfigurableTest.testData

staticinherited

---

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

• D:/AppData/OpenId/gluu/src/oxAuth/Server/src/test/java/org/xdi/oxauth/comp/CryptoProviderTest.java