C++ (Cpp) parcSignature_GetSignature Examples

Example #1

File: test_parc_Signature.c Project: isolis/Libparc

LONGBOW_TEST_CASE(Global, parcSignature_GetSignature)
{
    PARCBuffer *expected = parcBuffer_Allocate(strlen("Hello"));
    parcBuffer_PutArray(expected, strlen("Hello"), (uint8_t *) "Hello");
    PARCSignature *signature = parcSignature_Create(PARCSigningAlgorithm_DSA, PARC_HASH_SHA256, expected);

    PARCBuffer *actual = parcSignature_GetSignature(signature);

    assertTrue(parcBuffer_Equals(expected, actual), "Expected the original signature bits to be equal to the actual bits");
    parcSignature_Release(&signature);
    parcBuffer_Release(&expected);
}

Example #2

File: parc_InMemoryVerifier.c Project: isolis/Libparc

/**
 * Return if the signature and key verify with the local hash.
 *
 * PRECONDITION:
 *  - You know the signature and key are RSA.
 *
 * Example:
 * @code
 * <#example#>
 * @endcode
 */
static bool
_parcInMemoryVerifier_RSAKey_Verify(PARCInMemoryVerifier *verifier, PARCCryptoHash *localHash,
                                    PARCSignature *signatureToVerify, PARCBuffer *derEncodedKey)
{
    const uint8_t *der_bytes = parcByteArray_Array(parcBuffer_Array(derEncodedKey));

    long der_length = parcBuffer_Remaining(derEncodedKey);
    EVP_PKEY *unwrapped_key = d2i_PUBKEY(NULL, &der_bytes, der_length);

    if (unwrapped_key != NULL) {
        int success = 0;
        RSA *rsa = EVP_PKEY_get1_RSA(unwrapped_key);

        if (rsa != NULL) {
            int openssl_digest_type;

            switch (parcCryptoHash_GetDigestType(localHash)) {
                case PARC_HASH_SHA256:
                    openssl_digest_type = NID_sha256;
                    break;
                case PARC_HASH_SHA512:
                    openssl_digest_type = NID_sha512;
                    break;
                default:
                    trapUnexpectedState("Unknown digest type: %s",
                                        parcCryptoHashType_ToString(parcCryptoHash_GetDigestType(localHash)));
            }

            PARCBuffer *sigbits = parcSignature_GetSignature(signatureToVerify);
            PARCByteArray *bytearray = parcBuffer_Array(sigbits);
            unsigned signatureLength = (unsigned) parcBuffer_Remaining(sigbits);
            uint8_t *sigbuffer = parcByteArray_Array(bytearray);
            size_t signatureOffset = parcBuffer_ArrayOffset(sigbits);

            success = RSA_verify(openssl_digest_type,
                                 (unsigned char *) parcByteArray_Array(parcBuffer_Array(parcCryptoHash_GetDigest(localHash))),
                                 (unsigned) parcBuffer_Remaining(parcCryptoHash_GetDigest(localHash)),
                                 sigbuffer + signatureOffset,
                                 signatureLength,
                                 rsa);
            RSA_free(rsa);
        }
        EVP_PKEY_free(unwrapped_key);

        if (success) {
            return true;
        }
    }
    return false;
}

Example #3

File: test_parc_Signer.c Project: PARC/Libparc

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);
}