source: openpam/trunk/t/t_rfc4648.c @ 773

Last change on this file since 773 was 773, checked in by Dag-Erling Smørgrav, 7 years ago

Completely rewrite the test suite for the RFC 4648 encoding / decoding
functions and add many new tests, several of which fail.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 6.2 KB
Line 
1/*-
2 * Copyright (c) 2013-2014 Universitetet i Oslo
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 * 3. The name of the author may not be used to endorse or promote
14 *    products derived from this software without specific prior written
15 *    permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 *
29 * $Id: t_rfc4648.c 773 2014-03-09 11:49:08Z des $
30 */
31
32#ifdef HAVE_CONFIG_H
33# include "config.h"
34#endif
35
36#include <errno.h>
37#include <stdint.h>
38#include <stdio.h>
39#include <stdlib.h>
40#include <string.h>
41#include <unistd.h>
42
43#include <security/oath.h>
44
45#include "t.h"
46
47struct t_case {
48        const char *desc;
49        int (*func)(const char *, size_t, char *, size_t *);
50        const char *in;         /* input string  */
51        size_t ilen;            /* input length */
52        const char *out;        /* expected output string or NULL */
53        size_t blen;            /* initial value for olen or 0*/
54        size_t olen;            /* expected value for olen */
55        int ret;                /* expected return value */
56        int err;                /* expected errno if ret != 0 */
57};
58
59/* basic encoding / decoding */
60#define T_ENCODE_N(N, i, o)                                             \
61        { "base"#N"_enc("#i")", base##N##_enc, i, sizeof i - 1,         \
62          o, sizeof o, sizeof o, 0, 0 }
63#define T_DECODE_N(N, i, o)                                             \
64        { "base"#N"_dec("#i")", base##N##_dec, i, sizeof i - 1,         \
65          o, sizeof o - 1, sizeof o - 1, 0, 0 }
66#define T_ENCODE(p, b32, b64)                                           \
67        T_ENCODE_N(32, p, b32), T_ENCODE_N(64, p, b64)
68#define T_DECODE(p, b32, b64)                                           \
69        T_DECODE_N(32, b32, p), T_DECODE_N(64, b64, p)
70
71/* roundtrip encoding tests */
72#define T_ENCDEC(p, b32, b64)                                           \
73        T_ENCODE(p, b32, b64), T_DECODE(p, b32, b64)
74
75/* decoding failure */
76#define T_DECODE_FAIL_N(N, i, e)                                        \
77        { "base"#N"_dec("#i")", base##N##_dec, i, sizeof i - 1,         \
78          NULL, 0, 0, -1, e }
79#define T_DECODE_FAIL(e, b32, b64)                                      \
80        T_DECODE_FAIL_N(32, b32, e), T_DECODE_FAIL_N(64, b64, e)
81
82/* input string shorter than input length */
83#define T_SHORT_INPUT_DEC(N, i)                                         \
84        { "base"#N"_dec (short input)", base##N##_dec, i, sizeof i + 2, \
85          NULL, 0, base##N##_declen(sizeof i - 1), 0, 0 }
86#define T_SHORT_INPUT()                                                 \
87        T_SHORT_INPUT_DEC(32, "AAAAAAAA"),                              \
88        T_SHORT_INPUT_DEC(64, "AAAA")
89
90/* output string longer than output length */
91#define T_LONG_OUTPUT_ENC(N, i)                                         \
92        { "base"#N"_enc (long output)", base##N##_enc, i, sizeof i - 1, \
93          NULL, 1, base##N##_enclen(sizeof i - 1) + 1, -1, ENOSPC }
94#define T_LONG_OUTPUT_DEC(N, i)                                         \
95        { "base"#N"_dec (long output)", base##N##_dec, "AAAAAAAA", 8,   \
96          NULL, 1, base##N##_declen(sizeof i - 1), -1, ENOSPC }
97#define T_LONG_OUTPUT()                                                 \
98        T_LONG_OUTPUT_ENC(32, "foo"),                                   \
99        T_LONG_OUTPUT_DEC(32, "AAAAAAAA"),                              \
100        T_LONG_OUTPUT_ENC(64, "foo"),                                   \
101        T_LONG_OUTPUT_DEC(64, "AAAA")
102
103static struct t_case t_cases[] = {
104        /* test vectors from RFC 4648 */
105        /*       plain          base32                  base64 */
106        T_ENCDEC("",            "",                     ""),
107        T_ENCDEC("f",           "MY======",             "Zg=="),
108        T_ENCDEC("fo",          "MZXQ====",             "Zm8="),
109        T_ENCDEC("foo",         "MZXW6===",             "Zm9v"),
110        T_ENCDEC("foob",        "MZXW6YQ=",             "Zm9vYg=="),
111        T_ENCDEC("fooba",       "MZXW6YTB",             "Zm9vYmE="),
112        T_ENCDEC("foobar",      "MZXW6YTBOI======",     "Zm9vYmFy"),
113
114        /* zeroes */
115        T_ENCDEC("\0\0\0",      "AAAAA===",             "AAAA"),
116
117        /* sloppy padding */
118        T_DECODE("f",           "MY=",                  "Zg="),
119        T_DECODE("f",           "MY",                   "Zg"),
120
121        /* whitespace */
122        /*       plain          base32                  base64 */
123        T_DECODE("tst",         "ORZX I===",            "dH N0"),
124        T_DECODE("tst",         "ORZX\tI===",           "dH\tN0"),
125        T_DECODE("tst",         "ORZX\rI===",           "dH\rN0"),
126        T_DECODE("tst",         "ORZX\nI===",           "dH\nN0"),
127
128        /* invalid character in data */
129        T_DECODE_FAIL(EINVAL,   "AA!AAAAAA",            "AA!A"),
130
131        /* invalid character in padding */
132        T_DECODE_FAIL(EINVAL,   "AAAAA==!",             "AA=!"),
133
134        /* padding with no data */
135        T_DECODE_FAIL(EINVAL,   "AAAAAAAA=",            "AAAA="),
136
137        /* data after padding */
138        T_DECODE_FAIL(EINVAL,   "AA=A",                 "AA=A"),
139
140        /* padding in incorrect location */
141        T_DECODE_FAIL(EINVAL,   "A=",                   "A="),
142
143        /* various error conditions */
144        T_SHORT_INPUT(),
145        T_LONG_OUTPUT(),
146};
147
148/*
149 * Encoding test function
150 */
151static int
152t_rfc4648(void *arg)
153{
154        struct t_case *t = arg;
155        char buf[64];
156        size_t len;
157        int ret;
158
159        len = t->blen ? t->blen : sizeof buf;
160        ret = t->func(t->in, t->ilen, buf, &len);
161        if (ret != t->ret) {
162                t_verbose("expected return code %d, got %d\n",
163                    t->ret, ret);
164                return (0);
165        }
166        if (t->out && len != t->olen) {
167                t_verbose("expected output length %zu, got %zu\n",
168                    t->olen, len);
169                return (0);
170        }
171        if (t->ret != 0 && errno != t->err) {
172                t_verbose("expected errno %d, got %d\n",
173                    t->err, errno);
174                return (0);
175        }
176        if (t->ret == 0 && t->out && strncmp(buf, t->out, len) != 0) {
177                t_verbose("expected '%.*s' got '%.*s'\n",
178                    (int)t->olen, t->out, (int)len, buf);
179                return (0);
180        }
181        return (1);
182}
183
184/*
185 * Generate the test plan
186 */
187const struct t_test **
188t_prepare(int argc, char *argv[])
189{
190        struct t_test **plan, *tests;
191        int i, n;
192
193        (void)argc;
194        (void)argv;
195        n = sizeof t_cases / sizeof t_cases[0];
196        if ((plan = calloc(n + 1, sizeof *plan)) == NULL ||
197            (tests = calloc(n + 1, sizeof *tests)) == NULL)
198                return (NULL);
199        for (i = 0; i < n; ++i) {
200                plan[i] = &tests[i];
201                tests[i].func = t_rfc4648;
202                tests[i].desc = t_cases[i].desc;
203                tests[i].arg = &t_cases[i];
204        }
205        return ((const struct t_test **)plan);
206}
207
208/*
209 * Cleanup
210 */
211void
212t_cleanup(void)
213{
214}
Note: See TracBrowser for help on using the repository browser.