1 // gnoMint: a graphical interface for managing a certification authority
2 // Copyright (C) 2006-2009 David Marín Carreño <davefx@gmail.com>
3 //
4 // This file is part of gnoMint.
5 //
6 // gnoMint is free software; you can redistribute it and/or modify
7 // it under the terms of the GNU General Public License as published by
8 // the Free Software Foundation; either version 3 of the License, or
9 // (at your option) any later version.
10 //
11 // This program 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
14 // GNU General Public License for more details.
15 //
16 // You should have received a copy of the GNU General Public License
17 // along with this program; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19
20 #ifndef GNOMINTCLI
21
22
23 #include <glib-object.h>
24 #include <gtk/gtk.h>
25 #include <gdk/gdk.h>
26 #include <glib/gi18n.h>
27
28 #endif
29
30 #include <stdlib.h>
31 #include <string.h>
32
33
34 #include "ca.h"
35 #include "ca_file.h"
36 #include "certificate_properties.h"
37 #include "crl.h"
38 #include "csr_properties.h"
39 #include "dialog.h"
40 #include "export.h"
41 #include "new_ca_window.h"
42 #include "new_req_window.h"
43 #include "new_cert.h"
44 #include "preferences-gui.h"
45 #include "preferences-window.h"
46 #include "import.h"
47
48 #ifndef GNOMINTCLI
49
50 #define GNOMINT_MIME_TYPE "application/x-gnomint"
51
52
53 enum {CA_MODEL_COLUMN_ID=0,
54 CA_MODEL_COLUMN_IS_CA=1,
55 CA_MODEL_COLUMN_SERIAL=2,
56 CA_MODEL_COLUMN_SUBJECT=3,
57 CA_MODEL_COLUMN_ACTIVATION=4,
58 CA_MODEL_COLUMN_EXPIRATION=5,
59 CA_MODEL_COLUMN_REVOCATION=6,
60 CA_MODEL_COLUMN_PRIVATE_KEY_IN_DB=7,
61 CA_MODEL_COLUMN_PEM=8,
62 CA_MODEL_COLUMN_DN=9,
63 CA_MODEL_COLUMN_PARENT_DN=10,
64 CA_MODEL_COLUMN_PARENT_ROUTE=11,
65 CA_MODEL_COLUMN_ITEM_TYPE=12,
66 CA_MODEL_COLUMN_PARENT_ID=13, /* Only for CSRs */
67 CA_MODEL_COLUMN_NUMBER=14}
68 CaModelColumns;
69
70 enum {CSR_MODEL_COLUMN_ID=0,
71 CSR_MODEL_COLUMN_SUBJECT=1,
72 CSR_MODEL_COLUMN_PRIVATE_KEY_IN_DB=2,
73 CSR_MODEL_COLUMN_PEM=3,
74 CSR_MODEL_COLUMN_PARENT_ID=4,
75 CSR_MODEL_COLUMN_NUMBER=5}
76 CsrModelColumns;
77
78
79
80
81 extern GtkBuilder * main_window_gtkb;
82 extern GtkBuilder * cert_popup_menu_gtkb;
83 extern GtkBuilder * csr_popup_menu_gtkb;
84
85
86 static GtkTreeStore * ca_model = NULL;
87 static gboolean cert_title_inserted = FALSE;
88 static GtkTreeIter * cert_parent_iter = NULL;
89 static GtkTreeIter * last_parent_iter = NULL;
90 static GtkTreeIter * last_cert_iter = NULL;
91 static gboolean csr_title_inserted=FALSE;
92 static GtkTreeIter * csr_parent_iter = NULL;
93
94 static gboolean view_csr = TRUE;
95 static gboolean view_rcrt = TRUE;
96
97
98 int __ca_refresh_model_add_certificate (void *pArg, int argc, char **argv, char **columnNames);
99 int __ca_refresh_model_add_csr (void *pArg, int argc, char **argv, char **columnNames);
100 void __ca_tree_view_date_datafunc (GtkTreeViewColumn *tree_column,
101 GtkCellRenderer *cell,
102 GtkTreeModel *tree_model,
103 GtkTreeIter *iter,
104 gpointer data);
105 void __ca_tree_view_is_ca_datafunc (GtkTreeViewColumn *tree_column,
106 GtkCellRenderer *cell,
107 GtkTreeModel *tree_model,
108 GtkTreeIter *iter,
109 gpointer data);
110 void __ca_tree_view_private_key_in_db_datafunc (GtkTreeViewColumn *tree_column,
111 GtkCellRenderer *cell,
112 GtkTreeModel *tree_model,
113 GtkTreeIter *iter,
114 gpointer data);
115 void __ca_certificate_activated (GtkTreeView *tree_view,
116 GtkTreePath *path,
117 GtkTreeViewColumn *column,
118 gpointer user_data);
119 void __ca_csr_activated (GtkTreeView *tree_view,
120 GtkTreePath *path,
121 GtkTreeViewColumn *column,
122 gpointer user_data);
123 void __ca_activate_certificate_selection (GtkTreeIter *iter);
124 void __ca_activate_csr_selection (GtkTreeIter *iter);
125 void __ca_deactivate_actions (void);
126 gint __ca_selection_type (GtkTreeView *tree_view, GtkTreeIter **iter);
127 void __ca_export_public_pem (GtkTreeIter *iter, gint type);
128 gchar * __ca_export_private_pkcs8 (GtkTreeIter *iter, gint type);
129 void __ca_export_private_pem (GtkTreeIter *iter, gint type);
130 void __ca_export_pkcs12 (GtkTreeIter *iter, gint type);
131
132 void __disable_widget (gchar *widget_name);
133 void __enable_widget (gchar *widget_name);
134
135
__ca_refresh_model_add_certificate(void * pArg,int argc,char ** argv,char ** columnNames)136 int __ca_refresh_model_add_certificate (void *pArg, int argc, char **argv, char **columnNames)
137 {
138 GtkTreeIter iter;
139 GtkTreeStore * new_model = GTK_TREE_STORE (pArg);
140 GValue *last_id_value = g_new0 (GValue, 1);
141 GValue *last_parent_route_value = g_new0 (GValue, 1);
142 guint64 uint64_value;
143 const gchar * string_value;
144 gchar * last_node_route = NULL;
145
146 if (cert_title_inserted == FALSE) {
147 gtk_tree_store_append (new_model, &iter, NULL);
148 gtk_tree_store_set (new_model, &iter,
149 3, _("<b>Certificates</b>"),
150 -1);
151 cert_parent_iter = gtk_tree_iter_copy (&iter);
152 cert_title_inserted = TRUE;
153 }
154
155 if (! last_cert_iter || (! strcmp (argv[CA_FILE_CERT_COLUMN_PARENT_ROUTE],":"))) {
156 if (last_parent_iter)
157 gtk_tree_iter_free (last_parent_iter);
158 last_parent_iter = NULL;
159 } else {
160 // If not, then we must find the parent of the current node
161 gtk_tree_model_get_value (GTK_TREE_MODEL(new_model), last_cert_iter, CA_MODEL_COLUMN_ID, last_id_value);
162 gtk_tree_model_get_value (GTK_TREE_MODEL(new_model), last_cert_iter, CA_MODEL_COLUMN_PARENT_ROUTE,
163 last_parent_route_value);
164
165 uint64_value = g_value_get_uint64 (last_id_value);
166 string_value = g_value_get_string (last_parent_route_value);
167 g_assert (string_value);
168
169 last_node_route = g_strdup_printf ("%s%"G_GUINT64_FORMAT":", string_value, uint64_value);
170
171 if (! strcmp (argv[CA_FILE_CERT_COLUMN_PARENT_ROUTE], last_node_route)) {
172 // Last node is parent of the current node
173 if (last_parent_iter)
174 gtk_tree_iter_free (last_parent_iter);
175 last_parent_iter = gtk_tree_iter_copy (last_cert_iter);
176 g_free (last_node_route);
177 last_node_route = NULL;
178 } else {
179 // We go back in the hierarchical tree, starting in the current parent, until we find the parent of the
180 // current certificate.
181
182 if (last_parent_iter)
183 gtk_tree_iter_free (last_parent_iter);
184 last_parent_iter = gtk_tree_iter_copy (last_cert_iter);
185
186 while (last_node_route &&
187 strcmp (argv[CA_FILE_CERT_COLUMN_PARENT_ROUTE], last_node_route)) {
188
189 g_free (last_node_route);
190 last_node_route = NULL;
191
192 if (! gtk_tree_model_iter_parent(GTK_TREE_MODEL(new_model), &iter, last_parent_iter)) {
193 // Last ca iter is a top_level
194 if (last_parent_iter)
195 gtk_tree_iter_free (last_parent_iter);
196 last_parent_iter = NULL;
197 } else {
198 if (last_parent_iter)
199 gtk_tree_iter_free (last_parent_iter);
200 last_parent_iter = gtk_tree_iter_copy (&iter);
201
202 g_value_unset (last_parent_route_value);
203 g_value_unset (last_id_value);
204
205 gtk_tree_model_get_value (GTK_TREE_MODEL(new_model), last_parent_iter, CA_MODEL_COLUMN_ID, last_id_value);
206 gtk_tree_model_get_value (GTK_TREE_MODEL(new_model), last_parent_iter, CA_MODEL_COLUMN_PARENT_ROUTE,
207 last_parent_route_value);
208
209 uint64_value = g_value_get_uint64 (last_id_value);
210 string_value = g_value_get_string (last_parent_route_value);
211 if (string_value != NULL)
212 last_node_route = g_strdup_printf ("%s%"G_GUINT64_FORMAT":", string_value, uint64_value);
213 else
214 last_node_route = NULL;
215 }
216
217 }
218
219 if (last_node_route)
220 g_free (last_node_route);
221 }
222
223 }
224
225 gtk_tree_store_append (new_model, &iter, (last_parent_iter ? last_parent_iter: cert_parent_iter));
226
227 if (! argv[CA_FILE_CERT_COLUMN_REVOCATION])
228 gtk_tree_store_set (new_model, &iter,
229 CA_MODEL_COLUMN_ID, atoll(argv[CA_FILE_CERT_COLUMN_ID]),
230 CA_MODEL_COLUMN_IS_CA, atoi(argv[CA_FILE_CERT_COLUMN_IS_CA]),
231 CA_MODEL_COLUMN_SERIAL, argv[CA_FILE_CERT_COLUMN_SERIAL],
232 CA_MODEL_COLUMN_SUBJECT, argv[CA_FILE_CERT_COLUMN_SUBJECT],
233 CA_MODEL_COLUMN_ACTIVATION, atoi(argv[CA_FILE_CERT_COLUMN_ACTIVATION]),
234 CA_MODEL_COLUMN_EXPIRATION, atoi(argv[CA_FILE_CERT_COLUMN_EXPIRATION]),
235 CA_MODEL_COLUMN_REVOCATION, 0,
236 CA_MODEL_COLUMN_PRIVATE_KEY_IN_DB, atoi(argv[CA_FILE_CERT_COLUMN_PRIVATE_KEY_IN_DB]),
237 CA_MODEL_COLUMN_PEM, argv[CA_FILE_CERT_COLUMN_PEM],
238 CA_MODEL_COLUMN_DN, argv[CA_FILE_CERT_COLUMN_DN],
239 CA_MODEL_COLUMN_PARENT_DN, argv[CA_FILE_CERT_COLUMN_PARENT_DN],
240 CA_MODEL_COLUMN_PARENT_ROUTE, argv[CA_FILE_CERT_COLUMN_PARENT_ROUTE],
241 CA_MODEL_COLUMN_ITEM_TYPE, 0,
242 -1);
243 else {
244 gchar * revoked_subject = g_markup_printf_escaped ("<s>%s</s>",
245 argv[CA_FILE_CERT_COLUMN_SUBJECT]);
246
247 gtk_tree_store_set (new_model, &iter,
248 CA_MODEL_COLUMN_ID, atoll(argv[CA_FILE_CERT_COLUMN_ID]),
249 CA_MODEL_COLUMN_IS_CA, atoi(argv[CA_FILE_CERT_COLUMN_IS_CA]),
250 CA_MODEL_COLUMN_SERIAL, argv[CA_FILE_CERT_COLUMN_SERIAL],
251 CA_MODEL_COLUMN_SUBJECT, revoked_subject,
252 CA_MODEL_COLUMN_ACTIVATION, atoi(argv[CA_FILE_CERT_COLUMN_ACTIVATION]),
253 CA_MODEL_COLUMN_EXPIRATION, atoi(argv[CA_FILE_CERT_COLUMN_EXPIRATION]),
254 CA_MODEL_COLUMN_REVOCATION, atoi(argv[CA_FILE_CERT_COLUMN_REVOCATION]),
255 CA_MODEL_COLUMN_PRIVATE_KEY_IN_DB, atoi(argv[CA_FILE_CERT_COLUMN_PRIVATE_KEY_IN_DB]),
256 CA_MODEL_COLUMN_PEM, argv[CA_FILE_CERT_COLUMN_PEM],
257 CA_MODEL_COLUMN_DN, argv[CA_FILE_CERT_COLUMN_DN],
258 CA_MODEL_COLUMN_PARENT_DN, argv[CA_FILE_CERT_COLUMN_PARENT_DN],
259 CA_MODEL_COLUMN_PARENT_ROUTE, argv[CA_FILE_CERT_COLUMN_PARENT_ROUTE],
260 CA_MODEL_COLUMN_ITEM_TYPE, 0,
261 -1);
262
263 g_free (revoked_subject);
264 }
265
266
267 if (last_cert_iter)
268 gtk_tree_iter_free (last_cert_iter);
269 last_cert_iter = gtk_tree_iter_copy (&iter);
270
271 g_free (last_id_value);
272 g_free (last_parent_route_value);
273
274 return 0;
275 }
276
277
278
__ca_refresh_model_add_csr(void * pArg,int argc,char ** argv,char ** columnNames)279 int __ca_refresh_model_add_csr (void *pArg, int argc, char **argv, char **columnNames)
280 {
281 GtkTreeIter iter;
282 GtkTreeStore * new_model = GTK_TREE_STORE(pArg);
283
284 if (csr_title_inserted == 0) {
285 gtk_tree_store_append (new_model, &iter, NULL);
286 gtk_tree_store_set (new_model, &iter,
287 3, _("<b>Certificate Signing Requests</b>"),
288 -1);
289 csr_parent_iter = gtk_tree_iter_copy (&iter);
290 csr_title_inserted = TRUE;
291 }
292
293
294 gtk_tree_store_append (new_model, &iter, csr_parent_iter);
295
296 gtk_tree_store_set (new_model, &iter,
297 CA_MODEL_COLUMN_ID, atoll(argv[CA_FILE_CSR_COLUMN_ID]),
298 CA_MODEL_COLUMN_SUBJECT, argv[CA_FILE_CSR_COLUMN_SUBJECT],
299 CA_MODEL_COLUMN_PRIVATE_KEY_IN_DB, atoi(argv[CA_FILE_CSR_COLUMN_PRIVATE_KEY_IN_DB]),
300 CA_MODEL_COLUMN_PEM, argv[CA_FILE_CSR_COLUMN_PEM],
301 CA_MODEL_COLUMN_PARENT_ID, argv[CA_FILE_CSR_COLUMN_PARENT_ID],
302 CA_MODEL_COLUMN_ITEM_TYPE, 1,
303 -1);
304 return 0;
305 }
306
__ca_tree_view_date_datafunc(GtkTreeViewColumn * tree_column,GtkCellRenderer * cell,GtkTreeModel * tree_model,GtkTreeIter * iter,gpointer data)307 void __ca_tree_view_date_datafunc (GtkTreeViewColumn *tree_column,
308 GtkCellRenderer *cell,
309 GtkTreeModel *tree_model,
310 GtkTreeIter *iter,
311 gpointer data)
312 {
313 time_t model_time = 0;
314 #ifndef WIN32
315 struct tm model_time_tm;
316 #else
317 struct tm *model_time_tm = NULL;
318 #endif
319 gchar model_time_str[100];
320 gchar *result = NULL;
321 size_t size = 0;
322
323 gtk_tree_model_get(tree_model, iter, GPOINTER_TO_INT(data), &model_time, -1);
324
325 if (model_time == 0) {
326 g_object_set (G_OBJECT(cell), "text", "", NULL);
327 return;
328 }
329 #ifndef WIN32
330 gmtime_r (&model_time, &model_time_tm);
331 size = strftime (model_time_str, 100, _("%m/%d/%Y %R GMT"), &model_time_tm);
332 #else
333 model_time_tm = gmtime(&model_time);
334 size = strftime(model_time_str, 100, _("%m/%d/%Y %H:%M GMT"), model_time_tm);
335 #endif
336
337 result = g_strdup (model_time_str);
338
339 g_object_set(G_OBJECT(cell), "text", result, NULL);
340
341 g_free (result);
342 }
343
344
__ca_tree_view_is_ca_datafunc(GtkTreeViewColumn * tree_column,GtkCellRenderer * cell,GtkTreeModel * tree_model,GtkTreeIter * iter,gpointer data)345 void __ca_tree_view_is_ca_datafunc (GtkTreeViewColumn *tree_column,
346 GtkCellRenderer *cell,
347 GtkTreeModel *tree_model,
348 GtkTreeIter *iter,
349 gpointer data)
350 {
351 gboolean is_ca;
352 gchar *file = g_build_filename (PACKAGE_DATA_DIR, "gnomint", "ca-stamp-16.png", NULL);
353
354 static GdkPixbuf * is_ca_pixbuf = NULL;
355 static GdkPixbuf * null_pixbuf = NULL;
356 GError *gerror = NULL;
357
358 if (is_ca_pixbuf == NULL) {
359 is_ca_pixbuf = gdk_pixbuf_new_from_file (file, &gerror);
360
361 if (gerror)
362 g_print ("%s\n", gerror->message);
363 }
364
365 g_free (file);
366
367 if (null_pixbuf == NULL) {
368 null_pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, 1, 1);
369 }
370
371 gtk_tree_model_get(tree_model, iter, CA_MODEL_COLUMN_IS_CA, &is_ca, -1);
372
373 if (is_ca) {
374 g_object_set (G_OBJECT(cell), "pixbuf", is_ca_pixbuf, NULL);
375 } else {
376 g_object_set (G_OBJECT(cell), "pixbuf", null_pixbuf, NULL);
377 }
378 }
379
__ca_tree_view_private_key_in_db_datafunc(GtkTreeViewColumn * tree_column,GtkCellRenderer * cell,GtkTreeModel * tree_model,GtkTreeIter * iter,gpointer data)380 void __ca_tree_view_private_key_in_db_datafunc (GtkTreeViewColumn *tree_column,
381 GtkCellRenderer *cell,
382 GtkTreeModel *tree_model,
383 GtkTreeIter *iter,
384 gpointer data)
385 {
386 gboolean pk_indb;
387 gchar *file = g_build_filename (PACKAGE_DATA_DIR, "gnomint", "key-16.png", NULL);
388
389 static GdkPixbuf * pk_in_db_pixbuf = NULL;
390 static GdkPixbuf * null_pixbuf = NULL;
391 GError *gerror = NULL;
392
393 if (pk_in_db_pixbuf == NULL) {
394 pk_in_db_pixbuf = gdk_pixbuf_new_from_file (file, &gerror);
395
396 if (gerror)
397 g_print ("%s\n", gerror->message);
398 }
399
400 g_free (file);
401
402 if (null_pixbuf == NULL) {
403 null_pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, 1, 1);
404 }
405
406 gtk_tree_model_get(tree_model, iter, CA_MODEL_COLUMN_PRIVATE_KEY_IN_DB, &pk_indb, -1);
407
408 if (pk_indb) {
409 g_object_set (G_OBJECT(cell), "pixbuf", pk_in_db_pixbuf, NULL);
410 } else {
411 g_object_set (G_OBJECT(cell), "pixbuf", null_pixbuf, NULL);
412 }
413 }
414
415
416
ca_refresh_model_callback()417 gboolean ca_refresh_model_callback ()
418 {
419 GtkTreeStore * new_model = NULL;
420 GtkTreeView * treeview = NULL;
421 GtkCellRenderer * renderer = NULL;
422 GtkTreeViewColumn * column = NULL;
423
424 guint columns_number;
425
426 /* Models have these columns:
427 - Id
428 - Is CA
429 - Serial
430 - Subject
431 - Activation
432 - Expiration
433 - Revocation
434 - Private key is in DB
435 - PEM data
436 - DN
437 - Parent DN
438 - Parent route
439 - Item type
440 - Parent ID (only for CSR)
441 */
442
443 new_model = gtk_tree_store_new (CA_MODEL_COLUMN_NUMBER, G_TYPE_UINT64, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING,
444 G_TYPE_INT, G_TYPE_INT, G_TYPE_INT, G_TYPE_BOOLEAN, G_TYPE_STRING,
445 G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING);
446
447 cert_title_inserted = FALSE;
448 cert_parent_iter = NULL;
449 last_parent_iter = NULL;
450 last_cert_iter = NULL;
451 csr_title_inserted=FALSE;
452 csr_parent_iter = NULL;
453
454 ca_file_foreach_crt (__ca_refresh_model_add_certificate, view_rcrt, new_model);
455
456 if (view_csr)
457 ca_file_foreach_csr (__ca_refresh_model_add_csr, new_model);
458
459 treeview = GTK_TREE_VIEW(gtk_builder_get_object (main_window_gtkb, "ca_treeview"));
460
461 if (ca_model) {
462 GList * column_list;
463 g_object_unref (ca_model);
464
465 // Remove revocation column
466 column_list = gtk_tree_view_get_columns (treeview);
467 columns_number = g_list_length (column_list);
468 g_list_free (column_list);
469
470
471 } else {
472 /* GtkTooltips * table_tooltips = gtk_tooltips_new(); */
473 guint column_number;
474
475 /* There's no model assigned to the treeview yet, so we add its columns */
476
477 renderer = GTK_CELL_RENDERER(gtk_cell_renderer_text_new ());
478
479 column_number = gtk_tree_view_insert_column_with_attributes (treeview,
480 -1, _("Subject"), renderer,
481 "markup", CA_MODEL_COLUMN_SUBJECT,
482 NULL);
483
484 /* gtk_tooltips_set_tip (table_tooltips, GTK_WIDGET(gtk_tree_view_get_column(treeview, column_number - 1)), */
485 /* _("Subject of the certificate or request"), */
486 /* _("This is the distinguished name (DN) of the certificate or request")); */
487
488 renderer = GTK_CELL_RENDERER(gtk_cell_renderer_pixbuf_new ());
489
490 column_number = gtk_tree_view_insert_column_with_data_func (treeview,
491 -1, "", renderer,
492 __ca_tree_view_is_ca_datafunc,
493 NULL, NULL);
494
495 /* gtk_tooltips_set_tip (table_tooltips, GTK_WIDGET(gtk_tree_view_get_column(treeview, column_number - 1)), */
496 /* _("It's a CA certificate"), */
497 /* _("An icon in this column shows that the certificate is able to generate and sign " */
498 /* "new certificates.")); */
499
500 renderer = GTK_CELL_RENDERER(gtk_cell_renderer_pixbuf_new ());
501
502 column_number = gtk_tree_view_insert_column_with_data_func (treeview,
503 -1, "", renderer,
504 __ca_tree_view_private_key_in_db_datafunc,
505 NULL, NULL);
506
507 /* gtk_tooltips_set_tip (table_tooltips, GTK_WIDGET(gtk_tree_view_get_column(treeview, column_number - 1)), */
508 /* _("Private key kept in internal database"), */
509 /* _("An icon in this column shows that the private key related to the certificate " */
510 /* "is kept in the gnoMint database.")); */
511
512 renderer = GTK_CELL_RENDERER(gtk_cell_renderer_text_new ());
513
514 gtk_tree_view_insert_column_with_attributes (treeview,
515 -1, _("Serial"), renderer,
516 "markup", CA_MODEL_COLUMN_SERIAL,
517 NULL);
518
519 renderer = GTK_CELL_RENDERER(gtk_cell_renderer_text_new ());
520
521 gtk_tree_view_insert_column_with_data_func (treeview,
522 -1, _("Activation"), renderer,
523 __ca_tree_view_date_datafunc,
524 GINT_TO_POINTER(CA_MODEL_COLUMN_ACTIVATION), g_free);
525
526 renderer = GTK_CELL_RENDERER(gtk_cell_renderer_text_new ());
527
528 gtk_tree_view_insert_column_with_data_func (treeview,
529 -1, _("Expiration"), renderer,
530 __ca_tree_view_date_datafunc,
531 GINT_TO_POINTER(CA_MODEL_COLUMN_EXPIRATION), g_free);
532
533 renderer = GTK_CELL_RENDERER(gtk_cell_renderer_text_new ());
534
535 columns_number = gtk_tree_view_insert_column_with_data_func (treeview,
536 -1, _("Revocation"), renderer,
537 __ca_tree_view_date_datafunc,
538 GINT_TO_POINTER(CA_MODEL_COLUMN_REVOCATION),
539 g_free);
540
541
542 }
543
544 column = gtk_tree_view_get_column(treeview, columns_number - 1);
545
546 gtk_tree_view_column_set_visible (column, view_rcrt);
547
548 gtk_tree_view_set_model (treeview, GTK_TREE_MODEL(new_model));
549 ca_model = new_model;
550
551 gtk_tree_view_expand_all (treeview);
552
553 return TRUE;
554 }
555
__ca_certificate_activated(GtkTreeView * tree_view,GtkTreePath * path,GtkTreeViewColumn * column,gpointer user_data)556 void __ca_certificate_activated (GtkTreeView *tree_view,
557 GtkTreePath *path,
558 GtkTreeViewColumn *column,
559 gpointer user_data)
560 {
561 GValue * valueid = g_new0 (GValue, 1);
562 GValue * valuestr = g_new0 (GValue, 1);
563 GValue * value_pkey_in_db = g_new0 (GValue, 1);
564 GValue * value_is_ca = g_new0 (GValue, 1);
565 GtkTreeIter iter;
566 GtkTreeModel * tree_model = gtk_tree_view_get_model (tree_view);
567
568 gtk_tree_model_get_iter (tree_model, &iter, path);
569 gtk_tree_model_get_value (tree_model, &iter, CA_MODEL_COLUMN_ID, valueid);
570 gtk_tree_model_get_value (tree_model, &iter, CA_MODEL_COLUMN_PEM, valuestr);
571 gtk_tree_model_get_value (tree_model, &iter, CA_MODEL_COLUMN_PRIVATE_KEY_IN_DB, value_pkey_in_db);
572 gtk_tree_model_get_value (tree_model, &iter, CA_MODEL_COLUMN_IS_CA, value_is_ca);
573
574 certificate_properties_display (g_value_get_uint64 (valueid),
575 g_value_get_string(valuestr), g_value_get_boolean(value_pkey_in_db),
576 g_value_get_boolean (value_is_ca));
577
578 g_free (valuestr);
579 g_free (value_pkey_in_db);
580 g_free (value_is_ca);
581 }
582
__ca_csr_activated(GtkTreeView * tree_view,GtkTreePath * path,GtkTreeViewColumn * column,gpointer user_data)583 void __ca_csr_activated (GtkTreeView *tree_view,
584 GtkTreePath *path,
585 GtkTreeViewColumn *column,
586 gpointer user_data)
587 {
588 GValue * value = g_new0 (GValue, 1);
589 GValue * valuebool = g_new0 (GValue, 1);
590 GtkTreeIter iter;
591 GtkTreeModel * tree_model = gtk_tree_view_get_model (tree_view);
592
593 gtk_tree_model_get_iter (tree_model, &iter, path);
594 gtk_tree_model_get_value (tree_model, &iter, CA_MODEL_COLUMN_PEM, value);
595 gtk_tree_model_get_value (tree_model, &iter, CA_MODEL_COLUMN_PRIVATE_KEY_IN_DB, valuebool);
596
597 csr_properties_display (g_value_get_string(value), g_value_get_boolean (valuebool));
598
599 free (value);
600 free (valuebool);
601 }
602
603
604
ca_treeview_row_activated(GtkTreeView * tree_view,GtkTreePath * path,GtkTreeViewColumn * column,gpointer user_data)605 G_MODULE_EXPORT gboolean ca_treeview_row_activated (GtkTreeView *tree_view,
606 GtkTreePath *path,
607 GtkTreeViewColumn *column,
608 gpointer user_data)
609 {
610
611 GtkTreePath *parent = NULL;
612
613 if (tree_view == NULL) {
614 GtkTreeSelection *selection;
615 GtkTreeIter selection_iter;
616
617 tree_view = GTK_TREE_VIEW(gtk_builder_get_object (main_window_gtkb, "ca_treeview"));
618 selection = gtk_tree_view_get_selection (tree_view);
619
620 if (gtk_tree_selection_count_selected_rows (selection) != 1)
621 return FALSE;
622
623 gtk_tree_selection_get_selected (selection, NULL, &selection_iter);
624 path = gtk_tree_model_get_path (gtk_tree_view_get_model(tree_view), &selection_iter);
625
626
627 }
628
629 parent = gtk_tree_model_get_path (gtk_tree_view_get_model(tree_view), cert_parent_iter);
630 if (gtk_tree_path_is_ancestor (parent, path) && gtk_tree_path_compare (parent, path)) {
631 __ca_certificate_activated (tree_view, path, column, user_data);
632 } else {
633 gtk_tree_path_free (parent);
634
635 parent = gtk_tree_model_get_path (gtk_tree_view_get_model(tree_view), csr_parent_iter);
636 if (gtk_tree_path_is_ancestor (parent, path) && gtk_tree_path_compare (parent, path)) {
637 __ca_csr_activated (tree_view, path, column, user_data);
638 }
639 }
640 gtk_tree_path_free (parent);
641
642 return FALSE;
643
644 }
645
646
__ca_activate_certificate_selection(GtkTreeIter * iter)647 void __ca_activate_certificate_selection (GtkTreeIter *iter)
648 {
649 GObject *widget;
650 gboolean is_ca = FALSE;
651 gboolean pk_indb = FALSE;
652 gint is_revoked = FALSE;
653
654 widget = gtk_builder_get_object (main_window_gtkb, "export1");
655 gtk_widget_set_sensitive (GTK_WIDGET(widget), TRUE);
656
657 gtk_tree_model_get(GTK_TREE_MODEL(ca_model), iter,
658 CA_MODEL_COLUMN_IS_CA, &is_ca,
659 CA_MODEL_COLUMN_PRIVATE_KEY_IN_DB, &pk_indb,
660 CA_MODEL_COLUMN_REVOCATION, &is_revoked, -1);
661
662 widget = gtk_builder_get_object (main_window_gtkb, "extractprivatekey1");
663 gtk_widget_set_sensitive (GTK_WIDGET(widget), pk_indb);
664 widget = gtk_builder_get_object (main_window_gtkb, "extractpkey_toolbutton");
665 gtk_widget_set_sensitive (GTK_WIDGET(widget), pk_indb);
666
667 widget = gtk_builder_get_object (main_window_gtkb, "revoke1");
668 gtk_widget_set_sensitive (GTK_WIDGET(widget), (! is_revoked));
669 widget = gtk_builder_get_object (main_window_gtkb, "revoke_toolbutton");
670 gtk_widget_set_sensitive (GTK_WIDGET(widget), (! is_revoked));
671
672
673 widget = gtk_builder_get_object (main_window_gtkb, "sign1");
674 gtk_widget_set_sensitive (GTK_WIDGET(widget), FALSE);
675 widget = gtk_builder_get_object (main_window_gtkb, "sign_toolbutton");
676 gtk_widget_set_sensitive (GTK_WIDGET(widget), FALSE);
677
678 widget = gtk_builder_get_object (main_window_gtkb, "delete2");
679 gtk_widget_set_sensitive (GTK_WIDGET(widget), FALSE);
680 widget = gtk_builder_get_object (main_window_gtkb, "delete_toolbutton");
681 gtk_widget_set_sensitive (GTK_WIDGET(widget), FALSE);
682
683 widget = gtk_builder_get_object (main_window_gtkb, "properties1");
684 gtk_widget_set_sensitive (GTK_WIDGET(widget), TRUE);
685
686
687 }
688
__ca_activate_csr_selection(GtkTreeIter * iter)689 void __ca_activate_csr_selection (GtkTreeIter *iter)
690 {
691 GObject *widget;
692 gboolean pk_indb = FALSE;
693
694 widget = gtk_builder_get_object (main_window_gtkb, "export1");
695 gtk_widget_set_sensitive (GTK_WIDGET(widget), TRUE);
696
697 gtk_tree_model_get(GTK_TREE_MODEL(ca_model), iter, CA_MODEL_COLUMN_PRIVATE_KEY_IN_DB, &pk_indb, -1);
698
699 widget = gtk_builder_get_object (main_window_gtkb, "extractprivatekey1");
700 gtk_widget_set_sensitive (GTK_WIDGET(widget), pk_indb);
701 widget = gtk_builder_get_object (main_window_gtkb, "extractpkey_toolbutton");
702 gtk_widget_set_sensitive (GTK_WIDGET(widget), pk_indb);
703
704 widget = gtk_builder_get_object (main_window_gtkb, "revoke1");
705 gtk_widget_set_sensitive (GTK_WIDGET(widget), FALSE);
706 widget = gtk_builder_get_object (main_window_gtkb, "revoke_toolbutton");
707 gtk_widget_set_sensitive (GTK_WIDGET(widget), FALSE);
708
709 widget = gtk_builder_get_object (main_window_gtkb, "sign1");
710 gtk_widget_set_sensitive (GTK_WIDGET(widget), TRUE);
711 widget = gtk_builder_get_object (main_window_gtkb, "sign_toolbutton");
712 gtk_widget_set_sensitive (GTK_WIDGET(widget), TRUE);
713
714 widget = gtk_builder_get_object (main_window_gtkb, "delete2");
715 gtk_widget_set_sensitive (GTK_WIDGET(widget), TRUE);
716 widget = gtk_builder_get_object (main_window_gtkb, "delete_toolbutton");
717 gtk_widget_set_sensitive (GTK_WIDGET(widget), TRUE);
718
719 widget = gtk_builder_get_object (main_window_gtkb, "properties1");
720 gtk_widget_set_sensitive (GTK_WIDGET(widget), TRUE);
721 }
722
__ca_deactivate_actions()723 void __ca_deactivate_actions ()
724 {
725 GObject *widget;
726
727 widget = gtk_builder_get_object (main_window_gtkb, "export1");
728 gtk_widget_set_sensitive (GTK_WIDGET(widget), FALSE);
729
730 widget = gtk_builder_get_object (main_window_gtkb, "extractprivatekey1");
731 gtk_widget_set_sensitive (GTK_WIDGET(widget), FALSE);
732 widget = gtk_builder_get_object (main_window_gtkb, "extractpkey_toolbutton");
733 gtk_widget_set_sensitive (GTK_WIDGET(widget), FALSE);
734
735 widget = gtk_builder_get_object (main_window_gtkb, "revoke1");
736 gtk_widget_set_sensitive (GTK_WIDGET(widget), FALSE);
737 widget = gtk_builder_get_object (main_window_gtkb, "revoke_toolbutton");
738 gtk_widget_set_sensitive (GTK_WIDGET(widget), FALSE);
739
740 widget = gtk_builder_get_object (main_window_gtkb, "sign1");
741 gtk_widget_set_sensitive (GTK_WIDGET(widget), FALSE);
742 widget = gtk_builder_get_object (main_window_gtkb, "sign_toolbutton");
743 gtk_widget_set_sensitive (GTK_WIDGET(widget), FALSE);
744
745 widget = gtk_builder_get_object (main_window_gtkb, "delete2");
746 gtk_widget_set_sensitive (GTK_WIDGET(widget), FALSE);
747 widget = gtk_builder_get_object (main_window_gtkb, "delete_toolbutton");
748 gtk_widget_set_sensitive (GTK_WIDGET(widget), FALSE);
749
750 widget = gtk_builder_get_object (main_window_gtkb, "properties1");
751 gtk_widget_set_sensitive (GTK_WIDGET(widget), FALSE);
752 }
753
__ca_selection_type(GtkTreeView * tree_view,GtkTreeIter ** iter)754 gint __ca_selection_type (GtkTreeView *tree_view, GtkTreeIter **iter) {
755
756 GtkTreeSelection *selection = gtk_tree_view_get_selection (tree_view);
757 GtkTreeIter selection_iter;
758 GtkTreePath *parent = NULL;
759 GtkTreePath *selection_path = NULL;
760
761 if (gtk_tree_selection_count_selected_rows (selection) != 1)
762 return -1;
763
764 gtk_tree_selection_get_selected (selection, NULL, &selection_iter);
765 if (iter)
766 (*iter) = gtk_tree_iter_copy (&selection_iter);
767
768 selection_path = gtk_tree_model_get_path (gtk_tree_view_get_model(tree_view), &selection_iter);
769
770 parent = gtk_tree_model_get_path (gtk_tree_view_get_model(tree_view), cert_parent_iter);
771 if (gtk_tree_path_is_ancestor (parent, selection_path) && gtk_tree_path_compare (parent, selection_path)) {
772 gtk_tree_path_free (parent);
773 /* It's a certificate */
774 return CA_FILE_ELEMENT_TYPE_CERT;
775 }
776
777 gtk_tree_path_free (parent);
778 parent = gtk_tree_model_get_path (gtk_tree_view_get_model(tree_view), csr_parent_iter);
779 if (gtk_tree_path_is_ancestor (parent, selection_path) && gtk_tree_path_compare (parent, selection_path)) {
780 gtk_tree_path_free (parent);
781 /* It's a CSR */
782 return CA_FILE_ELEMENT_TYPE_CSR;
783 }
784
785 gtk_tree_path_free (parent);
786 return -1;
787 }
788
ca_treeview_selection_change(GtkTreeView * tree_view,gpointer user_data)789 G_MODULE_EXPORT gboolean ca_treeview_selection_change (GtkTreeView *tree_view,
790 gpointer user_data)
791 {
792 GtkTreeIter *selection_iter;
793 switch (__ca_selection_type (tree_view, &selection_iter)) {
794 case CA_FILE_ELEMENT_TYPE_CERT:
795 __ca_activate_certificate_selection (selection_iter);
796 break;
797 case CA_FILE_ELEMENT_TYPE_CSR:
798 __ca_activate_csr_selection (selection_iter);
799 break;
800 case -1:
801 default:
802 __ca_deactivate_actions();
803 break;
804 }
805
806 return FALSE;
807 }
808
809
__ca_export_public_pem(GtkTreeIter * iter,gint type)810 void __ca_export_public_pem (GtkTreeIter *iter, gint type)
811 {
812 GObject *widget = NULL;
813 GIOChannel * file = NULL;
814 gchar * filename = NULL;
815 gchar * pem = NULL;
816 gchar * parent_route = NULL;
817 GtkDialog * dialog = NULL;
818 GError * error = NULL;
819
820 widget = gtk_builder_get_object (main_window_gtkb, "main_window1");
821
822 if (type == 1)
823 dialog = GTK_DIALOG (gtk_file_chooser_dialog_new (_("Export certificate"),
824 GTK_WINDOW(widget),
825 GTK_FILE_CHOOSER_ACTION_SAVE,
826 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
827 GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
828 NULL));
829 else
830 dialog = GTK_DIALOG (gtk_file_chooser_dialog_new (_("Export certificate signing request"),
831 GTK_WINDOW(widget),
832 GTK_FILE_CHOOSER_ACTION_SAVE,
833 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
834 GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
835 NULL));
836
837 gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
838
839 if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) {
840 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
841 file = g_io_channel_new_file (filename, "w", &error);
842 if (error) {
843 gtk_widget_destroy (GTK_WIDGET(dialog));
844 if (type == 1)
845 dialog_error (_("There was an error while exporting certificate."));
846 else
847 dialog_error (_("There was an error while exporting CSR."));
848 return;
849 }
850
851 gtk_tree_model_get(GTK_TREE_MODEL(ca_model), iter, CA_MODEL_COLUMN_PEM, &pem, -1);
852 if (type == 1)
853 gtk_tree_model_get(GTK_TREE_MODEL(ca_model), iter, CA_MODEL_COLUMN_PARENT_ROUTE, &parent_route, -1);
854
855 g_io_channel_write_chars (file, pem, strlen(pem), NULL, &error);
856
857 if (parent_route && strcmp (parent_route, ":")) {
858 // The parent of the certificate is in the data base.
859 // We then export all the certificates up to the root, after the given certificate
860 // so it can be validated
861
862 gchar ** tokens = g_strsplit (parent_route, ":", -1);
863 // First and last tokens are always empty, as all parent ids start and end by ':'
864 guint num_tokens = g_strv_length (tokens) - 2;
865 gint i;
866
867 for (i=num_tokens; i>=1; i--) {
868 gchar * parent_pem = ca_file_get_public_pem_from_id (CA_FILE_ELEMENT_TYPE_CERT, atoll(tokens[i]));
869 if (parent_pem) {
870 g_io_channel_write_chars (file, parent_pem, strlen(parent_pem), NULL, &error);
871 g_free (parent_pem);
872 }
873 }
874
875 g_strfreev (tokens);
876 }
877
878 if (error) {
879 gtk_widget_destroy (GTK_WIDGET(dialog));
880 if (type == CA_FILE_ELEMENT_TYPE_CERT)
881 dialog_error (_("There was an error while exporting certificate."));
882 else
883 dialog_error (_("There was an error while exporting CSR."));
884 return;
885 }
886
887 g_io_channel_shutdown (file, TRUE, &error);
888 if (error) {
889 gtk_widget_destroy (GTK_WIDGET(dialog));
890 if (type == CA_FILE_ELEMENT_TYPE_CERT)
891 dialog_error (_("There was an error while exporting certificate."));
892 else
893 dialog_error (_("There was an error while exporting CSR."));
894 return;
895 }
896
897 g_io_channel_unref (file);
898
899 gtk_widget_destroy (GTK_WIDGET(dialog));
900 if (type == CA_FILE_ELEMENT_TYPE_CERT)
901 dialog = GTK_DIALOG(gtk_message_dialog_new (GTK_WINDOW(widget),
902 GTK_DIALOG_DESTROY_WITH_PARENT,
903 GTK_MESSAGE_INFO,
904 GTK_BUTTONS_CLOSE,
905 "%s",
906 _("Certificate exported successfully")));
907 else
908 dialog = GTK_DIALOG(gtk_message_dialog_new (GTK_WINDOW(widget),
909 GTK_DIALOG_DESTROY_WITH_PARENT,
910 GTK_MESSAGE_INFO,
911 GTK_BUTTONS_CLOSE,
912 "%s",
913 _("Certificate signing request exported successfully")));
914 gtk_dialog_run (GTK_DIALOG(dialog));
915
916 gtk_widget_destroy (GTK_WIDGET(dialog));
917
918 }
919 }
920
921
__ca_export_private_pkcs8(GtkTreeIter * iter,gint type)922 gchar * __ca_export_private_pkcs8 (GtkTreeIter *iter, gint type)
923 {
924 GObject *widget = NULL;
925 gchar * filename = NULL;
926 GtkDialog * dialog = NULL;
927 gint id;
928 gchar * strerror = NULL;
929
930 widget = gtk_builder_get_object (main_window_gtkb, "main_window1");
931
932 dialog = GTK_DIALOG (gtk_file_chooser_dialog_new (_("Export crypted private key"),
933 GTK_WINDOW(widget),
934 GTK_FILE_CHOOSER_ACTION_SAVE,
935 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
936 GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
937 NULL));
938
939 gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
940
941 if (gtk_dialog_run (GTK_DIALOG (dialog)) != GTK_RESPONSE_ACCEPT) {
942 gtk_widget_destroy (GTK_WIDGET(dialog));
943 return NULL;
944 }
945
946 filename = g_strdup(gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)));
947 gtk_widget_destroy (GTK_WIDGET(dialog));
948
949
950 gtk_tree_model_get(GTK_TREE_MODEL(ca_model), iter, CA_MODEL_COLUMN_ID, &id, -1);
951
952 strerror = export_private_pkcs8 (id, type, filename);
953
954 if (! strerror) {
955
956 dialog = GTK_DIALOG(gtk_message_dialog_new (GTK_WINDOW(widget),
957 GTK_DIALOG_DESTROY_WITH_PARENT,
958 GTK_MESSAGE_INFO,
959 GTK_BUTTONS_CLOSE,
960 "%s",
961 _("Private key exported successfully")));
962 gtk_dialog_run (GTK_DIALOG(dialog));
963
964 gtk_widget_destroy (GTK_WIDGET(dialog));
965 } else {
966 dialog_error (strerror);
967 }
968
969 return filename;
970 }
971
972
__ca_export_private_pem(GtkTreeIter * iter,gint type)973 void __ca_export_private_pem (GtkTreeIter *iter, gint type)
974 {
975 GObject *widget = NULL;
976 gchar * filename = NULL;
977 GtkDialog * dialog = NULL;
978 gint id;
979 gchar * error_msg = NULL;
980
981 widget = gtk_builder_get_object (main_window_gtkb, "main_window1");
982
983 dialog = GTK_DIALOG (gtk_file_chooser_dialog_new (_("Export uncrypted private key"),
984 GTK_WINDOW(widget),
985 GTK_FILE_CHOOSER_ACTION_SAVE,
986 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
987 GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
988 NULL));
989
990 gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
991
992 if (gtk_dialog_run (GTK_DIALOG (dialog)) != GTK_RESPONSE_ACCEPT) {
993 gtk_widget_destroy (GTK_WIDGET(dialog));
994 return;
995 }
996
997 filename = g_strdup(gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)));
998 gtk_widget_destroy (GTK_WIDGET(dialog));
999
1000 gtk_tree_model_get(GTK_TREE_MODEL(ca_model), iter, CA_MODEL_COLUMN_ID, &id, -1);
1001
1002 error_msg = export_private_pem (id, type, filename);
1003 g_free (filename);
1004
1005 if (error_msg) {
1006 dialog_error (error_msg);
1007 } else {
1008 dialog = GTK_DIALOG(gtk_message_dialog_new (GTK_WINDOW(widget),
1009 GTK_DIALOG_DESTROY_WITH_PARENT,
1010 GTK_MESSAGE_INFO,
1011 GTK_BUTTONS_CLOSE,
1012 "%s",
1013 _("Private key exported successfully")));
1014 gtk_dialog_run (GTK_DIALOG(dialog));
1015
1016 gtk_widget_destroy (GTK_WIDGET(dialog));
1017 }
1018
1019 }
1020
1021
__ca_export_pkcs12(GtkTreeIter * iter,gint type)1022 void __ca_export_pkcs12 (GtkTreeIter *iter, gint type)
1023 {
1024 GObject *widget = NULL;
1025 gchar * filename = NULL;
1026 GtkDialog * dialog = NULL;
1027 gint id;
1028
1029 gchar *error_msg = NULL;
1030
1031 widget = gtk_builder_get_object (main_window_gtkb, "main_window1");
1032
1033 dialog = GTK_DIALOG (gtk_file_chooser_dialog_new
1034 (_("Export whole certificate in PKCS#12 package"),
1035 GTK_WINDOW(widget),
1036 GTK_FILE_CHOOSER_ACTION_SAVE,
1037 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1038 GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
1039 NULL));
1040
1041 gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
1042
1043 if (gtk_dialog_run (GTK_DIALOG (dialog)) != GTK_RESPONSE_ACCEPT) {
1044 gtk_widget_destroy (GTK_WIDGET(dialog));
1045 return;
1046 }
1047
1048 filename = g_strdup(gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)));
1049 gtk_widget_destroy (GTK_WIDGET(dialog));
1050 gtk_tree_model_get(GTK_TREE_MODEL(ca_model), iter, CA_MODEL_COLUMN_ID, &id, -1);
1051
1052 error_msg = export_pkcs12 (id, type, filename);
1053
1054 g_free (filename);
1055
1056 if (error_msg && strlen(error_msg)) {
1057 dialog_error (error_msg);
1058 return;
1059 }
1060
1061 if (error_msg) {
1062 // Export cancelled by user
1063 return;
1064 }
1065
1066
1067 dialog = GTK_DIALOG(gtk_message_dialog_new (GTK_WINDOW(widget),
1068 GTK_DIALOG_DESTROY_WITH_PARENT,
1069 GTK_MESSAGE_INFO,
1070 GTK_BUTTONS_CLOSE,
1071 "%s",
1072 _("Certificate exported successfully")));
1073 gtk_dialog_run (GTK_DIALOG(dialog));
1074
1075 gtk_widget_destroy (GTK_WIDGET(dialog));
1076
1077
1078 }
1079
1080
ca_on_export1_activate(GtkMenuItem * menuitem,gpointer user_data)1081 G_MODULE_EXPORT void ca_on_export1_activate (GtkMenuItem *menuitem, gpointer user_data)
1082 {
1083 GObject * widget = NULL;
1084 //GtkDialog * dialog = NULL;
1085 GtkTreeIter *iter;
1086 gint type = __ca_selection_type (GTK_TREE_VIEW(gtk_builder_get_object (main_window_gtkb, "ca_treeview")), &iter);
1087 GtkBuilder * dialog_gtkb = NULL;
1088 gboolean has_pk_in_db = FALSE;
1089 gint response = 0;
1090
1091 dialog_gtkb = gtk_builder_new();
1092 gtk_builder_add_from_file (dialog_gtkb,
1093 g_build_filename (PACKAGE_DATA_DIR, "gnomint", "export_certificate_dialog.ui", NULL ),
1094 NULL);
1095 gtk_builder_connect_signals (dialog_gtkb, NULL);
1096
1097 gtk_tree_model_get(GTK_TREE_MODEL(ca_model), iter, CA_MODEL_COLUMN_PRIVATE_KEY_IN_DB, &has_pk_in_db, -1);
1098 widget = gtk_builder_get_object (dialog_gtkb, "privatepart_radiobutton2");
1099 gtk_widget_set_sensitive (GTK_WIDGET(widget), has_pk_in_db);
1100 widget = gtk_builder_get_object (dialog_gtkb, "bothparts_radiobutton3");
1101 gtk_widget_set_sensitive (GTK_WIDGET(widget), has_pk_in_db);
1102
1103 if (type == CA_FILE_ELEMENT_TYPE_CSR) {
1104 widget = gtk_builder_get_object (dialog_gtkb, "export_certificate_dialog");
1105 gtk_window_set_title (GTK_WINDOW(widget), _("Export CSR - gnoMint"));
1106
1107 widget = gtk_builder_get_object (dialog_gtkb, "label2");
1108 gtk_label_set_text
1109 (GTK_LABEL(widget),
1110 _("Please, choose which part of the saved Certificate Signing Request you want to export:"));
1111
1112 widget = gtk_builder_get_object (dialog_gtkb, "label5");
1113 gtk_label_set_markup
1114 (GTK_LABEL(widget),
1115 _("<i>Export the Certificate Signing Request to a public file, in PEM format.</i>"));
1116
1117 widget = gtk_builder_get_object (dialog_gtkb, "label15");
1118 gtk_label_set_markup
1119 (GTK_LABEL(widget),
1120 _("<i>Export the saved private key to a PKCS#8 password-protected file. This file should only be accessed by the subject of the Certificate Signing Request.</i>"));
1121
1122 widget = gtk_builder_get_object (dialog_gtkb, "bothparts_radiobutton3");
1123 g_object_set (G_OBJECT (widget), "visible", FALSE, NULL);
1124 widget = gtk_builder_get_object (dialog_gtkb, "label19");
1125 g_object_set (G_OBJECT (widget), "visible", FALSE, NULL);
1126
1127 }
1128
1129
1130 widget = gtk_builder_get_object (dialog_gtkb, "export_certificate_dialog");
1131
1132 response = gtk_dialog_run(GTK_DIALOG(widget));
1133
1134 if (!response || response == GTK_RESPONSE_CANCEL) {
1135 gtk_widget_destroy (GTK_WIDGET(widget));
1136 g_object_unref (G_OBJECT(dialog_gtkb));
1137 return;
1138 }
1139
1140 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (gtk_builder_get_object (dialog_gtkb, "publicpart_radiobutton1")))) {
1141 /* Export public part */
1142 __ca_export_public_pem (iter, type);
1143 gtk_widget_destroy (GTK_WIDGET(widget));
1144 g_object_unref (G_OBJECT(dialog_gtkb));
1145
1146 return;
1147 }
1148
1149 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (gtk_builder_get_object (dialog_gtkb, "privatepart_radiobutton2")))) {
1150 /* Export private part (crypted) */
1151 g_free (__ca_export_private_pkcs8 (iter, type));
1152 gtk_widget_destroy (GTK_WIDGET(widget));
1153 g_object_unref (G_OBJECT(dialog_gtkb));
1154
1155 return;
1156 }
1157
1158 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (gtk_builder_get_object (dialog_gtkb, "privatepart_uncrypted_radiobutton2")))) {
1159 /* Export private part (uncrypted) */
1160 __ca_export_private_pem (iter, type);
1161 gtk_widget_destroy (GTK_WIDGET(widget));
1162 g_object_unref (G_OBJECT(dialog_gtkb));
1163
1164 return;
1165 }
1166
1167 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (gtk_builder_get_object (dialog_gtkb, "bothparts_radiobutton3")))) {
1168 /* Export PKCS#12 structure */
1169 __ca_export_pkcs12 (iter, type);
1170 gtk_widget_destroy (GTK_WIDGET(widget));
1171 g_object_unref (G_OBJECT(dialog_gtkb));
1172
1173 return;
1174 }
1175
1176 gtk_widget_destroy (GTK_WIDGET(widget));
1177 g_object_unref (G_OBJECT(dialog_gtkb));
1178 dialog_error (_("Unexpected error"));
1179 }
1180
ca_on_extractprivatekey1_activate(GtkMenuItem * menuitem,gpointer user_data)1181 G_MODULE_EXPORT void ca_on_extractprivatekey1_activate (GtkMenuItem *menuitem, gpointer user_data)
1182 {
1183 GtkTreeIter *iter;
1184 gint type;
1185 gchar *filename = NULL;
1186 gint id;
1187
1188 type = __ca_selection_type (GTK_TREE_VIEW(gtk_builder_get_object (main_window_gtkb, "ca_treeview")), &iter);
1189
1190 gtk_tree_model_get(GTK_TREE_MODEL(ca_model), iter, CA_MODEL_COLUMN_ID, &id, -1);
1191
1192 filename = __ca_export_private_pkcs8 (iter, type);
1193
1194 if (! filename) {
1195 return;
1196 }
1197
1198 if (type == CA_FILE_ELEMENT_TYPE_CERT)
1199 ca_file_mark_pkey_as_extracted_for_id (CA_FILE_ELEMENT_TYPE_CERT, filename, id);
1200 else
1201 ca_file_mark_pkey_as_extracted_for_id (CA_FILE_ELEMENT_TYPE_CSR, filename, id);
1202
1203 g_free (filename);
1204
1205 dialog_refresh_list();
1206 }
1207
1208
ca_on_revoke_activate(GtkMenuItem * menuitem,gpointer user_data)1209 G_MODULE_EXPORT void ca_on_revoke_activate (GtkMenuItem *menuitem, gpointer user_data)
1210 {
1211 GObject * widget = NULL;
1212 GtkDialog * dialog = NULL;
1213 gchar * errmsg = NULL;
1214 GtkTreeIter *iter;
1215 gint type = __ca_selection_type (GTK_TREE_VIEW(gtk_builder_get_object (main_window_gtkb, "ca_treeview")), &iter);
1216 gint response = 0;
1217 gint id = 0;
1218
1219 if (type == CA_FILE_ELEMENT_TYPE_CSR)
1220 return;
1221
1222
1223
1224 gtk_tree_model_get(GTK_TREE_MODEL(ca_model), iter, CA_MODEL_COLUMN_ID, &id, -1);
1225
1226 widget = gtk_builder_get_object (main_window_gtkb, "main_window1");
1227 if (! ca_file_check_if_is_ca_id (id)) {
1228
1229 dialog = GTK_DIALOG(gtk_message_dialog_new_with_markup (GTK_WINDOW(widget),
1230 GTK_DIALOG_DESTROY_WITH_PARENT,
1231 GTK_MESSAGE_QUESTION,
1232 GTK_BUTTONS_YES_NO,
1233 "<b>%s</b>\n\n<span font_size='small'>%s</span>",
1234 _("Are you sure you want to revoke this certificate?"),
1235 _("Revoking a certificate will include it in the next CRL, marking it as invalid. This way, any future use of the certificate will be denied (as long as the CRL is checked).")));
1236 } else {
1237
1238 dialog = GTK_DIALOG(gtk_message_dialog_new_with_markup (GTK_WINDOW(widget),
1239 GTK_DIALOG_DESTROY_WITH_PARENT,
1240 GTK_MESSAGE_QUESTION,
1241 GTK_BUTTONS_YES_NO,
1242 "<b>%s</b>\n\n<span font_size='small'>%s</span>",
1243 _("Are you sure you want to revoke this CA certificate?"),
1244 _("Revoking a certificate will include it in the next CRL, marking it as invalid. This way, any future use of the certificate will be denied (as long as the CRL is checked). \n\nMoreover, revoking a CA certificate can invalidate all the certificates generated with it, so all them should be regenerated with a new CA certificate.")));
1245 }
1246
1247 response = gtk_dialog_run(dialog);
1248 gtk_widget_destroy (GTK_WIDGET(dialog));
1249
1250 if (response == GTK_RESPONSE_NO) {
1251 return;
1252 }
1253
1254 errmsg = ca_file_revoke_crt (id);
1255 if (errmsg) {
1256 dialog_error (_(errmsg));
1257
1258 }
1259
1260 dialog_refresh_list();
1261
1262 }
1263
1264
ca_on_delete2_activate(GtkMenuItem * menuitem,gpointer user_data)1265 G_MODULE_EXPORT void ca_on_delete2_activate (GtkMenuItem *menuitem, gpointer user_data)
1266 {
1267 GObject * widget = NULL;
1268 GtkDialog * dialog = NULL;
1269 GtkTreeIter *iter;
1270 gint type = __ca_selection_type (GTK_TREE_VIEW(gtk_builder_get_object (main_window_gtkb, "ca_treeview")), &iter);
1271 gint response = 0;
1272 gint id = 0;
1273
1274 if (type != CA_FILE_ELEMENT_TYPE_CSR)
1275 return;
1276
1277 widget = gtk_builder_get_object (main_window_gtkb, "main_window1");
1278 dialog = GTK_DIALOG(gtk_message_dialog_new (GTK_WINDOW(widget),
1279 GTK_DIALOG_DESTROY_WITH_PARENT,
1280 GTK_MESSAGE_QUESTION,
1281 GTK_BUTTONS_YES_NO,
1282 "%s",
1283 _("Are you sure you want to delete this Certificate Signing Request?")));
1284
1285 response = gtk_dialog_run(dialog);
1286 gtk_widget_destroy (GTK_WIDGET(dialog));
1287
1288 if (response == GTK_RESPONSE_NO) {
1289 return;
1290 }
1291
1292 gtk_tree_model_get(GTK_TREE_MODEL(ca_model), iter, CA_MODEL_COLUMN_ID, &id, -1);
1293 ca_file_remove_csr (id);
1294
1295 dialog_refresh_list();
1296 }
1297
ca_on_sign1_activate(GtkMenuItem * menuitem,gpointer user_data)1298 G_MODULE_EXPORT void ca_on_sign1_activate (GtkMenuItem *menuitem, gpointer user_data)
1299 {
1300 GtkTreeIter *iter;
1301
1302 gint type = __ca_selection_type (GTK_TREE_VIEW(gtk_builder_get_object (main_window_gtkb, "ca_treeview")), &iter);
1303 gchar * csr_pem;
1304 gchar * csr_parent_id;
1305 guint64 csr_id;
1306
1307 if (type != CA_FILE_ELEMENT_TYPE_CSR)
1308 return;
1309
1310 gtk_tree_model_get(GTK_TREE_MODEL(ca_model), iter, CA_MODEL_COLUMN_ID, &csr_id, CA_MODEL_COLUMN_PEM, &csr_pem, CA_MODEL_COLUMN_PARENT_ID, &csr_parent_id, -1);
1311
1312 new_cert_window_display (csr_id, csr_pem, csr_parent_id);
1313
1314 g_free (csr_pem);
1315 g_free (csr_parent_id);
1316 }
1317
1318
1319
ca_open(gchar * filename,gboolean create)1320 gboolean ca_open (gchar *filename, gboolean create)
1321 {
1322 if (! ca_file_open (filename, create))
1323 return FALSE;
1324
1325 __enable_widget ("new_certificate1");
1326 __enable_widget ("save_as1");
1327 __enable_widget ("preferences1");
1328
1329
1330 dialog_refresh_list();
1331
1332
1333 return TRUE;
1334 }
1335
ca_get_selected_row_id()1336 guint64 ca_get_selected_row_id ()
1337 {
1338 GtkTreeIter *iter;
1339 guint64 result;
1340
1341 gint type = __ca_selection_type (GTK_TREE_VIEW(gtk_builder_get_object (main_window_gtkb, "ca_treeview")), &iter);
1342 gtk_tree_model_get(GTK_TREE_MODEL(ca_model), iter, CA_MODEL_COLUMN_ID, &result, -1);
1343
1344 type = 0;
1345 return result;
1346 }
1347
ca_get_selected_row_pem()1348 gchar * ca_get_selected_row_pem ()
1349 {
1350 GtkTreeIter *iter;
1351 gchar * result;
1352
1353 gint type = __ca_selection_type (GTK_TREE_VIEW(gtk_builder_get_object (main_window_gtkb, "ca_treeview")), &iter);
1354 gtk_tree_model_get(GTK_TREE_MODEL(ca_model), iter, CA_MODEL_COLUMN_PEM, &result, -1);
1355
1356 type = 0;
1357 return result;
1358 }
1359
1360
ca_update_csr_view(gboolean new_value,gboolean refresh)1361 void ca_update_csr_view (gboolean new_value, gboolean refresh)
1362 {
1363 view_csr = new_value;
1364 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM(gtk_builder_get_object(main_window_gtkb, "csr_view_menuitem")), new_value);
1365 if (refresh)
1366 dialog_refresh_list();
1367 }
1368
ca_csr_view_toggled(GtkCheckMenuItem * button,gpointer user_data)1369 G_MODULE_EXPORT gboolean ca_csr_view_toggled (GtkCheckMenuItem *button, gpointer user_data)
1370 {
1371 ca_update_csr_view (gtk_check_menu_item_get_active (button), TRUE);
1372 if (view_csr != preferences_get_crq_visible())
1373 preferences_set_crq_visible (view_csr);
1374
1375 return TRUE;
1376 }
1377
ca_update_revoked_view(gboolean new_value,gboolean refresh)1378 void ca_update_revoked_view (gboolean new_value, gboolean refresh)
1379 {
1380 view_rcrt = new_value;
1381 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM(gtk_builder_get_object(main_window_gtkb, "revoked_view_menuitem")), new_value);
1382 if (refresh)
1383 dialog_refresh_list();
1384 }
1385
ca_rcrt_view_toggled(GtkCheckMenuItem * button,gpointer user_data)1386 G_MODULE_EXPORT gboolean ca_rcrt_view_toggled (GtkCheckMenuItem *button, gpointer user_data)
1387 {
1388 ca_update_revoked_view (gtk_check_menu_item_get_active (button), TRUE);
1389 if (view_rcrt != preferences_get_revoked_visible())
1390 preferences_set_revoked_visible (view_rcrt);
1391
1392 return TRUE;
1393 }
1394
ca_generate_crl(GtkCheckMenuItem * item,gpointer user_data)1395 G_MODULE_EXPORT void ca_generate_crl (GtkCheckMenuItem *item, gpointer user_data)
1396 {
1397 crl_window_display ();
1398 }
1399
1400
1401
1402
ca_treeview_popup_timeout_program_cb(gpointer data)1403 gboolean ca_treeview_popup_timeout_program_cb (gpointer data)
1404 {
1405 GObject *menu, *widget;
1406 GtkTreeView * tree_view = GTK_TREE_VIEW(gtk_builder_get_object (main_window_gtkb, "ca_treeview"));
1407 GdkEventButton *event_button = (GdkEventButton *) data;
1408 GtkTreeIter *iter;
1409 gboolean pk_indb, is_revoked;
1410 gint selection_type;
1411
1412 selection_type = __ca_selection_type (tree_view, &iter);
1413 switch (selection_type) {
1414
1415 case CA_FILE_ELEMENT_TYPE_CERT:
1416 menu = gtk_builder_get_object (cert_popup_menu_gtkb,
1417 "certificate_popup_menu");
1418
1419 gtk_tree_model_get(GTK_TREE_MODEL(ca_model), iter,
1420 CA_MODEL_COLUMN_PRIVATE_KEY_IN_DB, &pk_indb,
1421 CA_MODEL_COLUMN_REVOCATION, &is_revoked, -1);
1422
1423 widget = gtk_builder_get_object (cert_popup_menu_gtkb, "extract_pkey_menuitem");
1424 gtk_widget_set_sensitive (GTK_WIDGET(widget), pk_indb);
1425
1426 widget = gtk_builder_get_object (cert_popup_menu_gtkb, "revoke_menuitem");
1427 gtk_widget_set_sensitive (GTK_WIDGET(widget), (! is_revoked));
1428
1429 gtk_menu_popup (GTK_MENU(menu), NULL, NULL, NULL, NULL,
1430 event_button->button, event_button->time);
1431 return FALSE;
1432 case CA_FILE_ELEMENT_TYPE_CSR:
1433 menu = gtk_builder_get_object (csr_popup_menu_gtkb,
1434 "csr_popup_menu");
1435
1436 gtk_tree_model_get(GTK_TREE_MODEL(ca_model), iter,
1437 CA_MODEL_COLUMN_PRIVATE_KEY_IN_DB, &pk_indb,
1438 -1);
1439
1440 widget = gtk_builder_get_object (csr_popup_menu_gtkb, "extract_pkey_menuitem3");
1441 gtk_widget_set_sensitive (GTK_WIDGET(widget), pk_indb);
1442
1443 gtk_menu_popup (GTK_MENU(menu), NULL, NULL, NULL, NULL,
1444 event_button->button, event_button->time);
1445 return FALSE;
1446 default:
1447 case -1:
1448 return FALSE;
1449 }
1450
1451 }
1452
ca_treeview_popup_timeout_program(GdkEventButton * event)1453 void ca_treeview_popup_timeout_program (GdkEventButton *event)
1454 {
1455 g_timeout_add (1, ca_treeview_popup_timeout_program_cb, event);
1456
1457 }
1458
1459
ca_treeview_popup_handler(GtkTreeView * tree_view,GdkEvent * event,gpointer user_data)1460 G_MODULE_EXPORT gboolean ca_treeview_popup_handler (GtkTreeView *tree_view,
1461 GdkEvent *event, gpointer user_data)
1462 {
1463 GdkEventButton *event_button;
1464
1465 g_return_val_if_fail (event != NULL, FALSE);
1466
1467 if (event->type == GDK_BUTTON_PRESS) {
1468
1469 event_button = (GdkEventButton *) event;
1470 if (event_button->button == 3) {
1471 ca_treeview_popup_timeout_program (event_button);
1472 }
1473 }
1474
1475 return FALSE;
1476 }
1477
ca_on_change_pwd_menuitem_activate(GtkMenuItem * menuitem,gpointer user_data)1478 G_MODULE_EXPORT void ca_on_change_pwd_menuitem_activate (GtkMenuItem *menuitem, gpointer user_data)
1479 {
1480 GObject * widget = NULL;
1481 GtkDialog * dialog = NULL;
1482 GtkBuilder * dialog_gtkb = NULL;
1483 const gchar *newpwd;
1484 const gchar *currpwd;
1485
1486 gint response = 0;
1487 gboolean repeat;
1488
1489 dialog_gtkb = gtk_builder_new();
1490 gtk_builder_add_from_file (dialog_gtkb,
1491 g_build_filename (PACKAGE_DATA_DIR, "gnomint", "change_password_dialog.ui", NULL),
1492 NULL);
1493 gtk_builder_connect_signals (dialog_gtkb, NULL);
1494
1495 if (ca_file_is_password_protected()) {
1496 widget = gtk_builder_get_object (dialog_gtkb, "ca_changepwd_pwd_protect_yes_radiobutton");
1497 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(widget), TRUE);
1498
1499 widget = gtk_builder_get_object (dialog_gtkb, "ca_changepwd_label1");
1500 g_object_set (G_OBJECT(widget), "visible", TRUE, NULL);
1501
1502 widget = gtk_builder_get_object (dialog_gtkb, "ca_changepwd_current_pwd_entry");
1503 g_object_set (G_OBJECT(widget), "visible", TRUE, NULL);
1504
1505 widget = gtk_builder_get_object (dialog_gtkb, "ca_changepwd_label2");
1506 gtk_widget_set_sensitive (GTK_WIDGET(widget), TRUE);
1507
1508 widget = gtk_builder_get_object (dialog_gtkb, "ca_changepwd_label3");
1509 gtk_widget_set_sensitive (GTK_WIDGET(widget), TRUE);
1510
1511 widget = gtk_builder_get_object (dialog_gtkb, "ca_changepwd_newpwd_entry1");
1512 gtk_widget_set_sensitive (GTK_WIDGET(widget), TRUE);
1513
1514 widget = gtk_builder_get_object (dialog_gtkb, "ca_changepwd_newpwd_entry2");
1515 gtk_widget_set_sensitive (GTK_WIDGET(widget), TRUE);
1516
1517 widget = gtk_builder_get_object (dialog_gtkb, "ca_changepwd_commit_button");
1518 gtk_widget_set_sensitive (GTK_WIDGET(widget), FALSE);
1519
1520 } else {
1521 widget = gtk_builder_get_object (dialog_gtkb, "ca_changepwd_pwd_protect_no_radiobutton");
1522 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(widget), TRUE);
1523
1524 widget = gtk_builder_get_object (dialog_gtkb, "ca_changepwd_label1");
1525 g_object_set (G_OBJECT(widget), "visible", FALSE, NULL);
1526
1527 widget = gtk_builder_get_object (dialog_gtkb, "ca_changepwd_current_pwd_entry");
1528 g_object_set (G_OBJECT(widget), "visible", FALSE, NULL);
1529
1530 widget = gtk_builder_get_object (dialog_gtkb, "ca_changepwd_label2");
1531 gtk_widget_set_sensitive (GTK_WIDGET(widget), FALSE);
1532
1533 widget = gtk_builder_get_object (dialog_gtkb, "ca_changepwd_label3");
1534 gtk_widget_set_sensitive (GTK_WIDGET(widget), FALSE);
1535
1536 widget = gtk_builder_get_object (dialog_gtkb, "ca_changepwd_newpwd_entry1");
1537 gtk_widget_set_sensitive (GTK_WIDGET(widget), FALSE);
1538
1539 widget = gtk_builder_get_object (dialog_gtkb, "ca_changepwd_newpwd_entry2");
1540 gtk_widget_set_sensitive (GTK_WIDGET(widget), FALSE);
1541
1542 }
1543
1544 widget = gtk_builder_get_object (dialog_gtkb, "ca_changepwd_pwd_protect_yes_radiobutton");
1545 g_object_set_data (G_OBJECT(widget), "dialog_gtkb", dialog_gtkb);
1546
1547 widget = gtk_builder_get_object (dialog_gtkb, "ca_changepwd_newpwd_entry1");
1548 g_object_set_data (G_OBJECT(widget), "dialog_gtkb", dialog_gtkb);
1549
1550 widget = gtk_builder_get_object (dialog_gtkb, "ca_changepwd_newpwd_entry2");
1551 g_object_set_data (G_OBJECT(widget), "dialog_gtkb", dialog_gtkb);
1552
1553 widget = gtk_builder_get_object (dialog_gtkb, "ca_changepwd_current_pwd_entry");
1554 g_object_set_data (G_OBJECT(widget), "dialog_gtkb", dialog_gtkb);
1555
1556
1557 do {
1558
1559 widget = gtk_builder_get_object (dialog_gtkb, "change_password_dialog");
1560 gtk_window_set_title (GTK_WINDOW(widget), _("Change CA password - gnoMint"));
1561 response = gtk_dialog_run(GTK_DIALOG(widget));
1562
1563 if (!response || response == GTK_RESPONSE_CANCEL) {
1564 gtk_widget_destroy (GTK_WIDGET(widget));
1565 g_object_unref (G_OBJECT(dialog_gtkb));
1566 return;
1567 }
1568
1569 widget = gtk_builder_get_object (dialog_gtkb, "ca_changepwd_newpwd_entry1");
1570 newpwd = gtk_entry_get_text (GTK_ENTRY(widget));
1571
1572 widget = gtk_builder_get_object (dialog_gtkb, "ca_changepwd_current_pwd_entry");
1573 currpwd = gtk_entry_get_text (GTK_ENTRY(widget));
1574
1575 repeat = (ca_file_is_password_protected() && ! ca_file_check_password (currpwd));
1576
1577 if (repeat) {
1578 dialog_error (_("The current password you have entered "
1579 "doesn't match with the actual current database password."));
1580 widget = gtk_builder_get_object (dialog_gtkb, "ca_changepwd_current_pwd_entry");
1581 gtk_widget_grab_focus (GTK_WIDGET(widget));
1582 }
1583
1584 } while (repeat);
1585
1586 widget = gtk_builder_get_object (dialog_gtkb, "ca_changepwd_pwd_protect_yes_radiobutton");
1587 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget))) {
1588
1589 if (ca_file_is_password_protected()) {
1590 // It's a password change
1591
1592 if (! ca_file_password_change (currpwd, newpwd)) {
1593 dialog_error (_("Error while changing database password. "
1594 "The operation was cancelled."));
1595 } else {
1596 widget = gtk_builder_get_object (dialog_gtkb, "change_password_dialog");
1597 dialog = GTK_DIALOG(gtk_message_dialog_new (GTK_WINDOW(widget),
1598 GTK_DIALOG_DESTROY_WITH_PARENT,
1599 GTK_MESSAGE_INFO,
1600 GTK_BUTTONS_CLOSE,
1601 "%s",
1602 _("Password changed successfully")));
1603 gtk_dialog_run (GTK_DIALOG(dialog));
1604
1605 gtk_widget_destroy (GTK_WIDGET(dialog));
1606 }
1607
1608 } else {
1609 // It's a new password
1610
1611 if (! ca_file_password_protect (newpwd)) {
1612 dialog_error (_("Error while establishing database password. "
1613 "The operation was cancelled."));
1614
1615 } else {
1616 widget = gtk_builder_get_object (dialog_gtkb, "change_password_dialog");
1617 dialog = GTK_DIALOG(gtk_message_dialog_new (GTK_WINDOW(widget),
1618 GTK_DIALOG_DESTROY_WITH_PARENT,
1619 GTK_MESSAGE_INFO,
1620 GTK_BUTTONS_CLOSE,
1621 "%s",
1622 _("Password established successfully")));
1623 gtk_dialog_run (GTK_DIALOG(dialog));
1624
1625 gtk_widget_destroy (GTK_WIDGET(dialog));
1626 }
1627 }
1628 } else {
1629 if (ca_file_is_password_protected()) {
1630 // Remove password protection
1631 if (! ca_file_password_unprotect (currpwd)) {
1632 dialog_error (_("Error while removing database password. "
1633 "The operation was cancelled."));
1634 } else {
1635 widget = gtk_builder_get_object (dialog_gtkb, "change_password_dialog");
1636 dialog = GTK_DIALOG(gtk_message_dialog_new (GTK_WINDOW(widget),
1637 GTK_DIALOG_DESTROY_WITH_PARENT,
1638 GTK_MESSAGE_INFO,
1639 GTK_BUTTONS_CLOSE,
1640 "%s",
1641 _("Password removed successfully")));
1642 gtk_dialog_run (GTK_DIALOG(dialog));
1643
1644 gtk_widget_destroy (GTK_WIDGET(dialog));
1645
1646 }
1647
1648 } else {
1649 // Don't do anything
1650
1651 }
1652
1653 }
1654
1655 widget = gtk_builder_get_object (dialog_gtkb, "change_password_dialog");
1656 gtk_widget_destroy (GTK_WIDGET(widget));
1657
1658 }
1659
1660
ca_changepwd_newpwd_entry_changed(GtkWidget * entry,gpointer user_data)1661 G_MODULE_EXPORT gboolean ca_changepwd_newpwd_entry_changed (GtkWidget *entry, gpointer user_data)
1662 {
1663 GtkBuilder * dialog_gtkb = g_object_get_data (G_OBJECT(entry), "dialog_gtkb");
1664 GObject *widget;
1665
1666 const gchar *pwd1;
1667 const gchar *pwd2;
1668 const gchar *currpwd;
1669 gboolean pwd_protect;
1670
1671 widget = gtk_builder_get_object (dialog_gtkb, "ca_changepwd_pwd_protect_yes_radiobutton");
1672 pwd_protect = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
1673
1674 widget = gtk_builder_get_object (dialog_gtkb, "ca_changepwd_newpwd_entry1");
1675 pwd1 = gtk_entry_get_text (GTK_ENTRY(widget));
1676
1677 widget = gtk_builder_get_object (dialog_gtkb, "ca_changepwd_newpwd_entry2");
1678 pwd2 = gtk_entry_get_text (GTK_ENTRY(widget));
1679
1680 widget = gtk_builder_get_object (dialog_gtkb, "ca_changepwd_current_pwd_entry");
1681 currpwd = gtk_entry_get_text (GTK_ENTRY(widget));
1682
1683 widget = gtk_builder_get_object (dialog_gtkb, "ca_changepwd_commit_button");
1684 if (pwd_protect) {
1685 if (strlen(pwd1) && strlen(pwd2) && ! strcmp(pwd1, pwd2)) {
1686 if (!ca_file_is_password_protected() || (ca_file_is_password_protected() && strlen(currpwd)))
1687 gtk_widget_set_sensitive (GTK_WIDGET(widget), TRUE);
1688 else
1689 gtk_widget_set_sensitive (GTK_WIDGET(widget), FALSE);
1690 } else {
1691 gtk_widget_set_sensitive (GTK_WIDGET(widget), FALSE);
1692 }
1693 } else {
1694 gtk_widget_set_sensitive (GTK_WIDGET(widget), TRUE);
1695 }
1696
1697 return FALSE;
1698 }
1699
ca_changepwd_pwd_protect_radiobutton_toggled(GtkWidget * button,gpointer user_data)1700 G_MODULE_EXPORT gboolean ca_changepwd_pwd_protect_radiobutton_toggled (GtkWidget *button, gpointer user_data)
1701 {
1702 GtkBuilder * dialog_gtkb;
1703 GObject * widget = NULL;
1704
1705
1706 if (! G_IS_OBJECT(button))
1707 return TRUE;
1708
1709 dialog_gtkb = g_object_get_data (G_OBJECT(button), "dialog_gtkb");
1710 if (! dialog_gtkb)
1711 return TRUE;
1712
1713 widget = gtk_builder_get_object (dialog_gtkb, "ca_changepwd_pwd_protect_yes_radiobutton");
1714 if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget))) {
1715 /* We want to password-protect the database */
1716
1717 widget = gtk_builder_get_object (dialog_gtkb, "ca_changepwd_label2");
1718 gtk_widget_set_sensitive (GTK_WIDGET(widget), TRUE);
1719
1720 widget = gtk_builder_get_object (dialog_gtkb, "ca_changepwd_label3");
1721 gtk_widget_set_sensitive (GTK_WIDGET(widget), TRUE);
1722
1723 widget = gtk_builder_get_object (dialog_gtkb, "ca_changepwd_newpwd_entry1");
1724 gtk_widget_set_sensitive (GTK_WIDGET(widget), TRUE);
1725
1726 widget = gtk_builder_get_object (dialog_gtkb, "ca_changepwd_newpwd_entry2");
1727 gtk_widget_set_sensitive (GTK_WIDGET(widget), TRUE);
1728
1729 ca_changepwd_newpwd_entry_changed (button, NULL);
1730
1731 } else {
1732
1733 widget = gtk_builder_get_object (dialog_gtkb, "ca_changepwd_label2");
1734 gtk_widget_set_sensitive (GTK_WIDGET(widget), FALSE);
1735
1736 widget = gtk_builder_get_object (dialog_gtkb, "ca_changepwd_label3");
1737 gtk_widget_set_sensitive (GTK_WIDGET(widget), FALSE);
1738
1739 widget = gtk_builder_get_object (dialog_gtkb, "ca_changepwd_newpwd_entry1");
1740 gtk_widget_set_sensitive (GTK_WIDGET(widget), FALSE);
1741
1742 widget = gtk_builder_get_object (dialog_gtkb, "ca_changepwd_newpwd_entry2");
1743 gtk_widget_set_sensitive (GTK_WIDGET(widget), FALSE);
1744 }
1745
1746 return FALSE;
1747 }
1748
1749
ca_generate_dh_param_show(GtkWidget * menuitem,gpointer user_data)1750 G_MODULE_EXPORT void ca_generate_dh_param_show (GtkWidget *menuitem, gpointer user_data)
1751 {
1752 GObject * widget = NULL;
1753 GtkDialog * dialog = NULL, * dialog2 = NULL;
1754 GtkBuilder * dialog_gtkb = NULL;
1755 gchar *filename;
1756 gint response = 0;
1757 guint dh_size;
1758 gchar *strerror;
1759
1760 dialog_gtkb = gtk_builder_new();
1761 gtk_builder_add_from_file (dialog_gtkb,
1762 g_build_filename (PACKAGE_DATA_DIR, "gnomint", "dh_parameters_dialog.ui", NULL),
1763 NULL);
1764 gtk_builder_connect_signals (dialog_gtkb, NULL);
1765
1766
1767 dialog = GTK_DIALOG(gtk_builder_get_object (dialog_gtkb, "dh_parameters_dialog"));
1768 response = gtk_dialog_run(dialog);
1769
1770 if (!response) {
1771 gtk_widget_destroy (GTK_WIDGET(dialog));
1772 g_object_unref (G_OBJECT(dialog_gtkb));
1773 return;
1774 }
1775
1776 widget = gtk_builder_get_object (dialog_gtkb, "dh_prime_size_spinbutton");
1777 dh_size = gtk_spin_button_get_value (GTK_SPIN_BUTTON(widget));
1778
1779 dialog2 = GTK_DIALOG (gtk_file_chooser_dialog_new (_("Save Diffie-Hellman parameters"),
1780 GTK_WINDOW(widget),
1781 GTK_FILE_CHOOSER_ACTION_SAVE,
1782 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1783 GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
1784 NULL));
1785 gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog2), TRUE);
1786
1787 if (gtk_dialog_run (GTK_DIALOG (dialog2)) == GTK_RESPONSE_ACCEPT) {
1788
1789 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog2));
1790
1791 strerror = export_dh_param (dh_size, filename);
1792
1793 if (strerror) {
1794 gtk_widget_destroy (GTK_WIDGET(dialog2));
1795 gtk_widget_destroy (GTK_WIDGET(dialog));
1796 dialog_error (strerror);
1797 } else {
1798 gtk_widget_destroy (GTK_WIDGET(dialog2));
1799 gtk_widget_destroy (GTK_WIDGET(dialog));
1800 dialog = GTK_DIALOG(gtk_message_dialog_new (GTK_WINDOW(widget),
1801 GTK_DIALOG_DESTROY_WITH_PARENT,
1802 GTK_MESSAGE_INFO,
1803 GTK_BUTTONS_CLOSE,
1804 "%s",
1805 _("Diffie-Hellman parameters saved successfully")));
1806 gtk_dialog_run (GTK_DIALOG(dialog));
1807
1808 gtk_widget_destroy (GTK_WIDGET(dialog));
1809 }
1810
1811
1812 }
1813
1814
1815 return;
1816 }
1817
1818
1819 /*
1820 *
1821 * FILE MENU CALLBACKS
1822 *
1823 */
1824
1825
on_add_self_signed_ca_activate(GtkMenuItem * menuitem,gpointer user_data)1826 G_MODULE_EXPORT void on_add_self_signed_ca_activate (GtkMenuItem *menuitem, gpointer user_data)
1827 {
1828 new_ca_window_display();
1829
1830 }
1831
on_add_csr_activate(GtkMenuItem * menuitem,gpointer user_data)1832 G_MODULE_EXPORT void on_add_csr_activate (GtkMenuItem *menuitem, gpointer user_data)
1833 {
1834 new_req_window_display();
1835
1836 }
1837
1838
on_import1_activate(GtkMenuItem * menuitem,gpointer user_data)1839 G_MODULE_EXPORT void on_import1_activate (GtkMenuItem *menuitem, gpointer user_data)
1840 {
1841
1842 gchar *filename;
1843
1844 GObject *main_window_widget, *widget;
1845 GtkWidget *dialog;
1846 GtkBuilder * dialog_gtkb = NULL;
1847 GtkToggleButton *radiobutton = NULL;
1848 gint response = 0;
1849 gboolean import_file = TRUE;
1850
1851 main_window_widget = gtk_builder_get_object (main_window_gtkb, "main_window");
1852
1853 dialog_gtkb = gtk_builder_new();
1854 gtk_builder_add_from_file (dialog_gtkb,
1855 g_build_filename (PACKAGE_DATA_DIR, "gnomint", "import_file_or_directory_dialog.ui", NULL),
1856 NULL);
1857 gtk_builder_connect_signals (dialog_gtkb, NULL);
1858
1859 widget = gtk_builder_get_object (dialog_gtkb, "import_file_or_directory_dialog");
1860 response = gtk_dialog_run (GTK_DIALOG(widget));
1861
1862 if (response < 0) {
1863 gtk_widget_destroy (GTK_WIDGET(widget));
1864 g_object_unref (G_OBJECT(dialog_gtkb));
1865 return;
1866 }
1867
1868 radiobutton = GTK_TOGGLE_BUTTON(gtk_builder_get_object (dialog_gtkb, "importfile_radiobutton"));
1869 import_file = gtk_toggle_button_get_active(radiobutton);
1870
1871 gtk_widget_destroy (GTK_WIDGET(widget));
1872
1873 if (import_file) {
1874 // Import single file
1875 dialog = gtk_file_chooser_dialog_new (_("Select PEM file to import"),
1876 GTK_WINDOW(main_window_widget),
1877 GTK_FILE_CHOOSER_ACTION_OPEN,
1878 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1879 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
1880 NULL);
1881
1882 if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
1883 {
1884 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
1885 gtk_widget_destroy (dialog);
1886 } else {
1887 gtk_widget_destroy (dialog);
1888 return;
1889 }
1890
1891 if (! import_single_file (filename, NULL, NULL)) {
1892 dialog = gtk_message_dialog_new (GTK_WINDOW(main_window_widget),
1893 GTK_DIALOG_DESTROY_WITH_PARENT,
1894 GTK_MESSAGE_ERROR,
1895 GTK_BUTTONS_CLOSE,
1896 _("Problem when importing '%s' file"),
1897 filename);
1898
1899 gtk_dialog_run (GTK_DIALOG(dialog));
1900
1901 gtk_widget_destroy (dialog);
1902 }
1903 return;
1904 } else {
1905 // Import directory
1906
1907 gchar * result = NULL;
1908
1909 dialog = gtk_file_chooser_dialog_new (_("Select directory to import"),
1910 GTK_WINDOW(main_window_widget),
1911 GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
1912 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1913 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
1914 NULL);
1915
1916 if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
1917 {
1918 filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
1919 gtk_widget_destroy (dialog);
1920 } else {
1921 gtk_widget_destroy (dialog);
1922 return;
1923 }
1924
1925 result = import_whole_dir (filename);
1926
1927 if (result) {
1928 dialog = gtk_message_dialog_new (GTK_WINDOW(main_window_widget),
1929 GTK_DIALOG_DESTROY_WITH_PARENT,
1930 GTK_MESSAGE_ERROR,
1931 GTK_BUTTONS_CLOSE,
1932 "%s", result);
1933
1934 gtk_dialog_run (GTK_DIALOG(dialog));
1935
1936 gtk_widget_destroy (dialog);
1937 }
1938 return;
1939
1940 }
1941 }
1942
1943
1944 /*
1945 *
1946 * EDIT MENU CALLBACKS
1947 *
1948 */
1949
1950
1951
on_preferences1_activate(GtkMenuItem * menuitem,gpointer user_data)1952 G_MODULE_EXPORT void on_preferences1_activate (GtkMenuItem *menuitem, gpointer user_data)
1953 {
1954 preferences_window_display ();
1955 }
1956
on_properties1_activate(GtkMenuItem * menuitem,gpointer user_data)1957 G_MODULE_EXPORT void on_properties1_activate (GtkMenuItem *menuitem, gpointer user_data)
1958 {
1959 ca_treeview_row_activated (NULL, NULL, NULL, NULL);
1960 }
1961
1962
1963
1964
1965 #endif
1966
1967