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

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

Additional tests (which also fail) for unexpected padding.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 6.3 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 775 2014-03-09 12:04:56Z 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, e, i)                                        \
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, e, b32), T_DECODE_FAIL_N(64, e, b64)
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_N(32, EINVAL, "A======="),
142        T_DECODE_FAIL_N(32, EINVAL, "AAA====="),
143        T_DECODE_FAIL_N(32, EINVAL, "AAAAAA=="),
144        T_DECODE_FAIL_N(64, EINVAL, "A==="),
145
146        /* various error conditions */
147        T_SHORT_INPUT(),
148        T_LONG_OUTPUT(),
149};
150
151/*
152 * Encoding test function
153 */
154static int
155t_rfc4648(void *arg)
156{
157        struct t_case *t = arg;
158        char buf[64];
159        size_t len;
160        int ret;
161
162        len = t->blen ? t->blen : sizeof buf;
163        ret = t->func(t->in, t->ilen, buf, &len);
164        if (ret != t->ret) {
165                t_verbose("expected return code %d, got %d\n",
166                    t->ret, ret);
167                return (0);
168        }
169        if (t->out && len != t->olen) {
170                t_verbose("expected output length %zu, got %zu\n",
171                    t->olen, len);
172                return (0);
173        }
174        if (t->ret != 0 && errno != t->err) {
175                t_verbose("expected errno %d, got %d\n",
176                    t->err, errno);
177                return (0);
178        }
179        if (t->ret == 0 && t->out && strncmp(buf, t->out, len) != 0) {
180                t_verbose("expected '%.*s' got '%.*s'\n",
181                    (int)t->olen, t->out, (int)len, buf);
182                return (0);
183        }
184        return (1);
185}
186
187/*
188 * Generate the test plan
189 */
190const struct t_test **
191t_prepare(int argc, char *argv[])
192{
193        struct t_test **plan, *tests;
194        int i, n;
195
196        (void)argc;
197        (void)argv;
198        n = sizeof t_cases / sizeof t_cases[0];
199        if ((plan = calloc(n + 1, sizeof *plan)) == NULL ||
200            (tests = calloc(n + 1, sizeof *tests)) == NULL)
201                return (NULL);
202        for (i = 0; i < n; ++i) {
203                plan[i] = &tests[i];
204                tests[i].func = t_rfc4648;
205                tests[i].desc = t_cases[i].desc;
206                tests[i].arg = &t_cases[i];
207        }
208        return ((const struct t_test **)plan);
209}
210
211/*
212 * Cleanup
213 */
214void
215t_cleanup(void)
216{
217}
Note: See TracBrowser for help on using the repository browser.