test_crypto.c File Reference

Unit Tests for crypto API. More...

#include "asterisk.h"
#include "asterisk/utils.h"
#include "asterisk/test.h"
#include "asterisk/crypto.h"
#include "asterisk/paths.h"
#include "asterisk/module.h"
#include "asterisk/file.h"
#include <assert.h>
#include <sys/stat.h>
#include <limits.h>
#include <openssl/evp.h>

Include dependency graph for test_crypto.c:

Go to the source code of this file.

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
struct ast_module *	AST_MODULE_SELF_SYM (void)
	AST_TEST_DEFINE (crypto_aes_decrypt)
	AST_TEST_DEFINE (crypto_aes_encrypt)
	AST_TEST_DEFINE (crypto_rsa_decrypt)
	AST_TEST_DEFINE (crypto_rsa_encrypt)
	AST_TEST_DEFINE (crypto_sign)
	AST_TEST_DEFINE (crypto_verify)
static char *	hexstring (const unsigned char *data, unsigned datalen)
static int	load_module (void)
static void	pop_key_dir (void)
static void	push_key_dir (const char *dir)
static int	unload_module (void)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_DEFAULT , .description = "Crypto test module" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .requires = "res_crypto", }
static const struct ast_module_info *	ast_module_info = &__mod_info
static const char *	keypair1 = "rsa_key1"
static const char *	old_key_dir = NULL

Detailed Description

Unit Tests for crypto API.

Author

Philip Prindeville phili.nosp@m.pp@r.nosp@m.edfis.nosp@m.h-so.nosp@m.lutio.nosp@m.ns.c.nosp@m.om

Definition in file test_crypto.c.

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 689 of file test_crypto.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 689 of file test_crypto.c.

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 689 of file test_crypto.c.

AST_TEST_DEFINE() [1/6]

AST_TEST_DEFINE

(

crypto_aes_decrypt

)

Definition at line 581 of file test_crypto.c.

{
    int res = AST_TEST_FAIL;
    const unsigned char key[16] = {
        0x01, 0x23, 0x45, 0x67, 0x89, 0x01, 0x23, 0x45,
        0x67, 0x89, 0x01, 0x23, 0x45, 0x67, 0x89, 0x01
    };
    const unsigned char plaintext[16] = "Mary had a littl";
    unsigned char buf[16];
    const char *command = "openssl";
    char *args[] = { "openssl", "enc", "-aes-128-ecb", "-e", "-K", "KEY", "-nopad", NULL };
    enum { KEY = 5 };
    struct ast_test_capture cap;
    ast_aes_encrypt_key aes_key;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "crypto_aes_decrypt";
        info->category = "/res/res_crypto/";
        info->summary = "Decrypt test AES-128-ECB";
        info->description = "Decrypt a test string using AES-128 and ECB";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    ast_test_status_update(test, "Executing AES-ECB decryption test\n");
 
    ast_test_capture_init(&cap);
 
    if (!ast_check_command_in_path(command)) {
        ast_test_status_update(test, "couldn't find %s\n", command);
        return res;
    }
 
    args[KEY] = hexstring(key, sizeof(key));
    if (ast_test_capture_command(&cap, command, args, (const char *)plaintext, sizeof(plaintext)) != 1) {
        ast_test_status_update(test, "ast_test_capture_command() failed\n");
        goto cleanup;
    }
 
    if (cap.outlen != sizeof(buf)) {
        ast_test_status_update(test, "Unexpected length for stdout: %zu\n", cap.outlen);
        goto cleanup;
    }
 
    if (cap.errlen != 0) {
        ast_test_status_update(test, "Unexpected value/length for stderr: '%.*s'\n", (int) cap.errlen, cap.errbuf);
        goto cleanup;
    }
 
    if (cap.pid == -1) {
        ast_test_status_update(test, "Invalid process id\n");
        goto cleanup;
    }
 
    if (cap.exitcode != 0) {
        ast_test_status_update(test, "Child exited %d\n", cap.exitcode);
        goto cleanup;
    }
 
    memset(buf, 0, sizeof(buf));
    ast_aes_set_decrypt_key(key, &aes_key);
    if (ast_aes_decrypt((const unsigned char *)cap.outbuf, buf, &aes_key) <= 0) {
        ast_test_status_update(test, "ast_aes_decrypt() failed\n");
        goto cleanup;
    }
 
    if (memcmp(plaintext, buf, sizeof(plaintext))) {
        ast_test_status_update(test, "AES decryption mismatch\n");
        goto cleanup;
    }
 
    res = AST_TEST_PASS;
 
cleanup:
    ast_free(args[KEY]);
    ast_test_capture_free(&cap);
    return res;
}

References args, ast_aes_decrypt(), ast_aes_set_decrypt_key(), ast_check_command_in_path(), ast_free, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, buf, cleanup(), ast_test_capture::errbuf, ast_test_capture::errlen, ast_test_capture::exitcode, hexstring(), KEY, NULL, ast_test_capture::outbuf, ast_test_capture::outlen, ast_test_capture::pid, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [2/6]

AST_TEST_DEFINE

(

crypto_aes_encrypt

)

Definition at line 505 of file test_crypto.c.

{
    int res = AST_TEST_FAIL;
    const unsigned char key[16] = {
        0x01, 0x23, 0x45, 0x67, 0x89, 0x01, 0x23, 0x45,
        0x67, 0x89, 0x01, 0x23, 0x45, 0x67, 0x89, 0x01
    };
    const unsigned char plaintext[16] = "Mary had a littl";
    const char *command = "openssl";
    char *args[] = { "openssl", "enc", "-aes-128-ecb", "-d", "-K", "KEY", "-nopad", NULL };
    enum { KEY = 5 };
    struct ast_test_capture cap;
    unsigned char buf[16];
    ast_aes_encrypt_key aes_key;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "crypto_aes_encrypt";
        info->category = "/res/res_crypto/";
        info->summary = "Encrypt test AES-128-ECB";
        info->description = "Encrypt a test string using AES-128 and ECB";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    ast_test_status_update(test, "Executing AES-ECB encryption test\n");
 
    ast_test_capture_init(&cap);
 
    if (!ast_check_command_in_path(command)) {
        ast_test_status_update(test, "couldn't find %s\n", command);
        return res;
    }
 
    memset(buf, 0, sizeof(buf));
    ast_aes_set_encrypt_key(key, &aes_key);
    if (ast_aes_encrypt(plaintext, buf, &aes_key) <= 0) {
        ast_test_status_update(test, "ast_aes_encrypt() failed\n");
        goto cleanup;
    }
 
    args[KEY] = hexstring(key, sizeof(key));
    if (ast_test_capture_command(&cap, command, args, (const char *)buf, sizeof(buf)) != 1) {
        ast_test_status_update(test, "ast_test_capture_command() failed\n");
        goto cleanup;
    }
 
    if (cap.outlen != sizeof(plaintext) || memcmp(cap.outbuf, plaintext, cap.outlen)) {
        ast_test_status_update(test, "Unexpected value/length for stdout: '%.*s' (%zu)\n", (int) cap.outlen, cap.outbuf, cap.outlen);
        goto cleanup;
    }
 
    if (cap.errlen != 0) {
        ast_test_status_update(test, "Unexpected value/length for stderr: '%.*s'\n", (int) cap.errlen, cap.errbuf);
        goto cleanup;
    }
 
    if (cap.pid == -1) {
        ast_test_status_update(test, "Invalid process id\n");
        goto cleanup;
    }
 
    if (cap.exitcode != 0) {
        ast_test_status_update(test, "Child exited %d\n", cap.exitcode);
        goto cleanup;
    }
 
    res = AST_TEST_PASS;
 
cleanup:
    ast_free(args[KEY]);
    ast_test_capture_free(&cap);
    return res;
}

References args, ast_aes_encrypt(), ast_aes_set_encrypt_key(), ast_check_command_in_path(), ast_free, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, buf, cleanup(), ast_test_capture::errbuf, ast_test_capture::errlen, ast_test_capture::exitcode, hexstring(), KEY, NULL, ast_test_capture::outbuf, ast_test_capture::outlen, ast_test_capture::pid, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [3/6]

AST_TEST_DEFINE

(

crypto_rsa_decrypt

)

Definition at line 179 of file test_crypto.c.

{
    int res = AST_TEST_FAIL;
    struct ast_key *key = NULL;
    const unsigned char plaintext[23] = "Mary had a little lamb.";
    char wd[PATH_MAX], key_dir[PATH_MAX], pub[PATH_MAX];
    unsigned char buf[AST_CRYPTO_RSA_KEY_BITS / 8];
    const char *command = "openssl";
    char *args[] = { "openssl", "pkeyutl", "-encrypt", "-pubin", "-inkey", "PUBLIC", "-pkeyopt", "rsa_padding_mode:oaep", NULL };
    enum { PUBLIC = 5 };
    struct ast_test_capture cap;
    int len;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "crypto_decrypt_pub_key";
        info->category = "/res/res_crypto/";
        info->summary = "Decrypt w/ RSA public key";
        info->description = "Decrypt string with RSA private key";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    ast_test_status_update(test, "Executing RSA decryption test\n");
 
    ast_test_capture_init(&cap);
 
    if (!ast_check_command_in_path(command)) {
        ast_test_status_update(test, "couldn't find %s\n", command);
        ast_test_capture_free(&cap);
        return res;
    }
 
    if (getcwd(wd, sizeof(wd)) == NULL) {
        ast_test_status_update(test, "Could not determine current working directory\n");
        ast_test_capture_free(&cap);
        return res;
    }
 
    snprintf(key_dir, sizeof(key_dir), "%s/%s", wd, "tests/keys");
    push_key_dir((const char *)key_dir);
    snprintf(pub, sizeof(pub), "%s/%s.pub", key_dir, keypair1);
 
    if (ast_crypto_reload() != 1) {
        ast_test_status_update(test, "Couldn't force crypto reload\n");
        goto cleanup;
    }
 
    key = ast_key_get(keypair1, AST_KEY_PRIVATE);
 
    if (!key) {
        ast_test_status_update(test, "Couldn't read key: %s\n", keypair1);
        goto cleanup;
    }
 
    args[PUBLIC] = pub;
    if (ast_test_capture_command(&cap, command, args, (const char *)plaintext, sizeof(plaintext)) != 1) {
        ast_test_status_update(test, "ast_test_capture_command() failed\n");
        goto cleanup;
    }
 
    if (cap.outlen != sizeof(buf)) {
        ast_test_status_update(test, "Unexpected length for stdout: %zu\n", cap.outlen);
        goto cleanup;
    }
 
    if (cap.errlen != 0) {
        ast_test_status_update(test, "Unexpected value/length for stderr: '%.*s' (%zu)\n", (int) cap.errlen, cap.errbuf, cap.errlen);
        goto cleanup;
    }
 
    if (cap.pid == -1) {
        ast_test_status_update(test, "Invalid process id\n");
        goto cleanup;
    }
 
    if (cap.exitcode != 0) {
        ast_test_status_update(test, "Child exited %d\n", cap.exitcode);
        goto cleanup;
    }
 
    memset(buf, 0, sizeof(buf));
    len = ast_decrypt_bin(buf, (unsigned char *)cap.outbuf, cap.outlen, key);
 
    if (len != sizeof(plaintext) || memcmp(buf, plaintext, len)) {
        ast_test_status_update(test, "Unexpected value for decrypted text\n");
        goto cleanup;
    }
 
    res = AST_TEST_PASS;
 
cleanup:
    ast_test_capture_free(&cap);
    pop_key_dir();
    return res;
}

References args, ast_check_command_in_path(), ast_crypto_reload(), AST_CRYPTO_RSA_KEY_BITS, ast_decrypt_bin(), ast_key_get(), AST_KEY_PRIVATE, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, buf, cleanup(), ast_test_capture::errbuf, ast_test_capture::errlen, ast_test_capture::exitcode, keypair1, len(), NULL, ast_test_capture::outbuf, ast_test_capture::outlen, PATH_MAX, ast_test_capture::pid, pop_key_dir(), push_key_dir(), TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [4/6]

AST_TEST_DEFINE

(

crypto_rsa_encrypt

)

Definition at line 84 of file test_crypto.c.

{
    int res = AST_TEST_FAIL;
    struct ast_key *key = NULL;
    const unsigned char plaintext[23] = "Mary had a little lamb.";
    char wd[PATH_MAX], key_dir[PATH_MAX], priv[PATH_MAX];
    unsigned char buf[AST_CRYPTO_RSA_KEY_BITS / 8];
    const char *command = "openssl";
    char *args[] = { "openssl", "pkeyutl", "-decrypt", "-inkey", "PRIVATE", "-pkeyopt", "rsa_padding_mode:oaep", NULL };
    enum { PRIVATE = 4 };
    struct ast_test_capture cap;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "crypto_rsa_encrypt";
        info->category = "/res/res_crypto/";
        info->summary = "Encrypt w/ RSA public key";
        info->description = "Encrypt string with RSA public key";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    ast_test_status_update(test, "Executing RSA encryption test\n");
 
    ast_test_capture_init(&cap);
 
    if (!ast_check_command_in_path(command)) {
        ast_test_status_update(test, "couldn't find %s\n", command);
        ast_test_capture_free(&cap);
        return res;
    }
 
    if (getcwd(wd, sizeof(wd)) == NULL) {
        ast_test_status_update(test, "Could not determine current working directory\n");
        ast_test_capture_free(&cap);
        return res;
    }
 
    snprintf(key_dir, sizeof(key_dir), "%s/%s", wd, "tests/keys");
    push_key_dir((const char *)key_dir);
    snprintf(priv, sizeof(priv), "%s/%s.key", key_dir, keypair1);
 
    /* because git doesn't preserve permissions */
    (void)chmod(priv, 0400);
 
    if (ast_crypto_reload() != 1) {
        ast_test_status_update(test, "Couldn't force crypto reload\n");
        goto cleanup;
    }
 
    key = ast_key_get(keypair1, AST_KEY_PUBLIC);
 
    if (!key) {
        ast_test_status_update(test, "Couldn't read key: %s\n", keypair1);
        goto cleanup;
    }
 
    memset(buf, 0, sizeof(buf));
    ast_encrypt_bin(buf, plaintext, sizeof(plaintext), key);
 
    args[PRIVATE] = priv;
    if (ast_test_capture_command(&cap, command, args, (const char *)buf, sizeof(buf)) != 1) {
        ast_test_status_update(test, "ast_test_capture_command() failed\n");
        goto cleanup;
    }
 
    if (cap.outlen != sizeof(plaintext) || memcmp(cap.outbuf, plaintext, cap.outlen)) {
        ast_test_status_update(test, "Unexpected value/length for stdout: '%.*s' (%zu)\n", (int) cap.outlen, cap.outbuf, cap.outlen);
        goto cleanup;
    }
 
    if (cap.errlen != 0) {
        ast_test_status_update(test, "Unexpected length for stderr: '%.*s' (%zu)\n", (int) cap.errlen, cap.errbuf, cap.errlen);
        goto cleanup;
    }
 
    if (cap.pid == -1) {
        ast_test_status_update(test, "Invalid process id\n");
        goto cleanup;
    }
 
    if (cap.exitcode != 0) {
        ast_test_status_update(test, "Child exited %d\n", cap.exitcode);
        goto cleanup;
    }
 
    res = AST_TEST_PASS;
 
cleanup:
    ast_test_capture_free(&cap);
    pop_key_dir();
    return res;
}

References args, ast_check_command_in_path(), ast_crypto_reload(), AST_CRYPTO_RSA_KEY_BITS, ast_encrypt_bin(), ast_key_get(), AST_KEY_PUBLIC, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, buf, cleanup(), ast_test_capture::errbuf, ast_test_capture::errlen, ast_test_capture::exitcode, keypair1, NULL, ast_test_capture::outbuf, ast_test_capture::outlen, PATH_MAX, ast_test_capture::pid, pop_key_dir(), push_key_dir(), TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [5/6]

AST_TEST_DEFINE

(

crypto_sign

)

Definition at line 277 of file test_crypto.c.

{
    int res = AST_TEST_FAIL;
    struct ast_key *key = NULL;
    const char plaintext[23] = "Mary had a little lamb.";
    char wd[PATH_MAX], key_dir[PATH_MAX], pub[PATH_MAX];
    unsigned char buf[AST_CRYPTO_RSA_KEY_BITS / 8];
    const char *command = "openssl";
    char *args[] = { "openssl", "pkeyutl", "-verify", "-inkey", "PUBLIC", "-pubin", "-sigfile", "SIGNATURE", "-pkeyopt", "digest:sha1", NULL };
    enum { PUBLIC = 4, SIGNATURE = 7 };
    struct ast_test_capture cap;
    unsigned char digest[20];
    unsigned digestlen;
    EVP_MD_CTX *ctx;
    FILE *fsig = NULL;
    char signpath[64] = "/tmp/signingXXXXXX";
    const char success[] = "Signature Verified Successfully\n";
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "crypto_sign";
        info->category = "/res/res_crypto/";
        info->summary = "Sign w/ RSA private key";
        info->description = "Sign string with RSA private key";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    ast_test_status_update(test, "Executing RSA signing test\n");
 
    ast_test_capture_init(&cap);
 
    if (!ast_check_command_in_path(command)) {
        ast_test_status_update(test, "couldn't find %s\n", command);
        ast_test_capture_free(&cap);
        return res;
    }
 
    if (getcwd(wd, sizeof(wd)) == NULL) {
        ast_test_status_update(test, "Could not determine current working directory\n");
        ast_test_capture_free(&cap);
        return res;
    }
 
    snprintf(key_dir, sizeof(key_dir), "%s/%s", wd, "tests/keys");
    push_key_dir((const char *)key_dir);
    snprintf(pub, sizeof(pub), "%s/%s.pub", key_dir, keypair1);
 
    ctx = EVP_MD_CTX_create();
    EVP_DigestInit(ctx, EVP_sha1());
    EVP_DigestUpdate(ctx, plaintext, sizeof(plaintext));
    EVP_DigestFinal(ctx, digest, &digestlen);
    EVP_MD_CTX_destroy(ctx);
    ctx = NULL;
 
    if (ast_crypto_reload() != 1) {
        ast_test_status_update(test, "Couldn't force crypto reload\n");
        goto cleanup;
    }
 
    key = ast_key_get(keypair1, AST_KEY_PRIVATE);
 
    if (!key) {
        ast_test_status_update(test, "Couldn't read key: %s\n", keypair1);
        goto cleanup;
    }
 
    memset(buf, 0, sizeof(buf));
    if (ast_sign_bin(key, plaintext, sizeof(plaintext), buf) != 0) {
        ast_test_status_update(test, "ast_sign_bin() failed\n");
        goto cleanup;
    }
 
    fsig = ast_file_mkftemp(signpath, 0600);
    if (fsig == NULL) {
        ast_test_status_update(test, "Couldn't open temp signing file\n");
        goto cleanup;
    }
    fwrite(buf, sizeof(char), sizeof(buf), fsig);
    fclose(fsig);
    fsig = NULL;
 
    args[PUBLIC] = pub;
    args[SIGNATURE] = signpath;
    if (ast_test_capture_command(&cap, command, args, (const char *)digest, digestlen) != 1) {
        ast_test_status_update(test, "ast_test_capture_command() failed\n");
        goto cleanup;
    }
 
    if (cap.outlen != sizeof(success) - 1 || memcmp(cap.outbuf, success, cap.outlen)) {
        ast_test_status_update(test, "Unexpected value/length for stdout: '%.*s' (%zu)\n", (int) cap.outlen, cap.outbuf, cap.outlen);
        goto cleanup;
    }
 
    if (cap.errlen != 0) {
        ast_test_status_update(test, "Unexpected value for stderr: '%.*s' (%zu)\n", (int) cap.errlen, cap.errbuf, cap.errlen);
        goto cleanup;
    }
 
    if (cap.pid == -1) {
        ast_test_status_update(test, "Invalid process id\n");
        goto cleanup;
    }
 
#if OPENSSL_VERSION_NUMBER >= 0x10100000L
    if (cap.exitcode != 0) {
#else
    if (cap.exitcode != 0 && cap.exitcode != 1) {
#endif
        ast_test_status_update(test, "Child exited %d\n", cap.exitcode);
        goto cleanup;
    }
 
    res = AST_TEST_PASS;
 
cleanup:
    ast_test_capture_free(&cap);
    unlink(signpath);
    pop_key_dir();
    return res;
}

References args, ast_check_command_in_path(), ast_crypto_reload(), AST_CRYPTO_RSA_KEY_BITS, ast_file_mkftemp(), ast_key_get(), AST_KEY_PRIVATE, ast_sign_bin(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, buf, cleanup(), ast_test_capture::errbuf, ast_test_capture::errlen, ast_test_capture::exitcode, keypair1, NULL, ast_test_capture::outbuf, ast_test_capture::outlen, PATH_MAX, ast_test_capture::pid, pop_key_dir(), push_key_dir(), TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [6/6]

AST_TEST_DEFINE

(

crypto_verify

)

Definition at line 400 of file test_crypto.c.

{
    int res = AST_TEST_FAIL;
    struct ast_key *key = NULL;
    const char plaintext[23] = "Mary had a little lamb.";
    char wd[PATH_MAX], key_dir[PATH_MAX], priv[PATH_MAX];
    const char *command = "openssl";
    char *args[] = { "openssl", "pkeyutl", "-sign", "-inkey", "PRIVATE", "-pkeyopt", "digest:sha1", NULL };
    enum { PRIVATE = 4 };
    struct ast_test_capture cap;
    unsigned char digest[20];
    unsigned digestlen;
    EVP_MD_CTX *ctx;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "crypto_verify";
        info->category = "/res/res_crypto/";
        info->summary = "Verify w/ RSA public key";
        info->description = "Verify signature with RSA public key";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    ast_test_status_update(test, "Executing RSA signature verification test\n");
 
    ast_test_capture_init(&cap);
 
    if (!ast_check_command_in_path(command)) {
        ast_test_status_update(test, "couldn't find %s\n", command);
        ast_test_capture_free(&cap);
        return res;
    }
 
    if (getcwd(wd, sizeof(wd)) == NULL) {
        ast_test_status_update(test, "Could not determine current working directory\n");
        ast_test_capture_free(&cap);
        return res;
    }
 
    snprintf(key_dir, sizeof(key_dir), "%s/%s", wd, "tests/keys");
    push_key_dir((const char *)key_dir);
    snprintf(priv, sizeof(priv), "%s/%s.key", key_dir, keypair1);
 
    /* because git doesn't preserve permissions */
    (void)chmod(priv, 0400);
 
    if (ast_crypto_reload() != 1) {
        ast_test_status_update(test, "Couldn't force crypto reload\n");
        goto cleanup;
    }
 
    key = ast_key_get(keypair1, AST_KEY_PUBLIC);
 
    if (!key) {
        ast_test_status_update(test, "Couldn't read key: %s\n", keypair1);
        goto cleanup;
    }
 
    ctx = EVP_MD_CTX_create();
    EVP_DigestInit(ctx, EVP_sha1());
    EVP_DigestUpdate(ctx, plaintext, sizeof(plaintext));
    EVP_DigestFinal(ctx, digest, &digestlen);
    EVP_MD_CTX_destroy(ctx);
 
    args[PRIVATE] = priv;
    if (ast_test_capture_command(&cap, command, args, (const char *)digest, sizeof(digest)) != 1) {
        ast_test_status_update(test, "ast_test_capture_command() failed\n");
        goto cleanup;
    }
 
    if (cap.outlen != (AST_CRYPTO_RSA_KEY_BITS / 8)) {
        ast_test_status_update(test, "Unexpected length for stdout: %zu\n", cap.outlen);
        goto cleanup;
    }
 
    if (cap.errlen != 0) {
        ast_test_status_update(test, "Unexpected value/length for stderr: '%.*s'\n", (int) cap.errlen, cap.errbuf);
        goto cleanup;
    }
 
    if (cap.pid == -1) {
        ast_test_status_update(test, "Invalid process id\n");
        goto cleanup;
    }
 
    if (cap.exitcode != 0) {
        ast_test_status_update(test, "Child exited %d\n", cap.exitcode);
        goto cleanup;
    }
 
    if (ast_check_signature_bin(key, plaintext, sizeof(plaintext), (const unsigned char *)cap.outbuf) != 0) {
        ast_test_status_update(test, "ast_check_signature_bin() failed\n");
        goto cleanup;
    }
 
    res = AST_TEST_PASS;
 
cleanup:
    ast_test_capture_free(&cap);
    pop_key_dir();
    return res;
}

References args, ast_check_command_in_path(), ast_check_signature_bin(), ast_crypto_reload(), AST_CRYPTO_RSA_KEY_BITS, ast_key_get(), AST_KEY_PUBLIC, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, cleanup(), ast_test_capture::errbuf, ast_test_capture::errlen, ast_test_capture::exitcode, keypair1, NULL, ast_test_capture::outbuf, ast_test_capture::outlen, PATH_MAX, ast_test_capture::pid, pop_key_dir(), push_key_dir(), TEST_EXECUTE, and TEST_INIT.

hexstring()

static char * hexstring ( const unsigned char *  data, unsigned  datalen  )

static

Definition at line 51 of file test_crypto.c.

{
    char *buf = ast_malloc(datalen * 2 + 1);
    unsigned n;
 
    for (n = 0; n < datalen; ++n) {
        snprintf(&buf[n * 2], 3, "%02x", data[n]);
    }
    buf[datalen * 2] = '\0';
 
    return buf;
}

References ast_malloc, and buf.

Referenced by AST_TEST_DEFINE(), and AST_TEST_DEFINE().

load_module()

static int load_module ( void  )

static

Definition at line 673 of file test_crypto.c.

{
    AST_TEST_REGISTER(crypto_rsa_encrypt);
    AST_TEST_REGISTER(crypto_rsa_decrypt);
    AST_TEST_REGISTER(crypto_sign);
    AST_TEST_REGISTER(crypto_verify);
    AST_TEST_REGISTER(crypto_aes_encrypt);
    AST_TEST_REGISTER(crypto_aes_decrypt);
    return AST_MODULE_LOAD_SUCCESS;
}

References AST_MODULE_LOAD_SUCCESS, and AST_TEST_REGISTER.

pop_key_dir()

static void pop_key_dir ( void  )

static

Definition at line 73 of file test_crypto.c.

{
    assert(old_key_dir != NULL);
 
    ast_free((char *)ast_config_AST_KEY_DIR);
 
    ast_config_AST_KEY_DIR = old_key_dir;
 
    old_key_dir = NULL;
}

References ast_config_AST_KEY_DIR, ast_free, NULL, and old_key_dir.

Referenced by AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), and AST_TEST_DEFINE().

push_key_dir()

static void push_key_dir ( const char *  dir )

static

Definition at line 64 of file test_crypto.c.

{
    assert(old_key_dir == NULL);
 
    old_key_dir = ast_config_AST_KEY_DIR;
 
    ast_config_AST_KEY_DIR = ast_strdup(dir);
}

References ast_config_AST_KEY_DIR, ast_strdup, NULL, and old_key_dir.

Referenced by AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), and AST_TEST_DEFINE().

unload_module()

static int unload_module ( void  )

static

Definition at line 662 of file test_crypto.c.

{
    AST_TEST_UNREGISTER(crypto_rsa_encrypt);
    AST_TEST_UNREGISTER(crypto_rsa_decrypt);
    AST_TEST_UNREGISTER(crypto_sign);
    AST_TEST_UNREGISTER(crypto_verify);
    AST_TEST_UNREGISTER(crypto_aes_encrypt);
    AST_TEST_UNREGISTER(crypto_aes_decrypt);
    return 0;
}

References AST_TEST_UNREGISTER.

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_DEFAULT , .description = "Crypto test module" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .requires = "res_crypto", }

static

Definition at line 689 of file test_crypto.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 689 of file test_crypto.c.

keypair1

const char* keypair1 = "rsa_key1"

static

Definition at line 47 of file test_crypto.c.

Referenced by AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), and AST_TEST_DEFINE().

old_key_dir

const char* old_key_dir = NULL

static

Definition at line 49 of file test_crypto.c.

Referenced by pop_key_dir(), and push_key_dir().