unittest_curve_encoding.cpp

/* SPDX-License-Identifier: MPL-2.0 */

#include "../tests/testutil_unity.hpp"

// TODO: remove this ugly hack
#ifdef close
#undef close
#endif

#include <curve_mechanism_base.hpp>
#include <msg.hpp>
#include <random.hpp>

#include <unity.h>

#include <vector>

void setUp ()
{
}

void tearDown ()
{
}

void test_roundtrip (zmq::msg_t *msg_)
{
#ifdef ZMQ_HAVE_CURVE
    const std::vector<uint8_t> original (static_cast<uint8_t *> (msg_->data ()),
                                         static_cast<uint8_t *> (msg_->data ())
                                           + msg_->size ());

    zmq::curve_encoding_t encoding_client ("CurveZMQMESSAGEC",
                                           "CurveZMQMESSAGES", false);
    zmq::curve_encoding_t encoding_server ("CurveZMQMESSAGES",
                                           "CurveZMQMESSAGEC", false);

    uint8_t client_public[32];
    uint8_t client_secret[32];
    TEST_ASSERT_SUCCESS_ERRNO (
      crypto_box_keypair (client_public, client_secret));

    uint8_t server_public[32];
    uint8_t server_secret[32];
    TEST_ASSERT_SUCCESS_ERRNO (
      crypto_box_keypair (server_public, server_secret));

    TEST_ASSERT_SUCCESS_ERRNO (
      crypto_box_beforenm (encoding_client.get_writable_precom_buffer (),
                           server_public, client_secret));
    TEST_ASSERT_SUCCESS_ERRNO (
      crypto_box_beforenm (encoding_server.get_writable_precom_buffer (),
                           client_public, server_secret));

    TEST_ASSERT_SUCCESS_ERRNO (encoding_client.encode (msg_));

    // TODO: This is hacky...
    encoding_server.set_peer_nonce (0);
    int error_event_code;
    TEST_ASSERT_SUCCESS_ERRNO (
      encoding_server.decode (msg_, &error_event_code));

    TEST_ASSERT_EQUAL_INT (original.size (), msg_->size ());
    if (!original.empty ()) {
        TEST_ASSERT_EQUAL_UINT8_ARRAY (&original[0], msg_->data (),
                                       original.size ());
    }
#else
    LIBZMQ_UNUSED (msg_);
#endif
}

void test_roundtrip_empty ()
{
#ifndef ZMQ_HAVE_CURVE
    TEST_IGNORE_MESSAGE ("CURVE support is disabled");
#endif
    zmq::msg_t msg;
    msg.init ();

    test_roundtrip (&msg);

    msg.close ();
}

void test_roundtrip_small ()
{
#ifndef ZMQ_HAVE_CURVE
    TEST_IGNORE_MESSAGE ("CURVE support is disabled");
#endif
    zmq::msg_t msg;
    msg.init_size (32);
    memcpy (msg.data (), "0123456789ABCDEF0123456789ABCDEF", 32);

    test_roundtrip (&msg);

    msg.close ();
}

void test_roundtrip_large ()
{
#ifndef ZMQ_HAVE_CURVE
    TEST_IGNORE_MESSAGE ("CURVE support is disabled");
#endif
    zmq::msg_t msg;
    msg.init_size (2048);
    for (size_t pos = 0; pos < 2048; pos += 32) {
        memcpy (static_cast<char *> (msg.data ()) + pos,
                "0123456789ABCDEF0123456789ABCDEF", 32);
    }

    test_roundtrip (&msg);

    msg.close ();
}

void test_roundtrip_empty_more ()
{
#ifndef ZMQ_HAVE_CURVE
    TEST_IGNORE_MESSAGE ("CURVE support is disabled");
#endif
    zmq::msg_t msg;
    msg.init ();
    msg.set_flags (zmq::msg_t::more);

    test_roundtrip (&msg);
    TEST_ASSERT_TRUE (msg.flags () & zmq::msg_t::more);

    msg.close ();
}

int main ()
{
    setup_test_environment ();
    zmq::random_open ();

    UNITY_BEGIN ();

    RUN_TEST (test_roundtrip_empty);
    RUN_TEST (test_roundtrip_small);
    RUN_TEST (test_roundtrip_large);

    RUN_TEST (test_roundtrip_empty_more);

    zmq::random_close ();

    return UNITY_END ();
}