← Back to branch summary

~ubuntu-branches/ubuntu/precise/libssh/precise

« back to all changes in this revision

Viewing changes to tests/unittests/torture_keyfiles.c

  • Committer: Bazaar Package Importer
  • Author(s): Laurent Bigonville
  • Date: 2011-06-15 15:48:07 UTC
  • mfrom: (1.1.10 upstream) (4.1.12 sid)
  • Revision ID: james.westby@ubuntu.com-20110615154807-3muklcqfftr1vtch
Tags: 0.5.0-2
* debian/patches/0002-Check-for-NULL-pointers-in-string-c.patch:
  Consolidate patch (Should fix previous REJECT)
* Support multiarch spec

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/unittests/torture_keyfiles.c
 
1
#define LIBSSH_STATIC
 
2
 
 
3
#include "torture.h"
 
4
#include "keyfiles.c"
 
5
 
 
6
#define LIBSSH_RSA_TESTKEY "libssh_testkey.id_rsa"
 
7
#define LIBSSH_DSA_TESTKEY "libssh_testkey.id_dsa"
 
8
#define LIBSSH_PASSPHRASE "libssh-rocks"
 
9
 
 
10
static void setup_rsa_key(void **state) {
 
11
    ssh_session session;
 
12
    int rc;
 
13
 
 
14
    unlink(LIBSSH_RSA_TESTKEY);
 
15
    unlink(LIBSSH_RSA_TESTKEY ".pub");
 
16
 
 
17
    rc = system("ssh-keygen -t rsa -q -N \"\" -f " LIBSSH_RSA_TESTKEY);
 
18
    assert_true(rc == 0);
 
19
 
 
20
    session = ssh_new();
 
21
    *state = session;
 
22
}
 
23
 
 
24
static void setup_dsa_key(void **state) {
 
25
    ssh_session session;
 
26
    int rc;
 
27
 
 
28
    unlink(LIBSSH_DSA_TESTKEY);
 
29
    unlink(LIBSSH_DSA_TESTKEY ".pub");
 
30
 
 
31
    rc = system("ssh-keygen -t dsa -q -N \"\" -f " LIBSSH_DSA_TESTKEY);
 
32
    assert_true(rc == 0);
 
33
 
 
34
    session = ssh_new();
 
35
    *state = session;
 
36
}
 
37
 
 
38
static void setup_both_keys(void **state) {
 
39
    setup_rsa_key(state);
 
40
    ssh_free(*state);
 
41
    setup_dsa_key(state);
 
42
}
 
43
 
 
44
static void setup_both_keys_passphrase(void **state) {
 
45
    ssh_session session;
 
46
    int rc;
 
47
 
 
48
    rc = system("ssh-keygen -t rsa -N " LIBSSH_PASSPHRASE " -f " LIBSSH_RSA_TESTKEY);
 
49
    assert_true(rc == 0);
 
50
 
 
51
    rc = system("ssh-keygen -t dsa -N " LIBSSH_PASSPHRASE " -f " LIBSSH_DSA_TESTKEY);
 
52
    assert_true(rc == 0);
 
53
 
 
54
    session = ssh_new();
 
55
    *state = session;
 
56
}
 
57
static void teardown(void **state) {
 
58
    unlink(LIBSSH_DSA_TESTKEY);
 
59
    unlink(LIBSSH_DSA_TESTKEY ".pub");
 
60
 
 
61
    unlink(LIBSSH_RSA_TESTKEY);
 
62
    unlink(LIBSSH_RSA_TESTKEY ".pub");
 
63
 
 
64
    ssh_free(*state);
 
65
}
 
66
 
 
67
static void torture_pubkey_from_file(void **state) {
 
68
    ssh_session session = *state;
 
69
    ssh_string pubkey;
 
70
    int type, rc;
 
71
 
 
72
    rc = ssh_try_publickey_from_file(session, LIBSSH_RSA_TESTKEY, &pubkey, &type);
 
73
 
 
74
    assert_true(rc == 0);
 
75
 
 
76
    ssh_string_free(pubkey);
 
77
 
 
78
    /* test if it returns 1 if pubkey doesn't exist */
 
79
    unlink(LIBSSH_RSA_TESTKEY ".pub");
 
80
 
 
81
    rc = ssh_try_publickey_from_file(session, LIBSSH_RSA_TESTKEY, &pubkey, &type);
 
82
    assert_true(rc == 1);
 
83
 
 
84
    /* test if it returns -1 if privkey doesn't exist */
 
85
    unlink(LIBSSH_RSA_TESTKEY);
 
86
 
 
87
    rc = ssh_try_publickey_from_file(session, LIBSSH_RSA_TESTKEY, &pubkey, &type);
 
88
    assert_true(rc == -1);
 
89
}
 
90
 
 
91
static int torture_read_one_line(const char *filename, char *buffer, size_t len) {
 
92
  FILE *fp;
 
93
  size_t rc;
 
94
 
 
95
  fp = fopen(filename, "r");
 
96
  if (fp == NULL) {
 
97
    return -1;
 
98
  }
 
99
 
 
100
  rc = fread(buffer, len, 1, fp);
 
101
  if (rc != 0 || ferror(fp)) {
 
102
    fclose(fp);
 
103
    return -1;
 
104
  }
 
105
 
 
106
  fclose(fp);
 
107
 
 
108
  return 0;
 
109
}
 
110
 
 
111
static void torture_pubkey_generate_from_privkey(void **state) {
 
112
    ssh_session session = *state;
 
113
    ssh_private_key privkey = NULL;
 
114
    ssh_public_key pubkey = NULL;
 
115
    ssh_string pubkey_orig = NULL;
 
116
    ssh_string pubkey_new = NULL;
 
117
    char pubkey_line_orig[512] = {0};
 
118
    char pubkey_line_new[512] = {0};
 
119
    int type_orig = 0;
 
120
    int type_new = 0;
 
121
    int rc;
 
122
 
 
123
    /* read the publickey */
 
124
    rc = ssh_try_publickey_from_file(session, LIBSSH_RSA_TESTKEY, &pubkey_orig,
 
125
        &type_orig);
 
126
    assert_true(rc == 0);
 
127
    assert_true(pubkey_orig != NULL);
 
128
 
 
129
    rc = torture_read_one_line(LIBSSH_RSA_TESTKEY ".pub", pubkey_line_orig,
 
130
        sizeof(pubkey_line_orig));
 
131
    assert_true(rc == 0);
 
132
 
 
133
    /* remove the public key, generate it from the private key and write it. */
 
134
    unlink(LIBSSH_RSA_TESTKEY ".pub");
 
135
 
 
136
    privkey = privatekey_from_file(session, LIBSSH_RSA_TESTKEY, 0, NULL);
 
137
    assert_true(privkey != NULL);
 
138
 
 
139
    pubkey = publickey_from_privatekey(privkey);
 
140
    assert_true(pubkey != NULL);
 
141
    type_new = privkey->type;
 
142
    privatekey_free(privkey);
 
143
 
 
144
    pubkey_new = publickey_to_string(pubkey);
 
145
    publickey_free(pubkey);
 
146
 
 
147
    assert_true(pubkey_new != NULL);
 
148
 
 
149
    assert_true(ssh_string_len(pubkey_orig) == ssh_string_len(pubkey_new));
 
150
    assert_memory_equal(ssh_string_data(pubkey_orig),
 
151
                        ssh_string_data(pubkey_new),
 
152
                        ssh_string_len(pubkey_orig));
 
153
 
 
154
    rc = ssh_publickey_to_file(session, LIBSSH_RSA_TESTKEY ".pub", pubkey_new, type_new);
 
155
    assert_true(rc == 0);
 
156
 
 
157
    rc = torture_read_one_line(LIBSSH_RSA_TESTKEY ".pub", pubkey_line_new,
 
158
        sizeof(pubkey_line_new));
 
159
    assert_true(rc == 0);
 
160
 
 
161
    assert_string_equal(pubkey_line_orig, pubkey_line_new);
 
162
 
 
163
    ssh_string_free(pubkey_orig);
 
164
    ssh_string_free(pubkey_new);
 
165
}
 
166
 
 
167
/**
 
168
 * @brief tests the privatekey_from_file function without passphrase
 
169
 */
 
170
static void torture_privatekey_from_file(void **state) {
 
171
    ssh_session session = *state;
 
172
    ssh_private_key key = NULL;
 
173
 
 
174
    key = privatekey_from_file(session, LIBSSH_RSA_TESTKEY, SSH_KEYTYPE_RSA, NULL);
 
175
    assert_true(key != NULL);
 
176
    if (key != NULL) {
 
177
        privatekey_free(key);
 
178
        key = NULL;
 
179
    }
 
180
 
 
181
    key = privatekey_from_file(session, LIBSSH_DSA_TESTKEY, SSH_KEYTYPE_DSS, NULL);
 
182
    assert_true(key != NULL);
 
183
    if (key != NULL) {
 
184
        privatekey_free(key);
 
185
        key = NULL;
 
186
    }
 
187
 
 
188
    /* Test the automatic type discovery */
 
189
    key = privatekey_from_file(session, LIBSSH_RSA_TESTKEY, 0, NULL);
 
190
    assert_true(key != NULL);
 
191
    if (key != NULL) {
 
192
        privatekey_free(key);
 
193
        key = NULL;
 
194
    }
 
195
 
 
196
    key = privatekey_from_file(session, LIBSSH_DSA_TESTKEY, 0, NULL);
 
197
    assert_true(key != NULL);
 
198
    if (key != NULL) {
 
199
        privatekey_free(key);
 
200
        key = NULL;
 
201
    }
 
202
}
 
203
 
 
204
/**
 
205
 * @brief tests the privatekey_from_file function with passphrase
 
206
 */
 
207
static void torture_privatekey_from_file_passphrase(void **state) {
 
208
    ssh_session session = *state;
 
209
    ssh_private_key key = NULL;
 
210
 
 
211
    key = privatekey_from_file(session, LIBSSH_RSA_TESTKEY, SSH_KEYTYPE_RSA, LIBSSH_PASSPHRASE);
 
212
    assert_true(key != NULL);
 
213
    if (key != NULL) {
 
214
        privatekey_free(key);
 
215
        key = NULL;
 
216
    }
 
217
 
 
218
    key = privatekey_from_file(session, LIBSSH_DSA_TESTKEY, SSH_KEYTYPE_DSS, LIBSSH_PASSPHRASE);
 
219
    assert_true(key != NULL);
 
220
    if (key != NULL) {
 
221
        privatekey_free(key);
 
222
        key = NULL;
 
223
    }
 
224
 
 
225
    /* Test the automatic type discovery */
 
226
    key = privatekey_from_file(session, LIBSSH_RSA_TESTKEY, 0, LIBSSH_PASSPHRASE);
 
227
    assert_true(key != NULL);
 
228
    if (key != NULL) {
 
229
        privatekey_free(key);
 
230
        key = NULL;
 
231
    }
 
232
 
 
233
    key = privatekey_from_file(session, LIBSSH_DSA_TESTKEY, 0, LIBSSH_PASSPHRASE);
 
234
    assert_true(key != NULL);
 
235
    if (key != NULL) {
 
236
        privatekey_free(key);
 
237
        key = NULL;
 
238
    }
 
239
}
 
240
 
 
241
int torture_run_tests(void) {
 
242
    int rc;
 
243
    const UnitTest tests[] = {
 
244
        unit_test_setup_teardown(torture_pubkey_from_file,
 
245
                                 setup_rsa_key,
 
246
                                 teardown),
 
247
        unit_test_setup_teardown(torture_pubkey_generate_from_privkey,
 
248
                                 setup_rsa_key, teardown),
 
249
        unit_test_setup_teardown(torture_privatekey_from_file,
 
250
                                 setup_both_keys,
 
251
                                 teardown),
 
252
        unit_test_setup_teardown(torture_privatekey_from_file_passphrase,
 
253
                                 setup_both_keys_passphrase, teardown),
 
254
    };
 
255
 
 
256
 
 
257
    ssh_init();
 
258
    rc=run_tests(tests);
 
259
    ssh_finalize();
 
260
    return rc;
 
261
}