Changeset 653 in openpam


Ignore:
Timestamp:
Mar 5, 2013, 6:54:22 PM (8 years ago)
Author:
Dag-Erling Smørgrav
Message:

Test cases for base 32 and 64 encoders

Location:
trunk/t
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/t

    • Property svn:ignore
      •  

        old new  
        55t_openpam_readlinev
        66t_openpam_readword
         7t_rfc4648
  • trunk/t/Makefile.am

    r648 r653  
    99TESTS += t_openpam_readword
    1010TESTS += t_openpam_readlinev
     11if WITH_OATH
     12TESTS += t_rfc4648
     13endif
    1114check_PROGRAMS = $(TESTS)
    1215
     
    1720# link with libpam and libt
    1821LDADD = libt.a $(top_builddir)/lib/libpam/libpam.la
     22if WITH_OATH
     23LDADD += $(top_builddir)/lib/liboath/liboath.la
     24endif
  • trunk/t/t_rfc4648.c

    r648 r653  
    4242#include <security/pam_appl.h>
    4343#include <security/openpam.h>
    44 
    45 #include "oath.h"
     44#include <security/oath.h>
    4645
    4746#include "t.h"
    4847
    49 struct test_vector {
    50         const uint8_t *in;
    51         size_t ilen;
    52         const char *out;
    53         size_t olen;
     48/*
     49 * Test vectors from RFC 4648
     50 */
     51static struct t_vector {
     52        const char *plain;
     53/*      const char *base16; */
     54        const char *base32;
     55        const char *base64;
     56} t_vectors[] = {
     57        {
     58                .plain  = "",
     59                .base32 = "",
     60                .base64 = "",
     61        },
     62        {
     63                .plain  = "f",
     64                .base32 = "MY======",
     65                .base64 = "Zg=="
     66        },
     67        {
     68                .plain  = "fo",
     69                .base32 = "MZXQ====",
     70                .base64 = "Zm8=",
     71        },
     72        {
     73                .plain  = "foo",
     74                .base32 = "MZXW6===",
     75                .base64 = "Zm9v",
     76        },
     77        {
     78                .plain  = "foob",
     79                .base32 = "MZXW6YQ=",
     80                .base64 = "Zm9vYg==",
     81        },
     82        {
     83                .plain  = "fooba",
     84                .base32 = "MZXW6YTB",
     85                .base64 = "Zm9vYmE=",
     86        },
     87        {
     88                .plain  = "foobar",
     89                .base32 = "MZXW6YTBOI======",
     90                .base64 = "Zm9vYmFy",
     91        },
    5492};
    5593
    56 #define TV(i, o) \
    57         { (const uint8_t *)i, sizeof i - 1, (const char *)o, sizeof o }
    58 #define TV_ZERO \
    59         { NULL, 0, NULL, 0 }
     94/*
     95 * Encoding test function
     96 */
     97static int
     98t_rfc4648_enc(const char *plain, const char *encoded,
     99    int (*enc)(const uint8_t *, size_t, char *, size_t *))
     100{
     101        char buf[64];
     102        size_t blen, ilen, olen;
    60103
    61 static struct test_vector base64_vectors[] = {
    62         TV("", ""),
    63         TV("f", "Zg=="),
    64         TV("fo", "Zm8="),
    65         TV("foo", "Zm9v"),
    66         TV("foob", "Zm9vYg=="),
    67         TV("fooba", "Zm9vYmE="),
    68         TV("foobar", "Zm9vYmFy"),
    69         TV_ZERO
    70 };
    71 
    72 static struct test_vector base32_vectors[] = {
    73         TV("", ""),
    74         TV("f", "MY======"),
    75         TV("fo", "MZXQ===="),
    76         TV("foo", "MZXW6==="),
    77         TV("foob", "MZXW6YQ="),
    78         TV("fooba", "MZXW6YTB"),
    79         TV("foobar", "MZXW6YTBOI======"),
    80         TV_ZERO
    81 };
    82 
    83 
    84 
    85 /***************************************************************************
    86  * Base 64
    87  */
    88 
    89 T_FUNC(base_64, "RFC 4648 base 64 test vectors")
    90 {
    91         struct test_vector *tv;
    92         char buf[64];
    93         size_t buflen;
    94 
    95         for (tv = base64_vectors; tv->in != NULL; ++tv) {
    96                 buflen = tv->olen;
    97                 t_verbose("BASE64(\"%s\") = \"%s\"\n", tv->in, tv->out);
    98                 if (base64_enc(tv->in, tv->ilen, buf, &buflen) != 0) {
    99                         t_verbose("BASE64(\"%s\") failed\n", tv->in);
    100                         return (0);
    101                 }
    102                 if (buflen != tv->olen) {
    103                         t_verbose("BASE64(\"%s\") expected %zu B got %zu B\n",
    104                             tv->in, tv->olen, buflen);
    105                         return (0);
    106                 }
    107                 if (strcmp(buf, tv->out) != 0) {
    108                         t_verbose("BASE64(\"%s\") expected \"%s\" got \"%s\"\n",
    109                             tv->in, tv->out, buf);
    110                         return (0);
    111                 }
     104        blen = sizeof buf;
     105        ilen = strlen(plain);
     106        olen = strlen(encoded) + 1;
     107        if (enc((const uint8_t *)plain, ilen, buf, &blen) != 0) {
     108                t_verbose("encoding failed\n");
     109                return (0);
     110        }
     111        if (blen != olen) {
     112                t_verbose("expected %zu B got %zu B\n", olen, blen);
     113                return (0);
     114        }
     115        if (strcmp(buf, encoded) != 0) {
     116                t_verbose("expected \"%s\" got \"%s\"\n", encoded, buf);
     117                return (0);
    112118        }
    113119        return (1);
    114120}
    115121
     122/*
     123 * Encoding test wrapper for base 32
     124 */
     125static int
     126t_base32(void *arg)
     127{
     128        struct t_vector *tv = (struct t_vector *)arg;
    116129
    117 
    118 /***************************************************************************
    119  * Base 32
    120  */
    121 
    122 T_FUNC(base_32, "RFC 4648 base 32 test vectors")
    123 {
    124         struct test_vector *tv;
    125         char buf[64];
    126         size_t buflen;
    127 
    128         for (tv = base32_vectors; tv->in != NULL; ++tv) {
    129                 buflen = tv->olen;
    130                 t_verbose("BASE32(\"%s\") = \"%s\"\n", tv->in, tv->out);
    131                 if (base32_enc(tv->in, tv->ilen, buf, &buflen) != 0) {
    132                         t_verbose("BASE32(\"%s\") failed\n", tv->in);
    133                         return (0);
    134                 }
    135                 if (buflen != tv->olen) {
    136                         t_verbose("BASE32(\"%s\") expected %zu B got %zu B\n",
    137                             tv->in, tv->olen, buflen);
    138                         return (0);
    139                 }
    140                 if (strcmp(buf, tv->out) != 0) {
    141                         t_verbose("BASE32(\"%s\") expected \"%s\" got \"%s\"\n",
    142                             tv->in, tv->out, buf);
    143                         return (0);
    144                 }
    145         }
    146         return (1);
     130        return (t_rfc4648_enc(tv->plain, tv->base32, base32_enc));
    147131}
    148132
     133/*
     134 * Encoding test wrapper for base 64
     135 */
     136static int
     137t_base64(void *arg)
     138{
     139        struct t_vector *tv = (struct t_vector *)arg;
    149140
     141        return (t_rfc4648_enc(tv->plain, tv->base64, base64_enc));
     142}
    150143
    151 /***************************************************************************
    152  * Boilerplate
     144/*
     145 * Generate a test case for a given test vector
    153146 */
     147static struct t_test *
     148t_create_test(int (*func)(void *), const char *name, struct t_vector *tv)
     149{
     150        struct t_test *test;
     151        char *desc;
    154152
    155 const struct t_test *t_plan[] = {
    156         T(base_64),
    157         T(base_32),
    158         NULL
    159 };
     153        if ((test = calloc(1, sizeof *test)) == NULL)
     154                return (NULL);
     155        test->func = func;
     156        if ((desc = calloc(1, strlen(name) + strlen(tv->plain) + 5)) == NULL)
     157                return (NULL);
     158        sprintf(desc, "%s(\"%s\")", name, tv->plain);
     159        test->desc = desc;
     160        test->arg = tv;
     161        return (test);
     162}
    160163
     164/*
     165 * Generate the test plan
     166 */
    161167const struct t_test **
    162168t_prepare(int argc, char *argv[])
    163169{
     170        struct t_test **plan, **test;
     171        int n;
    164172
    165173        (void)argc;
    166174        (void)argv;
    167         return (t_plan);
     175        n = sizeof t_vectors / sizeof t_vectors[0];
     176        plan = calloc(n * 2 + 1, sizeof *plan);
     177        if (plan == NULL)
     178                return (NULL);
     179        test = plan;
     180        for (int i = 0; i < n; ++i) {
     181                *test++ = t_create_test(t_base32, "BASE32", &t_vectors[i]);
     182                *test++ = t_create_test(t_base64, "BASE64", &t_vectors[i]);
     183        }
     184        return ((const struct t_test **)plan);
    168185}
    169186
     187/*
     188 * Cleanup
     189 */
    170190void
    171191t_cleanup(void)
Note: See TracChangeset for help on using the changeset viewer.