3party/libzmq
0
0
Fork 0
mirror of https://github.com/zeromq/libzmq.git synced 2025-03-10 16:06:09 +00:00
Code Issues Packages Projects Releases Wiki Activity

Problem: test_security_plain not using a test framework

Browse Source 
Solution: migrate to Unity
This commit is contained in:
Simon Giesecke 2019-03-16 17:51:25 +01:00
parent 223ef516b6
commit 36a16ec7d1
2 changed files with 128 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Makefile.am
View File

@ -608,7 +608,8 @@ tests_test_security_null_LDADD = src/libzmq.la ${UNITY_LIBS}
tests_test_security_null_CPPFLAGS = ${UNITY_CPPFLAGS} tests_test_security_null_CPPFLAGS = ${UNITY_CPPFLAGS}
tests_test_security_plain_SOURCES = tests/test_security_plain.cpp tests_test_security_plain_SOURCES = tests/test_security_plain.cpp
tests_test_security_plain_LDADD = src/libzmq.la tests_test_security_plain_LDADD = src/libzmq.la ${UNITY_LIBS}
tests_test_security_plain_CPPFLAGS = ${UNITY_CPPFLAGS}
tests_test_security_zap_SOURCES = \ tests_test_security_zap_SOURCES = \
tests/test_security_zap.cpp \ tests/test_security_zap.cpp \

228
tests/test_security_plain.cpp
View File

@ -28,6 +28,8 @@
*/ */
#include "testutil.hpp" #include "testutil.hpp"
#include "testutil_unity.hpp"
#if defined(ZMQ_HAVE_WINDOWS) #if defined(ZMQ_HAVE_WINDOWS)
#include <winsock2.h> #include <winsock2.h>
#include <ws2tcpip.h> #include <ws2tcpip.h>
@ -40,43 +42,37 @@
#include <unistd.h> #include <unistd.h>
#endif #endif
static void zap_handler (void *ctx_) static void zap_handler (void *zap_)
{ {
// Create and bind ZAP socket
void *zap = zmq_socket (ctx_, ZMQ_REP);
assert (zap);
int rc = zmq_bind (zap, "inproc://zeromq.zap.01");
assert (rc == 0);
// Process ZAP requests forever // Process ZAP requests forever
while (true) { while (true) {
char *version = s_recv (zap); char *version = s_recv (zap_);
if (!version) if (!version)
break; // Terminating break; // Terminating
char *sequence = s_recv (zap); char *sequence = s_recv (zap_);
char *domain = s_recv (zap); char *domain = s_recv (zap_);
char *address = s_recv (zap); char *address = s_recv (zap_);
char *routing_id = s_recv (zap); char *routing_id = s_recv (zap_);
char *mechanism = s_recv (zap); char *mechanism = s_recv (zap_);
char *username = s_recv (zap); char *username = s_recv (zap_);
char *password = s_recv (zap); char *password = s_recv (zap_);
assert (streq (version, "1.0")); assert (streq (version, "1.0"));
assert (streq (mechanism, "PLAIN")); assert (streq (mechanism, "PLAIN"));
assert (streq (routing_id, "IDENT")); assert (streq (routing_id, "IDENT"));
s_sendmore (zap, version); s_sendmore (zap_, version);
s_sendmore (zap, sequence); s_sendmore (zap_, sequence);
if (streq (username, "admin") && streq (password, "password")) { if (streq (username, "admin") && streq (password, "password")) {
s_sendmore (zap, "200"); s_sendmore (zap_, "200");
s_sendmore (zap, "OK"); s_sendmore (zap_, "OK");
s_sendmore (zap, "anonymous"); s_sendmore (zap_, "anonymous");
s_send (zap, ""); s_send (zap_, "");
} else { } else {
s_sendmore (zap, "400"); s_sendmore (zap_, "400");
s_sendmore (zap, "Invalid username or password"); s_sendmore (zap_, "Invalid username or password");
s_sendmore (zap, ""); s_sendmore (zap_, "");
s_send (zap, ""); s_send (zap_, "");
} }
free (version); free (version);
free (sequence); free (sequence);
@ -87,94 +83,121 @@ static void zap_handler (void *ctx_)
free (username); free (username);
free (password); free (password);
} }
rc = zmq_close (zap); int rc = zmq_close (zap_);
assert (rc == 0); assert (rc == 0);
} }
int main (void) void *zap_thread;
char my_endpoint[MAX_SOCKET_STRING];
static void setup_zap_handler ()
{ {
setup_test_environment ();
size_t len = MAX_SOCKET_STRING;
char my_endpoint[MAX_SOCKET_STRING];
void *ctx = zmq_ctx_new ();
assert (ctx);
// Spawn ZAP handler // Spawn ZAP handler
void *zap_thread = zmq_threadstart (&zap_handler, ctx); // We create and bind ZAP socket in main thread to avoid case
// where child thread does not start up fast enough.
void *handler = zmq_socket (get_test_context (), ZMQ_REP);
TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (handler, "inproc://zeromq.zap.01"));
zap_thread = zmq_threadstart (&zap_handler, handler);
}
static void teardown_zap_handler ()
{
// Wait until ZAP handler terminates
zmq_threadclose (zap_thread);
}
const char domain[] = "test";
void *server;
static void setup_server ()
{
// Server socket will accept connections // Server socket will accept connections
void *server = zmq_socket (ctx, ZMQ_DEALER); server = test_context_socket (ZMQ_DEALER);
assert (server); TEST_ASSERT_SUCCESS_ERRNO (
int rc = zmq_setsockopt (server, ZMQ_ROUTING_ID, "IDENT", 6); zmq_setsockopt (server, ZMQ_ROUTING_ID, "IDENT", 6));
const char domain[] = "test"; TEST_ASSERT_SUCCESS_ERRNO (
assert (rc == 0); zmq_setsockopt (server, ZMQ_ZAP_DOMAIN, domain, strlen (domain)));
rc = zmq_setsockopt (server, ZMQ_ZAP_DOMAIN, domain, strlen (domain)); const int as_server = 1;
assert (rc == 0); TEST_ASSERT_SUCCESS_ERRNO (
int as_server = 1; zmq_setsockopt (server, ZMQ_PLAIN_SERVER, &as_server, sizeof (int)));
rc = zmq_setsockopt (server, ZMQ_PLAIN_SERVER, &as_server, sizeof (int)); bind_loopback_ipv4 (server, my_endpoint, sizeof my_endpoint);
assert (rc == 0); }
rc = zmq_bind (server, "tcp://127.0.0.1:*");
assert (rc == 0);
rc = zmq_getsockopt (server, ZMQ_LAST_ENDPOINT, my_endpoint, &len);
assert (rc == 0);
char username[256]; static void teardown_server ()
char password[256]; {
test_context_socket_close (server);
}
void setUp ()
{
setup_test_context ();
setup_zap_handler ();
setup_server ();
}
void tearDown ()
{
teardown_server ();
teardown_test_context ();
teardown_zap_handler ();
}
void test_plain_success ()
{
// Check PLAIN security with correct username/password // Check PLAIN security with correct username/password
void *client = zmq_socket (ctx, ZMQ_DEALER); void *client = test_context_socket (ZMQ_DEALER);
assert (client); const char username[] = "admin";
strcpy (username, "admin"); TEST_ASSERT_SUCCESS_ERRNO (
rc = zmq_setsockopt (client, ZMQ_PLAIN_USERNAME, username, strlen (username)));
zmq_setsockopt (client, ZMQ_PLAIN_USERNAME, username, strlen (username)); const char password[] = "password";
assert (rc == 0); TEST_ASSERT_SUCCESS_ERRNO (
strcpy (password, "password"); zmq_setsockopt (client, ZMQ_PLAIN_PASSWORD, password, strlen (password)));
rc = TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (client, my_endpoint));
zmq_setsockopt (client, ZMQ_PLAIN_PASSWORD, password, strlen (password));
assert (rc == 0);
rc = zmq_connect (client, my_endpoint);
assert (rc == 0);
bounce (server, client); bounce (server, client);
rc = zmq_close (client); test_context_socket_close (client);
assert (rc == 0); }
void test_plain_client_as_server_fails ()
{
// Check PLAIN security with badly configured client (as_server) // Check PLAIN security with badly configured client (as_server)
// This will be caught by the plain_server class, not passed to ZAP // This will be caught by the plain_server class, not passed to ZAP
client = zmq_socket (ctx, ZMQ_DEALER); void *client = test_context_socket (ZMQ_DEALER);
assert (client); TEST_ASSERT_SUCCESS_ERRNO (
as_server = 1; zmq_setsockopt (client, ZMQ_ZAP_DOMAIN, domain, strlen (domain)));
rc = zmq_setsockopt (client, ZMQ_ZAP_DOMAIN, domain, strlen (domain)); const int as_server = 1;
assert (rc == 0); TEST_ASSERT_SUCCESS_ERRNO (
rc = zmq_setsockopt (client, ZMQ_PLAIN_SERVER, &as_server, sizeof (int)); zmq_setsockopt (client, ZMQ_PLAIN_SERVER, &as_server, sizeof (int)));
assert (rc == 0); TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (client, my_endpoint));
rc = zmq_connect (client, my_endpoint);
assert (rc == 0);
expect_bounce_fail (server, client); expect_bounce_fail (server, client);
close_zero_linger (client); test_context_socket_close_zero_linger (client);
}
void test_plain_wrong_credentials_fails ()
{
// Check PLAIN security -- failed authentication // Check PLAIN security -- failed authentication
client = zmq_socket (ctx, ZMQ_DEALER); void *client = test_context_socket (ZMQ_DEALER);
assert (client); const char username[] = "wronguser";
strcpy (username, "wronguser"); const char password[] = "wrongpass";
strcpy (password, "wrongpass"); TEST_ASSERT_SUCCESS_ERRNO (
rc = zmq_setsockopt (client, ZMQ_PLAIN_USERNAME, username, strlen (username)));
zmq_setsockopt (client, ZMQ_PLAIN_USERNAME, username, strlen (username)); TEST_ASSERT_SUCCESS_ERRNO (
assert (rc == 0); zmq_setsockopt (client, ZMQ_PLAIN_PASSWORD, password, strlen (password)));
rc = TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (client, my_endpoint));
zmq_setsockopt (client, ZMQ_PLAIN_PASSWORD, password, strlen (password));
assert (rc == 0);
rc = zmq_connect (client, my_endpoint);
assert (rc == 0);
expect_bounce_fail (server, client); expect_bounce_fail (server, client);
close_zero_linger (client); test_context_socket_close_zero_linger (client);
}
void test_plain_vanilla_socket ()
{
// Unauthenticated messages from a vanilla socket shouldn't be received // Unauthenticated messages from a vanilla socket shouldn't be received
struct sockaddr_in ip4addr; struct sockaddr_in ip4addr;
fd_t s; fd_t s;
unsigned short int port; unsigned short int port;
rc = sscanf (my_endpoint, "tcp://127.0.0.1:%hu", &port); int rc = sscanf (my_endpoint, "tcp://127.0.0.1:%hu", &port);
assert (rc == 1); TEST_ASSERT_EQUAL_INT (1, rc);
ip4addr.sin_family = AF_INET; ip4addr.sin_family = AF_INET;
ip4addr.sin_port = htons (port); ip4addr.sin_port = htons (port);
@ -186,7 +209,7 @@ int main (void)
s = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP); s = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
rc = connect (s, (struct sockaddr *) &ip4addr, sizeof (ip4addr)); rc = connect (s, (struct sockaddr *) &ip4addr, sizeof (ip4addr));
assert (rc > -1); TEST_ASSERT_GREATER_THAN_INT (-1, rc);
// send anonymous ZMTP/1.0 greeting // send anonymous ZMTP/1.0 greeting
send (s, "\x01\x00", 2, 0); send (s, "\x01\x00", 2, 0);
// send sneaky message that shouldn't be received // send sneaky message that shouldn't be received
@ -196,18 +219,19 @@ int main (void)
char *buf = s_recv (server); char *buf = s_recv (server);
if (buf != NULL) { if (buf != NULL) {
printf ("Received unauthenticated message: %s\n", buf); printf ("Received unauthenticated message: %s\n", buf);
assert (buf == NULL); TEST_ASSERT_NULL (buf);
} }
close (s); close (s);
}
// Shutdown
rc = zmq_close (server); int main (void)
assert (rc == 0); {
rc = zmq_ctx_term (ctx); setup_test_environment ();
assert (rc == 0);
UNITY_BEGIN ();
// Wait until ZAP handler terminates RUN_TEST (test_plain_success);
zmq_threadclose (zap_thread); RUN_TEST (test_plain_client_as_server_fails);
RUN_TEST (test_plain_wrong_credentials_fails);
return 0; RUN_TEST (test_plain_vanilla_socket);
return UNITY_END ();
} }