src/ssl_manager.c

   1 /*
   2  * Claws Mail -- a GTK based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2022 the Claws Mail team and Colin Leroy
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 3 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  17  */
  18 #ifdef HAVE_CONFIG_H
  19 #  include "config.h"
  20 #include "claws-features.h"
  21 #endif
  22
  23 #ifdef USE_GNUTLS
  24 #include <gtk/gtk.h>
  25 #include <glib.h>
  26 #include <glib/gi18n.h>
  27 #include <gdk/gdkkeysyms.h>
  28 #include <sys/types.h>
  29 #include <dirent.h>
  30
  31 #include "ssl_manager.h"
  32 #include "ssl_certificate.h"
  33 #include "manage_window.h"
  34 #include "utils.h"
  35 #include "mainwindow.h"
  36 #include "alertpanel.h"
  37 #include "sslcertwindow.h"
  38 #include "prefs_common.h"
  39
  40 enum {
  41         SSL_MANAGER_HOST,
  42         SSL_MANAGER_PORT,
  43         SSL_MANAGER_CERT,
  44         SSL_MANAGER_STATUS,
  45         SSL_MANAGER_EXPIRY,
  46         SSL_MANAGER_FONT_WEIGHT,
  47         N_SSL_MANAGER_COLUMNS
  48 };
  49
  50
  51 static struct SSLManager
  52 {
  53         GtkWidget *window;
  54         GtkWidget *hbox1;
  55         GtkWidget *vbox1;
  56         GtkWidget *certlist;
  57         GtkWidget *view_btn;
  58         GtkWidget *delete_btn;
  59         GtkWidget *close_btn;
  60 } manager;
  61
  62 static void ssl_manager_view_cb         (GtkWidget *widget, gpointer data);
  63 static void ssl_manager_delete_cb       (GtkWidget *widget, gpointer data);
  64 static void ssl_manager_close_cb        (GtkWidget *widget, gpointer data);
  65 static gboolean key_pressed             (GtkWidget *widget, GdkEventKey *event,
  66                                          gpointer data);
  67 static void ssl_manager_load_certs      (void);
  68 static void ssl_manager_double_clicked(GtkTreeView              *list_view,
  69                                         GtkTreePath             *path,
  70                                         GtkTreeViewColumn       *column,
  71                                         gpointer                 data);
  72
  73 void ssl_manager_open(MainWindow *mainwin)
  74 {
  75         if (!manager.window)
  76                 ssl_manager_create();
  77
  78         manage_window_set_transient(GTK_WINDOW(manager.window));
  79         gtk_widget_grab_focus(manager.close_btn);
  80
  81         ssl_manager_load_certs();
  82
  83         gtk_widget_show(manager.window);
  84
  85 }
  86
  87 static GtkListStore* ssl_manager_create_data_store(void)
  88 {
  89         return gtk_list_store_new(N_SSL_MANAGER_COLUMNS,
  90                                   G_TYPE_STRING,
  91                                   G_TYPE_STRING,
  92                                   G_TYPE_POINTER,
  93                                   G_TYPE_STRING,
  94                                   G_TYPE_STRING,
  95                                   G_TYPE_INT,
  96                                   -1);
  97 }
  98
  99 static void ssl_manager_create_list_view_columns(GtkWidget *list_view)
 100 {
 101         GtkTreeViewColumn *column;
 102         GtkCellRenderer *renderer;
 103
 104         renderer = gtk_cell_renderer_text_new();
 105         g_object_set(renderer, "weight", PANGO_WEIGHT_NORMAL,
 106                      "weight-set", TRUE, NULL);
 107
 108         column = gtk_tree_view_column_new_with_attributes
 109                 (_("Server"),
 110                  renderer,
 111                  "text", SSL_MANAGER_HOST,
 112                  "weight", SSL_MANAGER_FONT_WEIGHT,
 113                  NULL);
 114         gtk_tree_view_append_column(GTK_TREE_VIEW(list_view), column);
 115
 116         column = gtk_tree_view_column_new_with_attributes
 117                 (_("Port"),
 118                  renderer,
 119                  "text", SSL_MANAGER_PORT,
 120                  NULL);
 121         gtk_tree_view_append_column(GTK_TREE_VIEW(list_view), column);
 122
 123         column = gtk_tree_view_column_new_with_attributes
 124                 (_("Status"),
 125                  renderer,
 126                  "text", SSL_MANAGER_STATUS,
 127                  NULL);
 128         gtk_tree_view_append_column(GTK_TREE_VIEW(list_view), column);
 129
 130         column = gtk_tree_view_column_new_with_attributes
 131                 (_("Expiry"),
 132                  renderer,
 133                  "text", SSL_MANAGER_EXPIRY,
 134                  NULL);
 135         gtk_tree_view_column_set_attributes
 136                 (column, renderer,
 137                  "text", SSL_MANAGER_EXPIRY,
 138                  NULL);
 139         gtk_tree_view_append_column(GTK_TREE_VIEW(list_view), column);
 140 }
 141
 142 static GtkWidget *ssl_manager_list_view_create  (void)
 143 {
 144         GtkTreeView *list_view;
 145         GtkTreeSelection *selector;
 146         GtkTreeModel *model;
 147
 148         model = GTK_TREE_MODEL(ssl_manager_create_data_store());
 149         list_view = GTK_TREE_VIEW(gtk_tree_view_new_with_model(model));
 150
 151         gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(model),
 152                                              0, GTK_SORT_ASCENDING);
 153         g_object_unref(model);
 154         gtk_tree_view_set_rules_hint(list_view, prefs_common.use_stripes_everywhere);
 155
 156         selector = gtk_tree_view_get_selection(list_view);
 157         gtk_tree_selection_set_mode(selector, GTK_SELECTION_BROWSE);
 158
 159         g_signal_connect(G_OBJECT(list_view), "row_activated",
 160                          G_CALLBACK(ssl_manager_double_clicked),
 161                          list_view);
 162
 163         /* create the columns */
 164         ssl_manager_create_list_view_columns(GTK_WIDGET(list_view));
 165
 166         return GTK_WIDGET(list_view);
 167 }
 168
 169 /*!
 170  *\brief        Save Gtk object size to prefs dataset
 171  */
 172 static void ssl_manager_size_allocate_cb(GtkWidget *widget,
 173                                          GtkAllocation *allocation)
 174 {
 175         cm_return_if_fail(allocation != NULL);
 176
 177         gtk_window_get_size(GTK_WINDOW(widget),
 178                 &prefs_common.sslmanwin_width, &prefs_common.sslmanwin_height);
 179 }
 180
 181 void ssl_manager_create(void)
 182 {
 183         GtkWidget *window;
 184         GtkWidget *scroll;
 185         GtkWidget *hbox1;
 186         GtkWidget *vbox1;
 187         GtkWidget *certlist;
 188         GtkWidget *view_btn;
 189         GtkWidget *delete_btn;
 190         GtkWidget *close_btn;
 191         static GdkGeometry geometry;
 192
 193         window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "ssl_manager");
 194         gtk_window_set_title (GTK_WINDOW(window),
 195                               _("Saved TLS certificates"));
 196
 197         gtk_container_set_border_width (GTK_CONTAINER (window), 8);
 198         gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER);
 199         gtk_window_set_resizable(GTK_WINDOW (window), TRUE);
 200         gtk_window_set_type_hint(GTK_WINDOW(window), GDK_WINDOW_TYPE_HINT_DIALOG);
 201         g_signal_connect(G_OBJECT(window), "delete_event",
 202                          G_CALLBACK(ssl_manager_close_cb), NULL);
 203         g_signal_connect(G_OBJECT(window), "size_allocate",
 204                          G_CALLBACK(ssl_manager_size_allocate_cb), NULL);
 205         g_signal_connect(G_OBJECT(window), "key_press_event",
 206                          G_CALLBACK(key_pressed), NULL);
 207         MANAGE_WINDOW_SIGNALS_CONNECT (window);
 208
 209         hbox1 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
 210         vbox1 = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
 211         delete_btn = gtkut_stock_button("edit-delete", _("D_elete"));
 212
 213         g_signal_connect(G_OBJECT(delete_btn), "clicked",
 214                          G_CALLBACK(ssl_manager_delete_cb), NULL);
 215
 216         view_btn = gtkut_stock_button("dialog-information", _("_Information"));
 217         g_signal_connect(G_OBJECT(view_btn), "clicked",
 218                          G_CALLBACK(ssl_manager_view_cb), NULL);
 219
 220         close_btn = gtk_button_new_with_mnemonic("_Close");
 221         gtk_button_set_image(GTK_BUTTON(close_btn),
 222                         gtk_image_new_from_icon_name("window-close", GTK_ICON_SIZE_BUTTON));
 223         g_signal_connect(G_OBJECT(close_btn), "clicked",
 224                          G_CALLBACK(ssl_manager_close_cb), NULL);
 225
 226         certlist = ssl_manager_list_view_create();
 227
 228         scroll = gtk_scrolled_window_new (NULL, NULL);
 229         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
 230                                         GTK_POLICY_NEVER,
 231                                         GTK_POLICY_AUTOMATIC);
 232
 233         gtk_container_add(GTK_CONTAINER (scroll), certlist);
 234
 235         gtk_box_pack_start(GTK_BOX(hbox1), scroll, TRUE, TRUE, 0);
 236         gtk_box_pack_start(GTK_BOX(hbox1), vbox1, FALSE, FALSE, 0);
 237         gtk_box_pack_start(GTK_BOX(vbox1), view_btn, FALSE, FALSE, 4);
 238         gtk_box_pack_start(GTK_BOX(vbox1), delete_btn, FALSE, FALSE, 4);
 239         gtk_box_pack_end(GTK_BOX(vbox1), close_btn, FALSE, FALSE, 4);
 240
 241         if (!geometry.min_height) {
 242                 geometry.min_width = 700;
 243                 geometry.min_height = 250;
 244         }
 245
 246         gtk_window_set_geometry_hints(GTK_WINDOW(window), NULL, &geometry,
 247                                       GDK_HINT_MIN_SIZE);
 248         gtk_window_set_default_size(GTK_WINDOW(window),
 249                                     prefs_common.sslmanwin_width,
 250                                     prefs_common.sslmanwin_height);
 251
 252         gtk_widget_show(certlist);
 253         gtk_widget_show(scroll);
 254         gtk_widget_show(hbox1);
 255         gtk_widget_show(vbox1);
 256         gtk_widget_show(close_btn);
 257         gtk_widget_show(delete_btn);
 258         gtk_widget_show(view_btn);
 259         gtk_container_add(GTK_CONTAINER (window), hbox1);
 260
 261         manager.window = window;
 262         manager.hbox1 = hbox1;
 263         manager.vbox1 = vbox1;
 264         manager.certlist = certlist;
 265         manager.view_btn = view_btn;
 266         manager.delete_btn = delete_btn;
 267         manager.close_btn = close_btn;
 268
 269         gtk_widget_show(window);
 270 }
 271
 272 static void ssl_manager_list_view_insert_cert(GtkWidget *list_view,
 273                                                   GtkTreeIter *row_iter,
 274                                                   gchar *host,
 275                                                   gchar *port,
 276                                                   SSLCertificate *cert)
 277 {
 278         char *sig_status, *exp_date;
 279         char buf[100];
 280         time_t exp_time_t;
 281         struct tm lt;
 282         PangoWeight weight = PANGO_WEIGHT_NORMAL;
 283         GtkTreeIter iter, *iterptr;
 284         GtkListStore *list_store = GTK_LIST_STORE(gtk_tree_view_get_model
 285                                         (GTK_TREE_VIEW(list_view)));
 286
 287         g_return_if_fail(cert != NULL);
 288
 289         exp_time_t = gnutls_x509_crt_get_expiration_time(cert->x509_cert);
 290
 291         memset(buf, 0, sizeof(buf));
 292         if (exp_time_t > 0) {
 293                 fast_strftime(buf, sizeof(buf)-1, prefs_common.date_format, localtime_r(&exp_time_t, &lt));
 294                 exp_date = (*buf) ? g_strdup(buf):g_strdup("?");
 295         } else
 296                 exp_date = g_strdup("");
 297
 298         if (exp_time_t < time(NULL))
 299                 weight = PANGO_WEIGHT_BOLD;
 300
 301         sig_status = ssl_certificate_check_signer(cert, cert->status);
 302
 303         if (sig_status == NULL)
 304                 sig_status = g_strdup_printf(_("Correct%s"),exp_time_t < time(NULL)? _(" (expired)"): "");
 305         else {
 306                  weight = PANGO_WEIGHT_BOLD;
 307                  if (exp_time_t < time(NULL))
 308                           sig_status = g_strconcat(sig_status,_(" (expired)"),NULL);
 309         }
 310
 311         if (row_iter == NULL) {
 312                 /* append new */
 313                 gtk_list_store_append(list_store, &iter);
 314                 iterptr = &iter;
 315         } else
 316                 iterptr = row_iter;
 317
 318         gtk_list_store_set(list_store, iterptr,
 319                            SSL_MANAGER_HOST, host,
 320                            SSL_MANAGER_PORT, port,
 321                            SSL_MANAGER_CERT, cert,
 322                            SSL_MANAGER_STATUS, sig_status,
 323                            SSL_MANAGER_EXPIRY, exp_date,
 324                            SSL_MANAGER_FONT_WEIGHT, weight,
 325                            -1);
 326
 327         g_free(sig_status);
 328         g_free(exp_date);
 329 }
 330
 331 static void ssl_manager_load_certs (void)
 332 {
 333         GDir *dir;
 334         const gchar *d;
 335         GError *error = NULL;
 336         gchar *path;
 337         int row = 0;
 338         GtkListStore *store;
 339
 340         store = GTK_LIST_STORE(gtk_tree_view_get_model
 341                                 (GTK_TREE_VIEW(manager.certlist)));
 342
 343         gtk_list_store_clear(store);
 344
 345         path = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
 346                           "certs", G_DIR_SEPARATOR_S, NULL);
 347
 348         if((dir = g_dir_open(path, 0, &error)) == NULL) {
 349                 debug_print("couldn't open dir '%s': %s (%d)\n", path,
 350                                 error->message, error->code);
 351                 g_error_free(error);
 352         g_free(path);
 353                 return;
 354         }
 355
 356         while ((d = g_dir_read_name(dir)) != NULL) {
 357                 gchar *server = NULL, *port = NULL, *fp = NULL;
 358                 SSLCertificate *cert;
 359
 360                 if(strstr(d, ".cert") != d + (strlen(d) - strlen(".cert")))
 361                         continue;
 362
 363                 if (get_serverportfp_from_filename(d, &server, &port, &fp)) {
 364
 365                         if (server != NULL && port != NULL) {
 366                                 gint portnum = atoi(port);
 367                                 if (portnum > 0 && portnum <= 65535) {
 368                                         cert = ssl_certificate_find(server, portnum, fp);
 369                                         ssl_manager_list_view_insert_cert(manager.certlist, NULL,
 370                                                         server, port, cert);
 371                                 }
 372                         }
 373                 }
 374                 if (server)
 375                         g_free(server);
 376                 if (port)
 377                         g_free(port);
 378                 if (fp)
 379                         g_free(fp);
 380                 row++;
 381         }
 382         g_dir_close(dir);
 383         g_free(path);
 384 }
 385
 386 static void ssl_manager_close(void)
 387 {
 388         gtk_widget_hide(manager.window);
 389 }
 390
 391 static void ssl_manager_close_cb(GtkWidget *widget,
 392                                  gpointer data)
 393 {
 394         ssl_manager_close();
 395 }
 396
 397 static gboolean key_pressed(GtkWidget *widget, GdkEventKey *event, gpointer data)
 398 {
 399         if (!event)
 400                 return FALSE;
 401
 402         if (event->keyval == GDK_KEY_Escape)
 403                 ssl_manager_close();
 404         else if (event->keyval == GDK_KEY_Delete)
 405                 ssl_manager_delete_cb(manager.delete_btn, NULL);
 406
 407         return FALSE;
 408 }
 409
 410 static void ssl_manager_double_clicked(GtkTreeView              *list_view,
 411                                         GtkTreePath             *path,
 412                                         GtkTreeViewColumn       *column,
 413                                         gpointer                 data)
 414 {
 415         SSLCertificate *cert;
 416         GtkTreeIter iter;
 417         GtkTreeModel *model = gtk_tree_view_get_model(list_view);
 418
 419         if (!gtk_tree_model_get_iter(model, &iter, path))
 420                 return;
 421
 422         gtk_tree_model_get(model, &iter,
 423                            SSL_MANAGER_CERT, &cert,
 424                            -1);
 425
 426         if (!cert)
 427                 return;
 428
 429         sslcertwindow_show_cert(cert);
 430
 431         return;
 432 }
 433
 434
 435
 436 static void ssl_manager_delete_cb(GtkWidget *widget,
 437                               gpointer data)
 438 {
 439         SSLCertificate *cert;
 440         int val;
 441         GtkTreeIter iter;
 442         GtkTreeModel *model;
 443
 444         cert = gtkut_tree_view_get_selected_pointer(
 445                         GTK_TREE_VIEW(manager.certlist), SSL_MANAGER_CERT,
 446                         &model, NULL, &iter);
 447
 448         if (!cert)
 449                 return;
 450
 451         val = alertpanel_full(_("Delete certificate"),
 452                               _("Do you really want to delete this certificate?"),
 453                               NULL, _("_Cancel"), "edit-delete", _("D_elete"), NULL, NULL,
 454                               ALERTFOCUS_FIRST, FALSE, NULL, ALERT_WARNING);
 455
 456
 457         if (val != G_ALERTALTERNATE)
 458                 return;
 459
 460         ssl_certificate_delete_from_disk(cert);
 461         ssl_certificate_destroy(cert);
 462         gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
 463 }
 464
 465 static void ssl_manager_view_cb(GtkWidget *widget,
 466                                 gpointer data)
 467 {
 468         SSLCertificate *cert;
 469
 470         cert = gtkut_tree_view_get_selected_pointer(
 471                         GTK_TREE_VIEW(manager.certlist), SSL_MANAGER_CERT,
 472                         NULL, NULL, NULL);
 473
 474         if (!cert)
 475                 return;
 476
 477         sslcertwindow_show_cert(cert);
 478 }
 479 #endif