LONGBOW_TEST_CASE(ccnx_internal, parcPkcs12KeyStore_GetEncodedCertificate)
{
// create a file and open it
const char *password = "******";
const char *subject = "alice";
bool result;
result = parcPkcs12KeyStore_CreateFile(filename, password, subject, 1024, 32);
assertTrue(result, "got error from parcPkcs12KeyStore_CreatePkcs12File");
PARCPkcs12KeyStore *publicKeyStore = parcPkcs12KeyStore_Open(filename, password, PARC_HASH_SHA256);
assertNotNull(publicKeyStore, "Got null result from opening openssl pkcs12 file");
PARCKeyStore *keyStore = parcKeyStore_Create(publicKeyStore, PARCPkcs12KeyStoreAsKeyStore);
parcPkcs12KeyStore_Release(&publicKeyStore);
PARCBuffer *certificate_der = parcKeyStore_GetDEREncodedCertificate(keyStore);
assertNotNull(certificate_der, "got null public key digest for external pkcs12");
// 557 (64-bit) and 553 (32-bit) are pre-etermined sizes of how big a DER encoded
// certificate with a 1024-bit key should be
size_t expectedMinimumLength = 545;
size_t expectedMaximumLength = 560;
size_t bb_length = parcBuffer_Remaining(certificate_der);
assertTrue(expectedMinimumLength <= bb_length && bb_length <= expectedMaximumLength,
"Digest unexpected size: got %zu expected %zu - %zu", bb_length, expectedMinimumLength, expectedMaximumLength);
parcKeyStore_Release(&keyStore);
parcBuffer_Release(&certificate_der);
}
LONGBOW_TEST_CASE(Global, ccnxPortalFactory_GetKeyId)
{
const char *keystoreName = "ccnxPortalFactory_keystore";
parcSecurity_Init();
bool success = parcPkcs12KeyStore_CreateFile(keystoreName, "keystore_password", "consumer", 1024, 30);
assertTrue(success, "parcPkcs12KeyStore_CreateFile('%s', 'keystore_password') failed.", keystoreName);
PARCIdentityFile *identityFile = parcIdentityFile_Create(keystoreName, "keystore_password");
PARCIdentity *identity = parcIdentity_Create(identityFile, PARCIdentityFileAsPARCIdentity);
CCNxPortalFactory *factory = ccnxPortalFactory_Create(identity);
const PARCKeyId *actual = ccnxPortalFactory_GetKeyId(factory);
PARCSigner *signer = parcIdentity_CreateSigner(identity);
PARCKeyId *expected = parcSigner_CreateKeyId(signer);
parcSigner_Release(&signer);
assertTrue(parcKeyId_Equals(expected, actual), "KeyIds not equal");
parcKeyId_Release(&expected);
ccnxPortalFactory_Release(&factory);
parcIdentityFile_Release(&identityFile);
parcIdentity_Release(&identity);
parcSecurity_Fini();
}
LONGBOW_TEST_CASE(ccnx_internal, parcPkcs12KeyStore_GetCertificateDigest)
{
// create a file and open it
const char *password = "******";
const char *subject = "alice";
bool result;
result = parcPkcs12KeyStore_CreateFile(filename, password, subject, 1024, 32);
assertTrue(result, "got error from parcPkcs12KeyStore_CreatePkcs12File");
PARCPkcs12KeyStore *publicKeyStore = parcPkcs12KeyStore_Open(filename, password, PARC_HASH_SHA256);
assertNotNull(publicKeyStore, "Got null result from opening openssl pkcs12 file");
PARCKeyStore *keyStore = parcKeyStore_Create(publicKeyStore, PARCPkcs12KeyStoreAsKeyStore);
parcPkcs12KeyStore_Release(&publicKeyStore);
PARCCryptoHash *cert_digest = parcKeyStore_GetCertificateDigest(keyStore);
assertNotNull(cert_digest, "got null public key digest for external pkcs12");
size_t bb_length = parcBuffer_Remaining(parcCryptoHash_GetDigest(cert_digest));
assertTrue(bb_length == SHA256_DIGEST_LENGTH,
"Incorrect digest length returned from GetPublicKeyDigest: %zu", bb_length);
parcKeyStore_Release(&keyStore);
parcCryptoHash_Release(&cert_digest);
}
LONGBOW_TEST_CASE(Global, parcPkcs12KeyStore_CreateFile_Fail)
{
// create a file and open it
const char *filename = "/tmp/parcPkcs12KeyStore_CreateAndOpen.p12";
const char *password = "******";
const char *subject = "alice";
bool result;
result = parcPkcs12KeyStore_CreateFile(filename, password, subject, -1, 32);
assertFalse(result, "Expected false result from parcPkcs12KeyStore_CreateFile()");
unlink(filename);
}
/**
* Create a keystore with the new default name in the old location
*/
LONGBOW_TEST_CASE(Local, ccnxKeystoreUtilities_OpenFromHomeDirectory_Newfile)
{
char *homedir = ccnxKeystoreUtilities_GetHomeDirectory();
char *ccnxdir = ccnxKeystoreUtilities_ConstructPath(homedir, ".ccnx");
mkdir(ccnxdir, 0700);
char *path = ccnxKeystoreUtilities_ConstructPath(ccnxdir, ".ccnx_keystore.p12");
bool success = parcPkcs12KeyStore_CreateFile(path, "1234", "ccnxuser", 1024, 365);
assertTrue(success, "parcPkcs12KeyStore_CreateFile() failed.");
KeystoreParams *signer = ccnxKeystoreUtilities_OpenFromHomeDirectory("1234");
assertNotNull(signer, "Signer should be non-null opening from a file we just created");
keystoreParams_Destroy(&signer);
parcMemory_Deallocate((void **) &path);
parcMemory_Deallocate((void **) &ccnxdir);
parcMemory_Deallocate((void **) &homedir);
}
LONGBOW_TEST_CASE(Global, parcPkcs12KeyStore_CreateAndOpen)
{
// create a file and open it
const char *filename = "/tmp/parcPkcs12KeyStore_CreateAndOpen.p12";
const char *password = "******";
const char *subject = "alice";
bool result;
result = parcPkcs12KeyStore_CreateFile(filename, password, subject, 1024, 32);
assertTrue(result, "got error from parcPkcs12KeyStore_CreatePkcs12File");
PARCPkcs12KeyStore *keyStore = parcPkcs12KeyStore_Open(filename, password, PARC_HASH_SHA256);
assertNotNull(keyStore, "Got null result from opening openssl pkcs12 file");
parcPkcs12KeyStore_Release(&keyStore);
unlink(filename);
}
PARCIdentity *
createAndGetIdentity(void)
{
const char *keystoreName = "consumer_keystore";
const char *keystorePassword = "******";
unsigned int keyLength = 1024;
unsigned int validityDays = 30;
char *subjectName = "consumer";
bool success = parcPkcs12KeyStore_CreateFile(keystoreName, keystorePassword, subjectName, keyLength, validityDays);
assertTrue(success,
"parcPkcs12KeyStore_CreateFile('%s', '%s', '%s', %d, %d) failed.",
keystoreName, keystorePassword, subjectName, keyLength, validityDays);
PARCIdentityFile *identityFile = parcIdentityFile_Create(keystoreName, keystorePassword);
PARCIdentity *identity = parcIdentity_Create(identityFile, PARCIdentityFileAsPARCIdentity);
parcIdentityFile_Release(&identityFile);
return identity;
}
LONGBOW_TEST_CASE(CreateAcquireRelease, ccnxPortalFactory_Create)
{
const char *keystoreName = "ccnxPortalFactory_keystore";
parcSecurity_Init();
bool success = parcPkcs12KeyStore_CreateFile(keystoreName, "keystore_password", "consumer", 1024, 30);
assertTrue(success, "parcPkcs12KeyStore_CreateFile('%s', 'keystore_password') failed.", keystoreName);
PARCIdentityFile *identityFile = parcIdentityFile_Create(keystoreName, "keystore_password");
PARCIdentity *identity = parcIdentity_Create(identityFile, PARCIdentityFileAsPARCIdentity);
CCNxPortalFactory *factory = ccnxPortalFactory_Create(identity);
parcIdentityFile_Release(&identityFile);
parcIdentity_Release(&identity);
ccnxPortalFactory_Release(&factory);
parcSecurity_Fini();
}
PARCIdentity *
ccnxFileRepoCommon_CreateAndGetIdentity(const char *keystoreName,
const char *keystorePassword,
const char *subjectName)
{
parcSecurity_Init();
unsigned int keyLength = 1024;
unsigned int validityDays = 30;
bool success = parcPkcs12KeyStore_CreateFile(keystoreName, keystorePassword, subjectName, keyLength, validityDays);
assertTrue(success,
"parcPkcs12KeyStore_CreateFile('%s', '%s', '%s', %d, %d) failed.",
keystoreName, keystorePassword, subjectName, keyLength, validityDays);
PARCIdentityFile *identityFile = parcIdentityFile_Create(keystoreName, keystorePassword);
PARCIdentity *result = parcIdentity_Create(identityFile, PARCIdentityFileAsPARCIdentity);
parcIdentityFile_Release(&identityFile);
parcSecurity_Fini();
return result;
}
LONGBOW_TEST_CASE(Global, ccnxPortalFactory_GetIdentity)
{
const char *keystoreName = "ccnxPortalFactory_keystore";
parcSecurity_Init();
bool success = parcPkcs12KeyStore_CreateFile(keystoreName, "keystore_password", "consumer", 1024, 30);
assertTrue(success, "parcPkcs12KeyStore_CreateFile('%s', 'keystore_password') failed.", keystoreName);
PARCIdentityFile *identityFile = parcIdentityFile_Create(keystoreName, "keystore_password");
PARCIdentity *identity = parcIdentity_Create(identityFile, PARCIdentityFileAsPARCIdentity);
CCNxPortalFactory *factory = ccnxPortalFactory_Create(identity);
const PARCIdentity *actual = ccnxPortalFactory_GetIdentity(factory);
assertTrue(identity == actual, "Expected the result to be the same as provided to the constructor");
parcIdentityFile_Release(&identityFile);
parcIdentity_Release(&identity);
ccnxPortalFactory_Release(&factory);
parcSecurity_Fini();
}
LONGBOW_TEST_CASE(ccnx_internal, parcPkcs12KeyStore_GetEncodedPublicKey)
{
// create a file and open it
const char *password = "******";
const char *subject = "alice";
bool result;
result = parcPkcs12KeyStore_CreateFile(filename, password, subject, 1024, 32);
assertTrue(result, "got error from parcPkcs12KeyStore_CreatePkcs12File");
PARCPkcs12KeyStore *publicKeyStore = parcPkcs12KeyStore_Open(filename, password, PARC_HASH_SHA256);
assertNotNull(publicKeyStore, "Got null result from opening openssl pkcs12 file");
PARCKeyStore *keyStore = parcKeyStore_Create(publicKeyStore, PARCPkcs12KeyStoreAsKeyStore);
parcPkcs12KeyStore_Release(&publicKeyStore);
PARCBuffer *pubkey_der = parcKeyStore_GetDEREncodedPublicKey(keyStore);
assertNotNull(pubkey_der, "got null public key digest for external pkcs12");
size_t bb_length = parcBuffer_Remaining(pubkey_der);
assertTrue(bb_length == 162, "Incorrect digest length returned from GetPublicKeyDigest: %zu", bb_length);
parcKeyStore_Release(&keyStore);
parcBuffer_Release(&pubkey_der);
}
