opietest.c revision 267654 
1/* opietest.c: Quick, though definitely not complete, regression test for
2               libopie. This is intended to catch two things:
3
4	(1) when changes break something
5        (2) if some system wierdness (libc, compiler, or CPU/hardware) is
6            not getting along at all with OPIE.
7
8        It's safe to say that, if tests fail, OPIE isn't going to work right
9on your system. The converse is not such a safe statement.
10
11%%% copyright-cmetz-96
12This software is Copyright 1996-2001 by Craig Metz, All Rights Reserved.
13The Inner Net License Version 3 applies to this software.
14You should have received a copy of the license with this software. If
15you didn't get a copy, you may request one from <license@inner.net>.
16
17        History:
18
19	Modified by cmetz for OPIE 2.4. Use struct opie_key for key blocks.
20	Modified by cmetz for OPIE 2.31. Added a couple of new checks,
21		removed a few commented-out checks for functions that
22		no longer exist, added test-skip capability.
23	Modified by cmetz for OPIE 2.3. Use new calling conventions for
24		opiebtoa8()/atob8(). opiegenerator() outputs hex now.
25	Modified by cmetz for OPIE 2.22. Test opielock()/opieunlock()
26		refcount support.
27	Created by cmetz for OPIE 2.2.
28*/
29#include "opie_cfg.h"
30#include <stdio.h>
31#include "opie.h"
32
33char buffer[1024];
34
35int testatob8()
36{
37  static char testin[] = "0123456789abcdef";
38  static unsigned char testout[sizeof(struct opie_otpkey)] = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
39  struct opie_otpkey key;
40
41  if (!opieatob8(&key, testin))
42    return -1;
43
44  if (memcmp(&key, testout, sizeof(testout)))
45    return -1;
46
47  return 0;
48}
49
50int testbtoa8()
51{
52  static unsigned char testin[sizeof(struct opie_otpkey)] = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
53  static char testout[] = "0123456789abcdef";
54  struct opie_otpkey testin_aligned;
55
56  memcpy(&testin_aligned, testin, sizeof(struct opie_otpkey));
57
58  if (!opiebtoa8(buffer, &testin_aligned))
59    return -1;
60
61  if (memcmp(buffer, testout, sizeof(testout)))
62    return -1;
63
64  return 0;
65}
66
67int testbtoe()
68{
69  static unsigned char testin[sizeof(struct opie_otpkey)] = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
70  static char testout[] = "AIM HEW BLUM FED MITE WARM";
71  struct opie_otpkey testin_aligned;
72
73  memcpy(&testin_aligned, testin, sizeof(struct opie_otpkey));
74
75  if (!opiebtoe(buffer, &testin_aligned))
76    return -1;
77
78  if (memcmp(buffer, testout, sizeof(testout)))
79    return -1;
80
81  return 0;
82}
83
84int testetob()
85{
86  static char testin[] = "AIM HEW BLUM FED MITE WARM";
87  static unsigned char testout[sizeof(struct opie_otpkey)] = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
88  struct opie_otpkey key;
89
90  if (opieetob(&key, testin) != 1)
91    return -1;
92
93  if (memcmp(&key, testout, sizeof(testout)))
94    return -1;
95
96  return 0;
97}
98
99int testgenerator()
100{
101  static char testin1[] = "otp-md5 123 ke1234";
102  static char testin2[] = "this is a test";
103  /*  static char testout[] = "END KERN BALM NICK EROS WAVY"; */
104  static char testout[] = "11D4 C147 E227 C1F1";
105
106  if (opiegenerator(testin1, testin2, buffer))
107    return -1;
108
109  if (memcmp(buffer, testout, sizeof(testout)))
110    return -1;
111
112  return 0;
113}
114
115int testgetsequence()
116{
117  struct opie testin;
118  testin.opie_n = 42;
119
120  if (opiegetsequence(&testin) != 42)
121    return -1;
122
123  return 0;
124}
125
126int testhashmd4()
127{
128  static unsigned char testin[sizeof(struct opie_otpkey)] = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
129  static unsigned char testout[sizeof(struct opie_otpkey)] = { 0x9f, 0x40, 0xfb, 0x84, 0xb, 0xf8, 0x7f, 0x4b };
130  struct opie_otpkey testin_aligned;
131
132  memcpy(&testin_aligned, testin, sizeof(struct opie_otpkey));
133
134  opiehash(&testin_aligned, 4);
135
136  if (memcmp(&testin_aligned, testout, sizeof(struct opie_otpkey)))
137    return -1;
138
139  return 0;
140}
141
142int testhashmd5()
143{
144  static unsigned char testin[] = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
145  static unsigned char testout[] = { 0x78, 0xdd, 0x1a, 0x37, 0xf8, 0x91, 0x54, 0xe1 };
146  struct opie_otpkey testin_aligned;
147
148  memcpy(&testin_aligned, testin, sizeof(struct opie_otpkey));
149
150  opiehash(&testin_aligned, 5);
151
152  if (memcmp(&testin_aligned, testout, sizeof(struct opie_otpkey)))
153    return -1;
154
155  return 0;
156}
157
158int testinsecure()
159{
160  opieinsecure();
161
162  return 0;
163}
164
165int testkeycrunch()
166{
167  static char testin1[] = "ke1234";
168  static char testin2[] = "this is a test";
169  static unsigned char testout[sizeof(struct opie_otpkey)] = { 0x2e, 0xd3, 0x5d, 0x74, 0x3e, 0xa9, 0xe9, 0xe8 };
170  struct opie_otpkey opie_otpkey;
171
172  if (opiekeycrunch(5, &opie_otpkey, testin1, testin2))
173    return -1;
174
175  if (memcmp(&opie_otpkey, testout, sizeof(struct opie_otpkey)))
176    return -1;
177
178  return 0;
179}
180
181int testlock()
182{
183  int i;
184
185  if (getuid())
186    return -2;
187
188  for (i = 0; i < 3; i++)
189    if (opielock("__opietest"))
190      return -1;
191
192  return 0;
193}
194
195int testpasscheck()
196{
197  static char testin1[] = "abadone";
198  static char testin2[] = "A more reasonable choice.";
199
200  if (!opiepasscheck(testin1))
201    return -1;
202
203  if (opiepasscheck(testin2))
204    return -1;
205
206  return 0;
207}
208
209int testrandomchallenge()
210{
211  char buffer[OPIE_CHALLENGE_MAX+1];
212
213  opierandomchallenge(buffer);
214
215  if (strncmp(buffer, "otp-", 4))
216    return -1;
217
218  return 0;
219}
220
221int testunlock()
222{
223  int i;
224
225  if (getuid())
226    return -2;
227
228  for (i = 0; i < 3; i++)
229    if (opieunlock())
230      return -1;
231
232  if (opieunlock() != -1)
233    return -1;
234
235  return 0;
236}
237
238struct opietest {
239  int (*f)();
240  char *n;
241};
242
243static struct opietest opietests[] = {
244  { testatob8, "atob8" },
245  { testbtoa8, "btoa8" },
246  { testbtoe, "btoe" },
247  { testetob, "etob" },
248/*  { testchallenge, "challenge" }, */
249  { testgenerator, "generator" },
250  { testgetsequence, "getsequence" },
251  { testhashmd4, "hash(MD4)" },
252  { testhashmd5, "hash(MD5)" },
253  { testinsecure, "insecure" },
254  { testkeycrunch, "keycrunch" },
255  { testlock, "lock" },
256  { testrandomchallenge, "randomchallenge" },
257/* { testreadpass, "readpass" }, */
258  { testunlock, "unlock" },
259/*  { testverify, "verify" }, */
260  { NULL, NULL }
261};
262
263int main FUNCTION((argc, argv), int argc AND char *argv[])
264{
265  struct opietest *opietest;
266  int tests_passed = 0;
267  int tests_failed = 0;
268  int tests_skipped = 0;
269  int ntests = 0, testn = 0;
270
271  if (getuid() != geteuid()) {
272    fprintf(stderr, "opietest: do not make this program setuid!\n");
273    exit(1);
274  };
275
276  for (opietest = opietests; opietest->n; opietest++)
277    ntests++;
278
279  printf("opietest: executing %d tests\n", ntests);
280
281  for (opietest = opietests, testn = 1; opietest->n; opietest++) {
282    printf("(%2d/%2d) testing opie%s... ", testn++, ntests, opietest->n);
283    switch(opietest->f()) {
284      case -2:
285        printf("skipped\n");
286        tests_skipped++;
287        opietest->f = NULL;
288        break;
289      case -1:
290        printf("FAILED!\n");
291        tests_failed++;
292        break;
293      case 0:
294        printf("passed\n");
295        tests_passed++;
296        opietest->f = NULL;
297        break;
298    }
299  }
300
301  printf("opietest: completed %d tests. %d tests passed, %d tests skipped, %d tests failed.\n", ntests, tests_passed, tests_skipped, tests_failed);
302  if (tests_failed) {
303    printf("opietest: please correct the following failures before attempting to use OPIE:\n");
304    for (opietest = opietests; opietest->n; opietest++)
305      if (opietest->f)
306	printf("          opie%s\n", opietest->n);
307    exit(1);
308  }
309  exit(0);
310}
311