LONGBOW_TEST_CASE(Global, parcCryptoHash_GetDigest) { int fd_buffer = open("test_digest_bytes_128.bin", O_RDONLY); int fd_truth = open("test_digest_bytes_128.sha256", O_RDONLY); assertFalse(fd_buffer < 0, "Could not open %s: %s", "test_digest_bytes_128.bin", strerror(errno)); assertFalse(fd_truth < 0, "Could not open %s: %s", "test_digest_bytes_128.sha256", strerror(errno)); uint8_t scratch[bufferLength]; ssize_t read_length = read(fd_truth, scratch, bufferLength); PARCCryptoHash *hashTruth = parcCryptoHash_CreateFromArray(PARC_HASH_SHA256, scratch, read_length); read_length = read(fd_buffer, scratch, bufferLength); PARCCryptoHasher *hasher = parcCryptoHasher_Create(PARC_HASH_SHA256); parcCryptoHasher_Init(hasher); parcCryptoHasher_UpdateBytes(hasher, scratch, read_length); PARCCryptoHash *hashTest = parcCryptoHasher_Finalize(hasher); assertTrue(parcBuffer_Equals(parcCryptoHash_GetDigest(hashTruth), parcCryptoHash_GetDigest(hashTest)), "Expected to be true"); parcCryptoHasher_Release(&hasher); parcCryptoHash_Release(&hashTruth); parcCryptoHash_Release(&hashTest); close(fd_buffer); close(fd_truth); }
LONGBOW_TEST_CASE(Global, parcCryptoHash_Equals) { int fd1 = open("test_digest_bytes_128.sha256", O_RDONLY); assertFalse(fd1 < 0, "Could not open %s: %s", "test_digest_bytes_128.sha256", strerror(errno)); uint8_t scratch1[bufferLength]; ssize_t read_length = read(fd1, scratch1, bufferLength); PARCCryptoHash *hash1 = parcCryptoHash_CreateFromArray(PARC_HASH_SHA256, scratch1, read_length); PARCCryptoHash *hash2 = parcCryptoHash_CreateFromArray(PARC_HASH_SHA256, scratch1, read_length); PARCCryptoHash *hash3 = parcCryptoHash_CreateFromArray(PARC_HASH_SHA256, scratch1, read_length); int fd2 = open("test_digest_bytes_128.sha512", O_RDONLY); assertFalse(fd2 < 0, "Could not open %s: %s", "test_digest_bytes_128.sha512", strerror(errno)); uint8_t scratch2[bufferLength]; read_length = read(fd2, scratch2, bufferLength); PARCCryptoHash *unequalhash = parcCryptoHash_CreateFromArray(PARC_HASH_SHA256, scratch2, read_length); parcObjectTesting_AssertEqualsFunction(parcCryptoHash_Equals, hash1, hash2, hash3, unequalhash); parcCryptoHash_Release(&hash1); parcCryptoHash_Release(&hash2); parcCryptoHash_Release(&hash3); parcCryptoHash_Release(&unequalhash); close(fd1); close(fd2); }
/** * Get the certificate digest from the openssl command line pkcs12 */ LONGBOW_TEST_CASE(openssl_commandline, parcPkcs12KeyStore_GetCertificateDigest) { PARCPkcs12KeyStore *publicKeyStore = parcPkcs12KeyStore_Open("test_rsa.p12", "blueberry", PARC_HASH_SHA256); PARCKeyStore *keyStore = parcKeyStore_Create(publicKeyStore, PARCPkcs12KeyStoreAsKeyStore); parcPkcs12KeyStore_Release(&publicKeyStore); PARCPublicKeySigner *publicKeySigner = parcPublicKeySigner_Create(keyStore, PARCSigningAlgorithm_RSA, PARC_HASH_SHA256); parcKeyStore_Release(&keyStore); PARCSigner *signer = parcSigner_Create(publicKeySigner, PARCPublicKeySignerAsSigner); parcPublicKeySigner_Release(&publicKeySigner); assertNotNull(signer, "Got null result from opening openssl pkcs12 file"); PARCCryptoHash *cert_digest = parcKeyStore_GetCertificateDigest(parcSigner_GetKeyStore(signer)); assertNotNull(cert_digest, "got null public key digest for external pkcs12"); // read in the "truth" from the command line utilities int fd = open("test_rsa_crt_sha256.bin", O_RDONLY); uint8_t true_digest[SHA256_DIGEST_LENGTH]; ssize_t read_bytes = read(fd, true_digest, SHA256_DIGEST_LENGTH); close(fd); assertTrue(read_bytes == SHA256_DIGEST_LENGTH, "could not read %d byte digest from test_rsa_pub_sha256.bin", SHA256_DIGEST_LENGTH); const uint8_t *bb_buffer = parcByteArray_Array(parcBuffer_Array(parcCryptoHash_GetDigest(cert_digest))); size_t bb_length = parcBuffer_Remaining(parcCryptoHash_GetDigest(cert_digest)); assertTrue(bb_length == SHA256_DIGEST_LENGTH, "Incorrect digest length returned from GetCertificateDigest: %zu", bb_length); assertTrue(memcmp(bb_buffer, true_digest, SHA256_DIGEST_LENGTH) == 0, "digests did not match"); parcSigner_Release(&signer); parcCryptoHash_Release(&cert_digest); }
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, parcSigner_CreatePublicKey) { _MockSigner *mock = _createSigner(); PARCSigner *signer = parcSigner_Create(mock, _MockSignerInterface); PARCKey *key = parcSigner_CreatePublicKey(signer); // Compute the real value PARCCryptoHash *hash = parcKeyStore_GetVerifierKeyDigest(mock->keyStore); PARCKeyId *keyid = parcKeyId_Create(parcCryptoHash_GetDigest(hash)); PARCBuffer *derEncodedKey = parcKeyStore_GetDEREncodedPublicKey(mock->keyStore); PARCKey *expectedKey = parcKey_CreateFromDerEncodedPublicKey(keyid, parcSigner_GetSigningAlgorithm(signer), derEncodedKey); parcBuffer_Release(&derEncodedKey); parcKeyId_Release(&keyid); parcCryptoHash_Release(&hash); assertTrue(parcKey_Equals(key, expectedKey), "Expected public keys to be computed equally."); parcKey_Release(&key); parcKey_Release(&expectedKey); parcSigner_Release(&signer); _mockSigner_Release(&mock); }
LONGBOW_TEST_CASE(Global, ccnxWireFormatMessage_HashProtectedRegion) { // >1234< const char string[] = "Hello dev null\n"; PARCBuffer *buffer = parcBuffer_Wrap((void *) string, sizeof(string), 0, sizeof(string)); size_t start = 5; size_t length = 4; CCNxWireFormatMessage *message = ccnxWireFormatMessage_FromContentObjectPacketType(CCNxTlvDictionary_SchemaVersion_V1, buffer); ccnxWireFormatMessage_SetProtectedRegionStart(message, start); ccnxWireFormatMessage_SetProtectedRegionLength(message, length); PARCCryptoHasher *hasher = parcCryptoHasher_Create(PARCCryptoHashType_SHA256); PARCCryptoHash *hash = ccnxWireFormatMessage_HashProtectedRegion(message, hasher); // the correctness of the has is tested in _ccnxWireFormatFacadeV1_ComputeHash assertNotNull(hash, "Got null hash from a good packet"); ccnxWireFormatMessage_Release(&message); parcCryptoHash_Release(&hash); parcBuffer_Release(&buffer); parcCryptoHasher_Release(&hasher); }
CCNxInterestPayloadId * ccnxInterestPayloadId_CreateAsSHA256Hash(const PARCBuffer *data) { CCNxInterestPayloadId *result = parcObject_CreateInstance(CCNxInterestPayloadId); PARCCryptoHasher *hasher = parcCryptoHasher_Create(PARCCryptoHashType_SHA256); parcCryptoHasher_Init(hasher); parcCryptoHasher_UpdateBuffer(hasher, data); PARCCryptoHash *hash = parcCryptoHasher_Finalize(hasher); parcCryptoHasher_Release(&hasher); PARCBuffer *hashData = parcCryptoHash_GetDigest(hash); PARCBuffer *codedHash = parcBuffer_Allocate(parcBuffer_Capacity(hashData) + 1); parcBuffer_PutUint8(codedHash, CCNxInterestPayloadId_TypeCode_RFC6920_SHA256); parcBuffer_PutBuffer(codedHash, hashData); parcBuffer_Flip(codedHash); result->nameSegment = ccnxNameSegment_CreateTypeValue(CCNxNameLabelType_PAYLOADID, codedHash); parcBuffer_Release(&codedHash); parcCryptoHash_Release(&hash); return result; }
LONGBOW_TEST_CASE(Global, parcCryptoHash_CreateFromArray) { int fd = open("test_digest_bytes_128.sha256", O_RDONLY); assertFalse(fd < 0, "Could not open %s: %s", "test_digest_bytes_128.sha256", strerror(errno)); uint8_t scratch[bufferLength]; ssize_t read_length = read(fd, scratch, bufferLength); PARCCryptoHash *hash = parcCryptoHash_CreateFromArray(PARC_HASH_SHA256, scratch, read_length); assertNotNull(hash, "Expected to be non null"); parcCryptoHash_Release(&hash); close(fd); }
static void _destroy(struct ccnx_signer_interface **interfaceContextPtr) { assertNotNull(interfaceContextPtr, "Got null double pointer"); assertNotNull(*interfaceContextPtr, "Got null pointer dereference"); PARCSigningInterface *interface = (PARCSigningInterface *) *interfaceContextPtr; _PARCAesSignerFileStore *keystore = (_PARCAesSignerFileStore *) interface->interfaceContext; parcBuffer_Release(&keystore->secretKey); parcCryptoHash_Release(&(keystore->secretKeyHash)); parcCryptoHasher_Release(&(keystore->hasher)); parcMemory_Deallocate((void **) &keystore); parcMemory_Deallocate((void **) &interface); *interfaceContextPtr = NULL; }
static bool _parcSymmetricKeySigner_Finalize(PARCSymmetricKeySigner **instancePtr) { assertNotNull(instancePtr, "Parameter must be a non-null pointer to a PARCSymmetricKeySigner pointer."); PARCSymmetricKeySigner *signer = (PARCSymmetricKeySigner *) *instancePtr; if (signer->secretKeyHash != NULL) { parcCryptoHash_Release(&signer->secretKeyHash); } if (signer->hasher != NULL) { parcCryptoHasher_Release(&signer->hasher); } if (signer->keyStore != NULL) { parcSymmetricKeyStore_Release(&signer->keyStore); } if (signer->generalKeyStore != NULL) { parcKeyStore_Release(&signer->generalKeyStore); } return true; }
LONGBOW_TEST_CASE(Global, ccnxWireFormatMessage_CreateContentObjectHash) { // >1234< const char string[] = "Hello dev null\n"; PARCBuffer *buffer = parcBuffer_Wrap((void *) string, sizeof(string), 0, sizeof(string)); CCNxWireFormatMessage *message = ccnxWireFormatMessage_FromContentObjectPacketType(CCNxTlvDictionary_SchemaVersion_V1, buffer); PARCCryptoHash *hash = ccnxWireFormatMessage_CreateContentObjectHash(message); ccnxWireFormatMessage_Release(&message); assertNull(hash, "Expect NULL for hash as it hasn't been encoded yet"); // We need to create a content object that is hashable CCNxName *name = ccnxName_CreateFromCString("lci:/test/content"); CCNxContentObject *contentObject = ccnxContentObject_CreateWithNameAndPayload(name, buffer); ccnxName_Release(&name); // This next stuff is to force an encode/decode to setup hash extents CCNxCodecNetworkBufferIoVec *iovec = ccnxCodecTlvPacket_DictionaryEncode(contentObject, NULL); ccnxContentObject_Release(&contentObject); PARCBuffer *encodedMessage = _iovecToParcBuffer(iovec); ccnxCodecNetworkBufferIoVec_Release(&iovec); // Decode message = ccnxWireFormatMessage_Create(encodedMessage); CCNxTlvDictionary *dictionary = ccnxWireFormatMessage_GetDictionary(message); bool success = ccnxCodecTlvPacket_BufferDecode(encodedMessage, dictionary); assertTrue(success, "Failed to decode buffer"); parcBuffer_Release(&encodedMessage); hash = ccnxWireFormatMessage_CreateContentObjectHash(message); // the correctness of the hash is tested in _ccnxWireFormatFacadeV1_ComputeHash assertNotNull(hash, "Got null hash from a good packet"); ccnxWireFormatMessage_Release(&message); parcCryptoHash_Release(&hash); parcBuffer_Release(&buffer); }
LONGBOW_TEST_CASE(Global, parcSigner_SignDigest) { _MockSigner *mock = _createSigner(); PARCSigner *signer = parcSigner_Create(mock, _MockSignerInterface); _mockSigner_Release(&mock); PARCBuffer *buffer = parcBuffer_Allocate(10); PARCCryptoHash *hash = parcCryptoHash_Create(PARCCryptoHashType_SHA256, buffer); PARCSignature *signature = parcSigner_SignDigest(signer, hash); assertNotNull(signature, "Expected non-NULL PARCSignature"); PARCBuffer *bits = parcSignature_GetSignature(signature); char *bitstring = parcBuffer_ToString(bits); char *expectedString = FAKE_SIGNATURE; assertTrue(strcmp(bitstring, expectedString) == 0, "Expected the forced signature as output %s, got %s", expectedString, bitstring); parcMemory_Deallocate(&bitstring); parcCryptoHash_Release(&hash); parcBuffer_Release(&buffer); parcSignature_Release(&signature); parcSigner_Release(&signer); }