From: Jani Nikula Date: Sun, 3 Mar 2013 14:10:11 +0000 (+0200) Subject: [PATCH 2/2] cli: mime node: abstract decryption and signature verification X-Git-Url: http://git.tremily.us/gitweb.cgi?a=commitdiff_plain;h=2624986a1b667672b6c9fa5e02b478488bc8dcce;p=notmuch-archives.git [PATCH 2/2] cli: mime node: abstract decryption and signature verification --- diff --git a/2a/682711dcd3db730de3a41e1e4b09177203d84e b/2a/682711dcd3db730de3a41e1e4b09177203d84e new file mode 100644 index 000000000..fdb0d97ce --- /dev/null +++ b/2a/682711dcd3db730de3a41e1e4b09177203d84e @@ -0,0 +1,342 @@ +Return-Path: +X-Original-To: notmuch@notmuchmail.org +Delivered-To: notmuch@notmuchmail.org +Received: from localhost (localhost [127.0.0.1]) + by olra.theworths.org (Postfix) with ESMTP id 826FD431FD0 + for ; Sun, 3 Mar 2013 06:10:24 -0800 (PST) +X-Virus-Scanned: Debian amavisd-new at olra.theworths.org +X-Amavis-Alert: BAD HEADER SECTION, Duplicate header field: "References" +X-Spam-Flag: NO +X-Spam-Score: -0.7 +X-Spam-Level: +X-Spam-Status: No, score=-0.7 tagged_above=-999 required=5 + tests=[RCVD_IN_DNSWL_LOW=-0.7] autolearn=disabled +Received: from olra.theworths.org ([127.0.0.1]) + by localhost (olra.theworths.org [127.0.0.1]) (amavisd-new, port 10024) + with ESMTP id RYEOZXK7aNPN for ; + Sun, 3 Mar 2013 06:10:22 -0800 (PST) +Received: from mail-lb0-f175.google.com (mail-lb0-f175.google.com + [209.85.217.175]) (using TLSv1 with cipher RC4-SHA (128/128 bits)) + (No client certificate requested) + by olra.theworths.org (Postfix) with ESMTPS id 92605431FBF + for ; Sun, 3 Mar 2013 06:10:18 -0800 (PST) +Received: by mail-lb0-f175.google.com with SMTP id n3so3268560lbo.6 + for ; Sun, 03 Mar 2013 06:10:17 -0800 (PST) +X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; + d=google.com; s=20120113; + h=x-received:from:to:cc:subject:date:message-id:x-mailer:in-reply-to + :references:in-reply-to:references:x-gm-message-state; + bh=u5nYV6lPQeWzSD0ohAho2tviQoGMdjNz+oNnkID1qjE=; + b=QaPpZMsfDZDvt2WokOapjegeIO37dWo0G0s4t6hihiw7af6MoRhOAxg2viyA8hBTu1 + KcZao7CnLoVrbPGj5uUouFsgsATr0sQwLkoqS/Wxs8mHk5YimalaFFKAg5/PuGf3Zkmi + x+c2IEdn5VIhbBWiaJEQ7GTEzEKulcw5z8YmZmiHMidm/1xmjiBYKdtjlfpiO/C1E2WY + e4oonriXNxei+IAjrdWw6Qta5yeL3LFsM+NHQt3lNV/QuFgCCdVI4Zjflg1NGg/af9Tg + 77TFAJsOPoAePPPLG53hG5oKqkfHqGs2maBfcfeh2gr32jFJ8FoHrbJYx9YvvuLqw50I + 2vHg== +X-Received: by 10.112.10.138 with SMTP id i10mr3278034lbb.24.1362319816975; + Sun, 03 Mar 2013 06:10:16 -0800 (PST) +Received: from localhost (dsl-hkibrasgw4-50df51-27.dhcp.inet.fi. + [80.223.81.27]) + by mx.google.com with ESMTPS id fz16sm10111409lab.5.2013.03.03.06.10.15 + (version=TLSv1.2 cipher=RC4-SHA bits=128/128); + Sun, 03 Mar 2013 06:10:16 -0800 (PST) +From: Jani Nikula +To: notmuch@notmuchmail.org +Subject: [PATCH 2/2] cli: mime node: abstract decryption and signature + verification +Date: Sun, 3 Mar 2013 16:10:11 +0200 +Message-Id: + +X-Mailer: git-send-email 1.7.10.4 +In-Reply-To: + +References: + +In-Reply-To: + +References: + +X-Gm-Message-State: + ALoCoQlIbNTVORhZRgaPwImmcXNybkmI21zLix5fPWHMku2hhN+YinpCRaCTlRXXff3XTmWjQuvP +X-BeenThere: notmuch@notmuchmail.org +X-Mailman-Version: 2.1.13 +Precedence: list +List-Id: "Use and development of the notmuch mail system." + +List-Unsubscribe: , + +List-Archive: +List-Post: +List-Help: +List-Subscribe: , + +X-List-Received-Date: Sun, 03 Mar 2013 14:10:24 -0000 + +The code filled with #ifdef GMIME_ATLEAST_26 is difficult to +read. Abstract the decryption and signature verification into +functions, with separate implementations for GMime 2.4 and 2.6, to +clarify the code. + +There should be no functional changes. +--- + mime-node.c | 210 ++++++++++++++++++++++++++++++++++++++--------------------- + 1 file changed, 134 insertions(+), 76 deletions(-) + +diff --git a/mime-node.c b/mime-node.c +index 839737a..ba7f709 100644 +--- a/mime-node.c ++++ b/mime-node.c +@@ -130,26 +130,155 @@ DONE: + } + + #ifdef GMIME_ATLEAST_26 ++ + static int + _signature_list_free (GMimeSignatureList **proxy) + { + g_object_unref (*proxy); + return 0; + } +-#else ++ ++static void ++set_signature_list_destructor (mime_node_t *node) ++{ ++ GMimeSignatureList **proxy = talloc (node, GMimeSignatureList *); ++ if (proxy) { ++ *proxy = node->sig_list; ++ talloc_set_destructor (proxy, _signature_list_free); ++ } ++} ++ ++static void ++node_verify (mime_node_t *node, GMimeObject *part, ++ notmuch_crypto_context_t *cryptoctx) ++{ ++ GError *err = NULL; ++ ++ node->verify_attempted = TRUE; ++ node->sig_list = g_mime_multipart_signed_verify ++ (GMIME_MULTIPART_SIGNED (part), cryptoctx, &err); ++ ++ if (node->sig_list) ++ set_signature_list_destructor (node); ++ else ++ fprintf (stderr, "Failed to verify signed part: %s\n", ++ err ? err->message : "no error explanation given"); ++ ++ if (err) ++ g_error_free (err); ++} ++ ++static void ++node_decrypt_and_verify (mime_node_t *node, GMimeObject *part, ++ notmuch_crypto_context_t *cryptoctx) ++{ ++ GError *err = NULL; ++ GMimeDecryptResult *decrypt_result = NULL; ++ GMimeMultipartEncrypted *encrypteddata = GMIME_MULTIPART_ENCRYPTED (part); ++ ++ node->decrypt_attempted = TRUE; ++ node->decrypted_child = g_mime_multipart_encrypted_decrypt ++ (encrypteddata, cryptoctx, &decrypt_result, &err); ++ if (! node->decrypted_child) { ++ fprintf (stderr, "Failed to decrypt part: %s\n", ++ err ? err->message : "no error explanation given"); ++ goto DONE; ++ } ++ ++ node->decrypt_success = TRUE; ++ node->verify_attempted = TRUE; ++ ++ /* This may be NULL if the part is not signed. */ ++ node->sig_list = g_mime_decrypt_result_get_signatures (decrypt_result); ++ if (node->sig_list) { ++ g_object_ref (node->sig_list); ++ set_signature_list_destructor (node); ++ } ++ g_object_unref (decrypt_result); ++ ++ DONE: ++ if (err) ++ g_error_free (err); ++} ++ ++#else /* GMIME_ATLEAST_26 */ ++ + static int + _signature_validity_free (GMimeSignatureValidity **proxy) + { + g_mime_signature_validity_free (*proxy); + return 0; + } +-#endif ++ ++static void ++set_signature_validity_destructor (mime_node_t *node) ++{ ++ GMimeSignatureValidity **proxy = talloc (node, GMimeSignatureValidity *); ++ if (proxy) { ++ *proxy = node->sig_validity; ++ talloc_set_destructor (proxy, _signature_validity_free); ++ } ++} ++ ++static void ++node_verify (mime_node_t *node, GMimeObject *part, ++ notmuch_crypto_context_t *cryptoctx) ++{ ++ GError *err = NULL; ++ ++ node->verify_attempted = TRUE; ++ node->sig_validity = g_mime_multipart_signed_verify ++ (GMIME_MULTIPART_SIGNED (part), cryptoctx, &err); ++ if (node->sig_validity) { ++ set_signature_validity_destructor (node); ++ } else { ++ fprintf (stderr, "Failed to verify signed part: %s\n", ++ err ? err->message : "no error explanation given"); ++ } ++ ++ if (err) ++ g_error_free (err); ++} ++ ++static void ++node_decrypt_and_verify (mime_node_t *node, GMimeObject *part, ++ notmuch_crypto_context_t *cryptoctx) ++{ ++ GError *err = NULL; ++ GMimeMultipartEncrypted *encrypteddata = GMIME_MULTIPART_ENCRYPTED (part); ++ ++ node->decrypt_attempted = TRUE; ++ node->decrypted_child = g_mime_multipart_encrypted_decrypt ++ (encrypteddata, cryptoctx, &err); ++ if (! node->decrypted_child) { ++ fprintf (stderr, "Failed to decrypt part: %s\n", ++ err ? err->message : "no error explanation given"); ++ goto DONE; ++ } ++ ++ node->decrypt_success = TRUE; ++ node->verify_attempted = TRUE; ++ ++ /* The GMimeSignatureValidity returned here is a const, unlike the ++ * one returned by g_mime_multipart_signed_verify() in ++ * node_verify() above, so the destructor is not needed. ++ */ ++ node->sig_validity = g_mime_multipart_encrypted_get_signature_validity (encrypteddata); ++ if (! node->sig_validity) ++ fprintf (stderr, "Failed to verify encrypted signed part: %s\n", ++ err ? err->message : "no error explanation given"); ++ ++ DONE: ++ if (err) ++ g_error_free (err); ++} ++ ++#endif /* GMIME_ATLEAST_26 */ + + static mime_node_t * + _mime_node_create (mime_node_t *parent, GMimeObject *part) + { + mime_node_t *node = talloc_zero (parent, mime_node_t); +- GError *err = NULL; + notmuch_crypto_context_t *cryptoctx = NULL; + + /* Set basic node properties */ +@@ -198,32 +327,7 @@ _mime_node_create (mime_node_t *parent, GMimeObject *part) + "message (must be exactly 2)\n", + node->nchildren); + } else { +- GMimeMultipartEncrypted *encrypteddata = +- GMIME_MULTIPART_ENCRYPTED (part); +- node->decrypt_attempted = TRUE; +-#ifdef GMIME_ATLEAST_26 +- GMimeDecryptResult *decrypt_result = NULL; +- node->decrypted_child = g_mime_multipart_encrypted_decrypt +- (encrypteddata, cryptoctx, &decrypt_result, &err); +-#else +- node->decrypted_child = g_mime_multipart_encrypted_decrypt +- (encrypteddata, cryptoctx, &err); +-#endif +- if (node->decrypted_child) { +- node->decrypt_success = node->verify_attempted = TRUE; +-#ifdef GMIME_ATLEAST_26 +- /* This may be NULL if the part is not signed. */ +- node->sig_list = g_mime_decrypt_result_get_signatures (decrypt_result); +- if (node->sig_list) +- g_object_ref (node->sig_list); +- g_object_unref (decrypt_result); +-#else +- node->sig_validity = g_mime_multipart_encrypted_get_signature_validity (encrypteddata); +-#endif +- } else { +- fprintf (stderr, "Failed to decrypt part: %s\n", +- (err ? err->message : "no error explanation given")); +- } ++ node_decrypt_and_verify (node, part, cryptoctx); + } + } else if (GMIME_IS_MULTIPART_SIGNED (part) && node->ctx->crypto->verify && cryptoctx) { + if (node->nchildren != 2) { +@@ -232,56 +336,10 @@ _mime_node_create (mime_node_t *parent, GMimeObject *part) + "(must be exactly 2)\n", + node->nchildren); + } else { +-#ifdef GMIME_ATLEAST_26 +- node->sig_list = g_mime_multipart_signed_verify +- (GMIME_MULTIPART_SIGNED (part), cryptoctx, &err); +- node->verify_attempted = TRUE; +- +- if (!node->sig_list) +- fprintf (stderr, "Failed to verify signed part: %s\n", +- (err ? err->message : "no error explanation given")); +-#else +- /* For some reason the GMimeSignatureValidity returned +- * here is not a const (inconsistent with that +- * returned by +- * g_mime_multipart_encrypted_get_signature_validity, +- * and therefore needs to be properly disposed of. +- * +- * In GMime 2.6, they're both non-const, so we'll be able +- * to clean up this asymmetry. */ +- GMimeSignatureValidity *sig_validity = g_mime_multipart_signed_verify +- (GMIME_MULTIPART_SIGNED (part), cryptoctx, &err); +- node->verify_attempted = TRUE; +- node->sig_validity = sig_validity; +- if (sig_validity) { +- GMimeSignatureValidity **proxy = +- talloc (node, GMimeSignatureValidity *); +- *proxy = sig_validity; +- talloc_set_destructor (proxy, _signature_validity_free); +- } +-#endif ++ node_verify (node, part, cryptoctx); + } + } + +-#ifdef GMIME_ATLEAST_26 +- /* sig_list may be created in both above cases, so we need to +- * cleanly handle it here. */ +- if (node->sig_list) { +- GMimeSignatureList **proxy = talloc (node, GMimeSignatureList *); +- *proxy = node->sig_list; +- talloc_set_destructor (proxy, _signature_list_free); +- } +-#endif +- +-#ifndef GMIME_ATLEAST_26 +- if (node->verify_attempted && !node->sig_validity) +- fprintf (stderr, "Failed to verify signed part: %s\n", +- (err ? err->message : "no error explanation given")); +-#endif +- +- if (err) +- g_error_free (err); +- + return node; + } + +-- +1.7.10.4 +