Completely rewrite the test suite for the RFC 4648 encoding / decoding
functions and add many new tests, several of which fail. git-svn-id: svn+ssh://svn.openpam.org/svn/openpam/trunk@773 185d5e19-27fe-0310-9dcf-9bff6b9f3609
This commit is contained in:
Dag-Erling Smørgrav
parent
01809a1b48
commit
c5265319ff
291
t/t_rfc4648.c
291
t/t_rfc4648.c
|
|
@ -33,7 +33,7 @@
|
||||||
# include "config.h"
|
# include "config.h"
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#include <err.h>
|
#include <errno.h>
|
||||||
#include <stdint.h>
|
#include <stdint.h>
|
||||||
#include <stdio.h>
|
#include <stdio.h>
|
||||||
#include <stdlib.h>
|
#include <stdlib.h>
|
||||||
|
|
@ -44,194 +44,163 @@
|
||||||
|
|
||||||
#include "t.h"
|
#include "t.h"
|
||||||
|
|
||||||
/*
|
struct t_case {
|
||||||
* Test vectors from RFC 4648
|
const char *desc;
|
||||||
*/
|
int (*func)(const char *, size_t, char *, size_t *);
|
||||||
static struct t_vector {
|
const char *in; /* input string */
|
||||||
const char *plain;
|
size_t ilen; /* input length */
|
||||||
/* const char *base16; */
|
const char *out; /* expected output string or NULL */
|
||||||
const char *base32;
|
size_t blen; /* initial value for olen or 0*/
|
||||||
const char *base64;
|
size_t olen; /* expected value for olen */
|
||||||
} t_vectors[] = {
|
int ret; /* expected return value */
|
||||||
{
|
int err; /* expected errno if ret != 0 */
|
||||||
.plain = "",
|
};
|
||||||
.base32 = "",
|
|
||||||
.base64 = "",
|
/* basic encoding / decoding */
|
||||||
},
|
#define T_ENCODE_N(N, i, o) \
|
||||||
{
|
{ "base"#N"_enc("#i")", base##N##_enc, i, sizeof i - 1, \
|
||||||
.plain = "f",
|
o, sizeof o, sizeof o, 0, 0 }
|
||||||
.base32 = "MY======",
|
#define T_DECODE_N(N, i, o) \
|
||||||
.base64 = "Zg=="
|
{ "base"#N"_dec("#i")", base##N##_dec, i, sizeof i - 1, \
|
||||||
},
|
o, sizeof o - 1, sizeof o - 1, 0, 0 }
|
||||||
{
|
#define T_ENCODE(p, b32, b64) \
|
||||||
.plain = "fo",
|
T_ENCODE_N(32, p, b32), T_ENCODE_N(64, p, b64)
|
||||||
.base32 = "MZXQ====",
|
#define T_DECODE(p, b32, b64) \
|
||||||
.base64 = "Zm8=",
|
T_DECODE_N(32, b32, p), T_DECODE_N(64, b64, p)
|
||||||
},
|
|
||||||
{
|
/* roundtrip encoding tests */
|
||||||
.plain = "foo",
|
#define T_ENCDEC(p, b32, b64) \
|
||||||
.base32 = "MZXW6===",
|
T_ENCODE(p, b32, b64), T_DECODE(p, b32, b64)
|
||||||
.base64 = "Zm9v",
|
|
||||||
},
|
/* decoding failure */
|
||||||
{
|
#define T_DECODE_FAIL_N(N, i, e) \
|
||||||
.plain = "foob",
|
{ "base"#N"_dec("#i")", base##N##_dec, i, sizeof i - 1, \
|
||||||
.base32 = "MZXW6YQ=",
|
NULL, 0, 0, -1, e }
|
||||||
.base64 = "Zm9vYg==",
|
#define T_DECODE_FAIL(e, b32, b64) \
|
||||||
},
|
T_DECODE_FAIL_N(32, b32, e), T_DECODE_FAIL_N(64, b64, e)
|
||||||
{
|
|
||||||
.plain = "fooba",
|
/* input string shorter than input length */
|
||||||
.base32 = "MZXW6YTB",
|
#define T_SHORT_INPUT_DEC(N, i) \
|
||||||
.base64 = "Zm9vYmE=",
|
{ "base"#N"_dec (short input)", base##N##_dec, i, sizeof i + 2, \
|
||||||
},
|
NULL, 0, base##N##_declen(sizeof i - 1), 0, 0 }
|
||||||
{
|
#define T_SHORT_INPUT() \
|
||||||
.plain = "foobar",
|
T_SHORT_INPUT_DEC(32, "AAAAAAAA"), \
|
||||||
.base32 = "MZXW6YTBOI======",
|
T_SHORT_INPUT_DEC(64, "AAAA")
|
||||||
.base64 = "Zm9vYmFy",
|
|
||||||
},
|
/* output string longer than output length */
|
||||||
|
#define T_LONG_OUTPUT_ENC(N, i) \
|
||||||
|
{ "base"#N"_enc (long output)", base##N##_enc, i, sizeof i - 1, \
|
||||||
|
NULL, 1, base##N##_enclen(sizeof i - 1) + 1, -1, ENOSPC }
|
||||||
|
#define T_LONG_OUTPUT_DEC(N, i) \
|
||||||
|
{ "base"#N"_dec (long output)", base##N##_dec, "AAAAAAAA", 8, \
|
||||||
|
NULL, 1, base##N##_declen(sizeof i - 1), -1, ENOSPC }
|
||||||
|
#define T_LONG_OUTPUT() \
|
||||||
|
T_LONG_OUTPUT_ENC(32, "foo"), \
|
||||||
|
T_LONG_OUTPUT_DEC(32, "AAAAAAAA"), \
|
||||||
|
T_LONG_OUTPUT_ENC(64, "foo"), \
|
||||||
|
T_LONG_OUTPUT_DEC(64, "AAAA")
|
||||||
|
|
||||||
|
static struct t_case t_cases[] = {
|
||||||
|
/* test vectors from RFC 4648 */
|
||||||
|
/* plain base32 base64 */
|
||||||
|
T_ENCDEC("", "", ""),
|
||||||
|
T_ENCDEC("f", "MY======", "Zg=="),
|
||||||
|
T_ENCDEC("fo", "MZXQ====", "Zm8="),
|
||||||
|
T_ENCDEC("foo", "MZXW6===", "Zm9v"),
|
||||||
|
T_ENCDEC("foob", "MZXW6YQ=", "Zm9vYg=="),
|
||||||
|
T_ENCDEC("fooba", "MZXW6YTB", "Zm9vYmE="),
|
||||||
|
T_ENCDEC("foobar", "MZXW6YTBOI======", "Zm9vYmFy"),
|
||||||
|
|
||||||
|
/* zeroes */
|
||||||
|
T_ENCDEC("\0\0\0", "AAAAA===", "AAAA"),
|
||||||
|
|
||||||
|
/* sloppy padding */
|
||||||
|
T_DECODE("f", "MY=", "Zg="),
|
||||||
|
T_DECODE("f", "MY", "Zg"),
|
||||||
|
|
||||||
|
/* whitespace */
|
||||||
|
/* plain base32 base64 */
|
||||||
|
T_DECODE("tst", "ORZX I===", "dH N0"),
|
||||||
|
T_DECODE("tst", "ORZX\tI===", "dH\tN0"),
|
||||||
|
T_DECODE("tst", "ORZX\rI===", "dH\rN0"),
|
||||||
|
T_DECODE("tst", "ORZX\nI===", "dH\nN0"),
|
||||||
|
|
||||||
|
/* invalid character in data */
|
||||||
|
T_DECODE_FAIL(EINVAL, "AA!AAAAAA", "AA!A"),
|
||||||
|
|
||||||
|
/* invalid character in padding */
|
||||||
|
T_DECODE_FAIL(EINVAL, "AAAAA==!", "AA=!"),
|
||||||
|
|
||||||
|
/* padding with no data */
|
||||||
|
T_DECODE_FAIL(EINVAL, "AAAAAAAA=", "AAAA="),
|
||||||
|
|
||||||
|
/* data after padding */
|
||||||
|
T_DECODE_FAIL(EINVAL, "AA=A", "AA=A"),
|
||||||
|
|
||||||
|
/* padding in incorrect location */
|
||||||
|
T_DECODE_FAIL(EINVAL, "A=", "A="),
|
||||||
|
|
||||||
|
/* various error conditions */
|
||||||
|
T_SHORT_INPUT(),
|
||||||
|
T_LONG_OUTPUT(),
|
||||||
};
|
};
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* Encoding test function
|
* Encoding test function
|
||||||
*/
|
*/
|
||||||
static int
|
static int
|
||||||
t_rfc4648_enc(const char *plain, const char *encoded,
|
t_rfc4648(void *arg)
|
||||||
int (*enc)(const char *, size_t, char *, size_t *))
|
|
||||||
{
|
{
|
||||||
|
struct t_case *t = arg;
|
||||||
char buf[64];
|
char buf[64];
|
||||||
size_t blen, ilen, olen;
|
size_t len;
|
||||||
|
int ret;
|
||||||
|
|
||||||
blen = sizeof buf;
|
len = t->blen ? t->blen : sizeof buf;
|
||||||
ilen = strlen(plain);
|
ret = t->func(t->in, t->ilen, buf, &len);
|
||||||
olen = strlen(encoded) + 1;
|
if (ret != t->ret) {
|
||||||
if (enc((const char *)plain, ilen, buf, &blen) != 0) {
|
t_verbose("expected return code %d, got %d\n",
|
||||||
t_verbose("encoding failed\n");
|
t->ret, ret);
|
||||||
return (0);
|
return (0);
|
||||||
}
|
}
|
||||||
if (blen != olen) {
|
if (t->out && len != t->olen) {
|
||||||
t_verbose("expected '%.*s' got '%.*s'\n", (int)olen, encoded, (int)blen, buf);
|
t_verbose("expected output length %zu, got %zu\n",
|
||||||
t_verbose("expected %zu B got %zu B\n", olen, blen);
|
t->olen, len);
|
||||||
return (0);
|
return (0);
|
||||||
}
|
}
|
||||||
if (strncmp(buf, encoded, blen) != 0) {
|
if (t->ret != 0 && errno != t->err) {
|
||||||
t_verbose("expected '%.*s' got '%.*s'\n", (int)olen, encoded, (int)blen, buf);
|
t_verbose("expected errno %d, got %d\n",
|
||||||
|
t->err, errno);
|
||||||
|
return (0);
|
||||||
|
}
|
||||||
|
if (t->ret == 0 && t->out && strncmp(buf, t->out, len) != 0) {
|
||||||
|
t_verbose("expected '%.*s' got '%.*s'\n",
|
||||||
|
(int)t->olen, t->out, (int)len, buf);
|
||||||
return (0);
|
return (0);
|
||||||
}
|
}
|
||||||
return (1);
|
return (1);
|
||||||
}
|
}
|
||||||
|
|
||||||
/*
|
|
||||||
* Encoding test wrapper for base 32
|
|
||||||
*/
|
|
||||||
static int
|
|
||||||
t_base32_enc(void *arg)
|
|
||||||
{
|
|
||||||
struct t_vector *tv = (struct t_vector *)arg;
|
|
||||||
|
|
||||||
return (t_rfc4648_enc(tv->plain, tv->base32, base32_enc));
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Encoding test wrapper for base 64
|
|
||||||
*/
|
|
||||||
static int
|
|
||||||
t_base64_enc(void *arg)
|
|
||||||
{
|
|
||||||
struct t_vector *tv = (struct t_vector *)arg;
|
|
||||||
|
|
||||||
return (t_rfc4648_enc(tv->plain, tv->base64, base64_enc));
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Decoding test function
|
|
||||||
*/
|
|
||||||
static int
|
|
||||||
t_rfc4648_dec(const char *encoded, const char *plain,
|
|
||||||
int (*dec)(const char *, size_t, char *, size_t *))
|
|
||||||
{
|
|
||||||
char buf[64];
|
|
||||||
size_t blen, ilen, olen;
|
|
||||||
|
|
||||||
blen = sizeof buf;
|
|
||||||
ilen = strlen(encoded);
|
|
||||||
olen = strlen(plain);
|
|
||||||
if (dec(encoded, ilen, buf, &blen) != 0) {
|
|
||||||
t_verbose("encoding failed\n");
|
|
||||||
return (0);
|
|
||||||
}
|
|
||||||
if (blen != olen) {
|
|
||||||
t_verbose("expected %zu B got %zu B\n", olen, blen);
|
|
||||||
return (0);
|
|
||||||
}
|
|
||||||
if (strncmp(buf, plain, blen) != 0) {
|
|
||||||
t_verbose("expected '%.*s' got '%.*s'\n", (int)olen, plain, (int)blen, buf);
|
|
||||||
return (0);
|
|
||||||
}
|
|
||||||
return (1);
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Decoding test wrapper for base 32
|
|
||||||
*/
|
|
||||||
static int
|
|
||||||
t_base32_dec(void *arg)
|
|
||||||
{
|
|
||||||
struct t_vector *tv = (struct t_vector *)arg;
|
|
||||||
|
|
||||||
return (t_rfc4648_dec(tv->base32, tv->plain, base32_dec));
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Decoding test wrapper for base 64
|
|
||||||
*/
|
|
||||||
static int
|
|
||||||
t_base64_dec(void *arg)
|
|
||||||
{
|
|
||||||
struct t_vector *tv = (struct t_vector *)arg;
|
|
||||||
|
|
||||||
return (t_rfc4648_dec(tv->base64, tv->plain, base64_dec));
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Generate a test case for a given test vector
|
|
||||||
*/
|
|
||||||
static struct t_test *
|
|
||||||
t_create_test(int (*func)(void *), const char *name, struct t_vector *tv)
|
|
||||||
{
|
|
||||||
struct t_test *test;
|
|
||||||
char *desc;
|
|
||||||
|
|
||||||
if ((test = calloc(1, sizeof *test)) == NULL)
|
|
||||||
return (NULL);
|
|
||||||
test->func = func;
|
|
||||||
if ((desc = calloc(1, strlen(name) + strlen(tv->plain) + 5)) == NULL)
|
|
||||||
return (NULL);
|
|
||||||
sprintf(desc, "%s(\"%s\")", name, tv->plain);
|
|
||||||
test->desc = desc;
|
|
||||||
test->arg = tv;
|
|
||||||
return (test);
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* Generate the test plan
|
* Generate the test plan
|
||||||
*/
|
*/
|
||||||
const struct t_test **
|
const struct t_test **
|
||||||
t_prepare(int argc, char *argv[])
|
t_prepare(int argc, char *argv[])
|
||||||
{
|
{
|
||||||
struct t_test **plan, **test;
|
struct t_test **plan, *tests;
|
||||||
int n;
|
int i, n;
|
||||||
|
|
||||||
(void)argc;
|
(void)argc;
|
||||||
(void)argv;
|
(void)argv;
|
||||||
n = sizeof t_vectors / sizeof t_vectors[0];
|
n = sizeof t_cases / sizeof t_cases[0];
|
||||||
plan = calloc(n * 4 + 1, sizeof *plan);
|
if ((plan = calloc(n + 1, sizeof *plan)) == NULL ||
|
||||||
if (plan == NULL)
|
(tests = calloc(n + 1, sizeof *tests)) == NULL)
|
||||||
return (NULL);
|
return (NULL);
|
||||||
test = plan;
|
for (i = 0; i < n; ++i) {
|
||||||
for (int i = 0; i < n; ++i) {
|
plan[i] = &tests[i];
|
||||||
*test++ = t_create_test(t_base32_enc, "BASE32ENC", &t_vectors[i]);
|
tests[i].func = t_rfc4648;
|
||||||
*test++ = t_create_test(t_base32_dec, "BASE32DEC", &t_vectors[i]);
|
tests[i].desc = t_cases[i].desc;
|
||||||
*test++ = t_create_test(t_base64_enc, "BASE64ENC", &t_vectors[i]);
|
tests[i].arg = &t_cases[i];
|
||||||
*test++ = t_create_test(t_base64_dec, "BASE64DEC", &t_vectors[i]);
|
|
||||||
}
|
}
|
||||||
return ((const struct t_test **)plan);
|
return ((const struct t_test **)plan);
|
||||||
}
|
}
|
||||||
|
|
|
||||||
Loading…
Reference in New Issue