Line data Source code
1 : /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
2 : /* test-secret-binary.c: Test binary keyring read and write
3 :
4 : Copyright (C) 2009 Stefan Walter
5 :
6 : The Gnome Keyring Library is free software; you can redistribute it and/or
7 : modify it under the terms of the GNU Library General Public License as
8 : published by the Free Software Foundation; either version 2 of the
9 : License, or (at your option) any later version.
10 :
11 : The Gnome Keyring Library is distributed in the hope that it will be useful,
12 : but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 : Library General Public License for more details.
15 :
16 : You should have received a copy of the GNU Library General Public
17 : License along with the Gnome Library; see the file COPYING.LIB. If not,
18 : <http://www.gnu.org/licenses/>.
19 :
20 : Author: Stef Walter <stef@memberwebs.com>
21 : */
22 :
23 : #include "config.h"
24 :
25 : #include "mock-secret-module.h"
26 :
27 : #include "secret-store/gkm-secret-binary.h"
28 : #include "secret-store/gkm-secret-collection.h"
29 : #include "secret-store/gkm-secret-data.h"
30 : #include "secret-store/gkm-secret-fields.h"
31 : #include "secret-store/gkm-secret-item.h"
32 :
33 : #include "gkm/gkm-secret.h"
34 :
35 : #include "pkcs11/pkcs11i.h"
36 :
37 : #include <glib.h>
38 :
39 : #include <stdlib.h>
40 : #include <stdio.h>
41 : #include <string.h>
42 :
43 : typedef struct {
44 : GkmModule *module;
45 : GkmSession *session;
46 : GkmSecretCollection *collection;
47 : GkmSecretData *sdata;
48 : } Test;
49 :
50 : static void
51 9 : setup (Test *test, gconstpointer unused)
52 : {
53 : GkmSecret *master;
54 :
55 9 : test->module = test_secret_module_initialize_and_enter ();
56 9 : test->session = test_secret_module_open_session (TRUE);
57 :
58 9 : test->collection = g_object_new (GKM_TYPE_SECRET_COLLECTION,
59 : "module", test->module,
60 : "identifier", "test",
61 : "label", "brigadooooooooooooon",
62 : NULL);
63 :
64 9 : test->sdata = g_object_new (GKM_TYPE_SECRET_DATA, NULL);
65 9 : master = gkm_secret_new_from_password ("my-keyring-password");
66 9 : gkm_secret_data_set_master (test->sdata, master);
67 9 : g_object_unref (master);
68 :
69 9 : g_assert (GKM_IS_SECRET_COLLECTION (test->collection));
70 :
71 9 : }
72 :
73 : static void
74 9 : teardown (Test *test, gconstpointer unused)
75 : {
76 9 : g_object_unref (test->collection);
77 9 : g_object_unref (test->sdata);
78 9 : test_secret_module_leave_and_finalize ();
79 9 : }
80 :
81 : static GkmDataResult
82 7 : check_read_keyring_file (Test *test, const gchar *path)
83 : {
84 : GkmDataResult res;
85 : gchar *data;
86 : gsize n_data;
87 :
88 7 : if (!g_file_get_contents (path, &data, &n_data, NULL))
89 0 : g_assert_not_reached ();
90 7 : res = gkm_secret_binary_read (test->collection, test->sdata, data, n_data);
91 7 : g_free (data);
92 :
93 7 : return res;
94 : }
95 :
96 :
97 : static void
98 1 : test_read_encrypted (Test *test, gconstpointer unused)
99 : {
100 : GkmDataResult res;
101 :
102 1 : res = check_read_keyring_file (test, SRCDIR "/pkcs11/secret-store/fixtures/encrypted.keyring");
103 1 : g_assert (res == GKM_DATA_SUCCESS);
104 :
105 1 : test_secret_collection_validate (test->collection, test->sdata);
106 1 : }
107 :
108 : static void
109 1 : test_read_wrong_format (Test *test, gconstpointer unused)
110 : {
111 : GkmDataResult res;
112 :
113 1 : res = check_read_keyring_file (test, SRCDIR "/pkcs11/secret-store/fixtures/plain.keyring");
114 1 : g_assert (res == GKM_DATA_UNRECOGNIZED);
115 1 : }
116 :
117 : static void
118 1 : test_read_wrong_master (Test *test, gconstpointer unused)
119 : {
120 : GkmDataResult res;
121 : GkmSecret *master;
122 :
123 1 : master = gkm_secret_new_from_password ("wrong");
124 1 : gkm_secret_data_set_master (test->sdata, master);
125 1 : g_object_unref (master);
126 :
127 1 : res = check_read_keyring_file (test, SRCDIR "/pkcs11/secret-store/fixtures/encrypted.keyring");
128 1 : g_assert (res == GKM_DATA_LOCKED);
129 1 : }
130 :
131 : static void
132 1 : test_read_sdata_but_no_master (Test *test, gconstpointer unused)
133 : {
134 : GkmDataResult res;
135 :
136 1 : gkm_secret_data_set_master (test->sdata, NULL);
137 :
138 1 : res = check_read_keyring_file (test, SRCDIR "/pkcs11/secret-store/fixtures/encrypted.keyring");
139 1 : g_assert (res == GKM_DATA_LOCKED);
140 1 : }
141 :
142 : static void
143 1 : test_write (Test *test, gconstpointer unused)
144 : {
145 : GkmDataResult res;
146 : gpointer data;
147 : gsize n_data;
148 :
149 1 : test_secret_collection_populate (test->collection, test->sdata);
150 :
151 1 : res = gkm_secret_binary_write (test->collection, test->sdata, &data, &n_data);
152 1 : g_assert (res == GKM_DATA_SUCCESS);
153 1 : g_assert (data);
154 1 : g_assert (n_data);
155 :
156 : /* Try parsing it again */
157 1 : res = gkm_secret_binary_read (test->collection, test->sdata, data, n_data);
158 1 : g_assert (res == GKM_DATA_SUCCESS);
159 1 : g_free (data);
160 1 : }
161 :
162 : static void
163 1 : test_remove_unavailable (Test *test, gconstpointer unused)
164 : {
165 : GkmDataResult res;
166 : GList *items;
167 : gchar *data;
168 : gsize n_data;
169 :
170 1 : if (!g_file_get_contents (SRCDIR "/pkcs11/secret-store/fixtures/encrypted.keyring", &data, &n_data, NULL))
171 0 : g_assert_not_reached ();
172 1 : res = gkm_secret_binary_read (test->collection, test->sdata, data, n_data);
173 1 : g_assert (res == GKM_DATA_SUCCESS);
174 :
175 : /* Two items from the file */
176 1 : items = gkm_secret_collection_get_items (test->collection);
177 1 : g_assert_cmpint (g_list_length (items), ==, 2);
178 1 : g_list_free (items);
179 :
180 : /* Fill in some more data */
181 1 : test_secret_collection_populate (test->collection, test->sdata);
182 :
183 : /* Should have added three more */
184 1 : items = gkm_secret_collection_get_items (test->collection);
185 1 : g_assert_cmpint (g_list_length (items), ==, 5);
186 1 : g_list_free (items);
187 :
188 : /* Re-read the keyring */
189 1 : res = gkm_secret_binary_read (test->collection, test->sdata, data, n_data);
190 1 : g_assert (res == GKM_DATA_SUCCESS);
191 :
192 : /* And we're back to two */
193 1 : items = gkm_secret_collection_get_items (test->collection);
194 1 : g_assert_cmpint (g_list_length (items), ==, 2);
195 1 : g_list_free (items);
196 :
197 1 : g_free (data);
198 1 : }
199 :
200 : static void
201 1 : test_read_created_on_solaris_opencsw (Test *test, gconstpointer unused)
202 : {
203 : GkmDataResult res;
204 : GkmSecret *master;
205 :
206 1 : master = gkm_secret_new_from_password ("test");
207 1 : gkm_secret_data_set_master (test->sdata, master);
208 1 : g_object_unref (master);
209 :
210 1 : res = check_read_keyring_file (test, SRCDIR "/pkcs11/secret-store/fixtures/created-on-solaris-opencsw.keyring");
211 1 : g_assert_cmpint (res, ==, GKM_DATA_SUCCESS);
212 1 : }
213 :
214 : static void
215 1 : test_read_created_on_rhel (Test *test, gconstpointer unused)
216 : {
217 : GkmDataResult res;
218 : GkmSecret *master;
219 :
220 1 : master = gkm_secret_new_from_password ("test");
221 1 : gkm_secret_data_set_master (test->sdata, master);
222 1 : g_object_unref (master);
223 :
224 1 : res = check_read_keyring_file (test, SRCDIR "/pkcs11/secret-store/fixtures/created-on-rhel.keyring");
225 1 : g_assert_cmpint (res, ==, GKM_DATA_SUCCESS);
226 1 : }
227 :
228 : static void
229 1 : test_read_with_schema (Test *test,
230 : gconstpointer unused)
231 : {
232 : GkmDataResult res;
233 : GkmSecret *master;
234 : GkmSecretItem *item;
235 :
236 1 : master = gkm_secret_new_from_password ("test");
237 1 : gkm_secret_data_set_master (test->sdata, master);
238 1 : g_object_unref (master);
239 1 : res = check_read_keyring_file (test, SRCDIR "/pkcs11/secret-store/fixtures/encrypted-with-schema.keyring");
240 1 : g_assert_cmpint (res, ==, GKM_DATA_SUCCESS);
241 :
242 1 : item = gkm_secret_collection_get_item (test->collection, "1");
243 1 : g_assert (item != NULL);
244 :
245 1 : g_assert_cmpstr (gkm_secret_item_get_schema (item), ==, "se.lostca.is.rishi.secret");
246 1 : }
247 :
248 : int
249 1 : main (int argc, char **argv)
250 : {
251 : #if !GLIB_CHECK_VERSION(2,35,0)
252 : g_type_init ();
253 : #endif
254 1 : g_test_init (&argc, &argv, NULL);
255 :
256 1 : g_test_add ("/secret-store/binary/read_encrypted", Test, NULL, setup, test_read_encrypted, teardown);
257 1 : g_test_add ("/secret-store/binary/read_wrong_format", Test, NULL, setup, test_read_wrong_format, teardown);
258 1 : g_test_add ("/secret-store/binary/read_wrong_master", Test, NULL, setup, test_read_wrong_master, teardown);
259 1 : g_test_add ("/secret-store/binary/read_sdata_but_no_master", Test, NULL, setup, test_read_sdata_but_no_master, teardown);
260 1 : g_test_add ("/secret-store/binary/write", Test, NULL, setup, test_write, teardown);
261 1 : g_test_add ("/secret-store/binary/remove_unavailable", Test, NULL, setup, test_remove_unavailable, teardown);
262 1 : g_test_add ("/secret-store/binary/created_on_rhel", Test, NULL, setup, test_read_created_on_rhel, teardown);
263 1 : g_test_add ("/secret-store/binary/created_on_solaris_opencsw", Test, NULL, setup, test_read_created_on_solaris_opencsw, teardown);
264 1 : g_test_add ("/secret-store/binary/read_with_schema", Test, NULL, setup, test_read_with_schema, teardown);
265 :
266 1 : return g_test_run ();
267 : }
|
