git.chise.org Git - elisp/gnus.git-/blob - lisp/canlock.el

   1 ;;; canlock.el --- functions for Cancel-Lock feature
   2
   3 ;; Copyright (C) 1998, 1999, 2001, 2002, 2003, 2004
   4 ;; Free Software Foundation, Inc.
   5
   6 ;; Author: Katsumi Yamaoka <yamaoka@jpl.org>
   7 ;; Keywords: news, cancel-lock, hmac, sha1, rfc2104
   8
   9 ;; This program is free software; you can redistribute it and/or modify
  10 ;; it under the terms of the GNU General Public License as published by
  11 ;; the Free Software Foundation; either version 2, or (at your option)
  12 ;; any later version.
  13
  14 ;; This program is distributed in the hope that it will be useful,
  15 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 ;; GNU General Public License for more details.
  18
  19 ;; You should have received a copy of the GNU General Public License
  20 ;; along with this program; see the file COPYING.  If not, write to the
  21 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  22 ;; Boston, MA 02111-1307, USA.
  23
  24 ;;; Commentary:
  25
  26 ;; Canlock is a library for generating and verifying Cancel-Lock and/or
  27 ;; Cancel-Key header in news articles.  This is used to protect articles
  28 ;; from rogue cancel, supersede or replace attacks.  The method is based
  29 ;; on draft-ietf-usefor-cancel-lock-01.txt which was released on November
  30 ;; 3rd 1998.  For instance, you can add Cancel-Lock (and possibly Cancel-
  31 ;; Key) header in a news article by using a hook which will be evaluated
  32 ;; just before sending an article as follows:
  33 ;;
  34 ;; (add-hook '*e**a*e-header-hook 'canlock-insert-header t)
  35 ;;
  36 ;; Verifying Cancel-Lock is mainly a function of news servers, however,
  37 ;; you can verify your own article using the command `canlock-verify' in
  38 ;; the (raw) article buffer.  You will be prompted for the password for
  39 ;; each time if the option `canlock-password' or `canlock-password-for-
  40 ;; verify' is nil.  Note that setting these options is a bit unsafe.
  41
  42 ;;; Code:
  43
  44 (eval-when-compile
  45   (require 'cl))
  46
  47 (eval-and-compile
  48   (require 'sha1-el)
  49   (condition-case nil
  50       (sha1 "" nil nil 'binary)
  51     (wrong-number-of-arguments
  52      (let ((mel (locate-library "mel")))
  53        (when mel
  54          (load (expand-file-name "sha1-el" (file-name-directory mel))
  55                nil t))))))
  56
  57 (autoload 'mail-fetch-field "mail-utils")
  58 (defvar mail-header-separator)
  59
  60 (defgroup canlock nil
  61   "The Cancel-Lock feature."
  62   :group 'applications)
  63
  64 (defcustom canlock-password nil
  65   "Password to use when signing a Cancel-Lock or a Cancel-Key header."
  66   :type '(radio (const :format "Not specified " nil)
  67                 (string :tag "Password" :size 0))
  68   :group 'canlock)
  69
  70 (defcustom canlock-password-for-verify canlock-password
  71   "Password to use when verifying a Cancel-Lock or a Cancel-Key header."
  72   :type '(radio (const :format "Not specified " nil)
  73                 (string :tag "Password" :size 0))
  74   :group 'canlock)
  75
  76 (defcustom canlock-force-insert-header nil
  77   "If non-nil, insert a Cancel-Lock or a Cancel-Key header even if the
  78 buffer does not look like a news message."
  79   :type 'boolean
  80   :group 'canlock)
  81
  82 (eval-when-compile
  83   (defmacro canlock-string-as-unibyte (string)
  84     "Return a unibyte string with the same individual bytes as STRING."
  85     (if (fboundp 'string-as-unibyte)
  86         (list 'string-as-unibyte string)
  87       string)))
  88
  89 (defun canlock-sha1 (message)
  90   "Make a SHA-1 digest of MESSAGE as a unibyte string of length 20 bytes."
  91   (condition-case nil
  92       (let (sha1-maximum-internal-length)
  93         (sha1 message nil nil 'binary))
  94     (wrong-number-of-arguments
  95      (canlock-string-as-unibyte (sha1-binary message)))))
  96
  97 (defun canlock-make-cancel-key (message-id password)
  98   "Make a Cancel-Key header."
  99   (when (> (length password) 20)
 100     (setq password (canlock-sha1 password)))
 101   (setq password (concat password (make-string (- 64 (length password)) 0)))
 102   (let ((ipad (mapconcat (lambda (byte)
 103                            (char-to-string (logxor 54 byte)))
 104                          password ""))
 105         (opad (mapconcat (lambda (byte)
 106                            (char-to-string (logxor 92 byte)))
 107                          password "")))
 108     (base64-encode-string
 109      (canlock-sha1
 110       (concat opad
 111               (canlock-sha1
 112                (concat ipad (canlock-string-as-unibyte message-id))))))))
 113
 114 (defun canlock-narrow-to-header ()
 115   "Narrow the buffer to the head of the message."
 116   (let (case-fold-search)
 117     (narrow-to-region
 118      (goto-char (point-min))
 119      (goto-char (if (re-search-forward
 120                      (format "^$\\|^%s$"
 121                              (regexp-quote mail-header-separator))
 122                      nil t)
 123                     (match-beginning 0)
 124                   (point-max))))))
 125
 126 (defun canlock-delete-headers ()
 127   "Delete Cancel-Key or Cancel-Lock headers in the narrowed buffer."
 128   (let ((case-fold-search t))
 129     (goto-char (point-min))
 130     (while (re-search-forward "^Cancel-\\(Key\\|Lock\\):" nil t)
 131       (delete-region (match-beginning 0)
 132                      (if (re-search-forward "^[^\t ]" nil t)
 133                          (goto-char (match-beginning 0))
 134                        (point-max))))))
 135
 136 (defun canlock-fetch-fields (&optional key)
 137   "Return a list of the values of Cancel-Lock header.
 138 If KEY is non-nil, look for a Cancel-Key header instead.  The buffer
 139 is expected to be narrowed to just the headers of the message."
 140   (let ((field (mail-fetch-field (if key "Cancel-Key" "Cancel-Lock")))
 141         fields rest
 142         (case-fold-search t))
 143     (when field
 144       (setq fields (split-string field "[\t\n\r ,]+"))
 145       (while fields
 146         (when (string-match "^sha1:" (setq field (pop fields)))
 147           (push (substring field 5) rest)))
 148       (nreverse rest))))
 149
 150 (defun canlock-fetch-id-for-key ()
 151   "Return a Message-ID in Cancel, Supersedes or Replaces header.
 152 The buffer is expected to be narrowed to just the headers of the
 153 message."
 154   (or (let ((cancel (mail-fetch-field "Control")))
 155         (and cancel
 156              (string-match "^cancel[\t ]+\\(<[^\t\n @<>]+@[^\t\n @<>]+>\\)"
 157                            cancel)
 158              (match-string 1 cancel)))
 159       (mail-fetch-field "Supersedes")
 160       (mail-fetch-field "Replaces")))
 161
 162 ;;;###autoload
 163 (defun canlock-insert-header (&optional id-for-key id-for-lock password)
 164   "Insert a Cancel-Key and/or a Cancel-Lock header if possible."
 165   (let (news control key-for-key key-for-lock)
 166     (save-excursion
 167       (save-restriction
 168         (canlock-narrow-to-header)
 169         (when (setq news (or canlock-force-insert-header
 170                              (mail-fetch-field "Newsgroups")))
 171           (unless id-for-key
 172             (setq id-for-key (canlock-fetch-id-for-key)))
 173           (if (and (setq control (mail-fetch-field "Control"))
 174                    (string-match "^cancel[\t ]+<[^\t\n @<>]+@[^\t\n @<>]+>"
 175                                  control))
 176               (setq id-for-lock nil)
 177             (unless id-for-lock
 178               (setq id-for-lock (mail-fetch-field "Message-ID"))))
 179           (canlock-delete-headers)
 180           (goto-char (point-max))))
 181       (when news
 182         (if (not (or id-for-key id-for-lock))
 183             (message "There are no Message-ID(s)")
 184           (unless password
 185             (setq password (or canlock-password
 186                                (read-passwd
 187                                 "Password for Canlock: "))))
 188           (if (or (not (stringp password)) (zerop (length password)))
 189               (message "Password for Canlock is bad")
 190             (setq key-for-key (when id-for-key
 191                                 (canlock-make-cancel-key
 192                                  id-for-key password))
 193                   key-for-lock (when id-for-lock
 194                                  (canlock-make-cancel-key
 195                                   id-for-lock password)))
 196             (if (not (or key-for-key key-for-lock))
 197                 (message "Couldn't insert Canlock header")
 198               (when key-for-key
 199                 (insert "Cancel-Key: sha1:" key-for-key "\n"))
 200               (when key-for-lock
 201                 (insert "Cancel-Lock: sha1:"
 202                         (base64-encode-string (canlock-sha1 key-for-lock))
 203                         "\n")))))))))
 204
 205 ;;;###autoload
 206 (defun canlock-verify (&optional buffer)
 207   "Verify Cancel-Lock or Cancel-Key in BUFFER.
 208 If BUFFER is nil, the current buffer is assumed.  Signal an error if
 209 it fails."
 210   (interactive)
 211   (let (keys locks errmsg id-for-key id-for-lock password
 212              key-for-key key-for-lock match)
 213     (save-excursion
 214       (when buffer
 215         (set-buffer buffer))
 216       (save-restriction
 217         (widen)
 218         (canlock-narrow-to-header)
 219         (setq keys (canlock-fetch-fields 'key)
 220               locks (canlock-fetch-fields))
 221         (if (not (or keys locks))
 222             (setq errmsg
 223                   "There are neither Cancel-Lock nor Cancel-Key headers")
 224           (setq id-for-key (canlock-fetch-id-for-key)
 225                 id-for-lock (mail-fetch-field "Message-ID"))
 226           (or id-for-key id-for-lock
 227               (setq errmsg "There are no Message-ID(s)")))))
 228     (if errmsg
 229         (error "%s" errmsg)
 230       (setq password (or canlock-password-for-verify
 231                          (read-passwd "Password for Canlock: ")))
 232       (if (or (not (stringp password)) (zerop (length password)))
 233           (error "Password for Canlock is bad")
 234         (when keys
 235           (when id-for-key
 236             (setq key-for-key (canlock-make-cancel-key id-for-key password))
 237             (while (and keys (not match))
 238               (setq match (string-equal key-for-key (pop keys)))))
 239           (setq keys (if match "good" "bad")))
 240         (setq match nil)
 241         (when locks
 242           (when id-for-lock
 243             (setq key-for-lock
 244                   (base64-encode-string
 245                    (canlock-sha1 (canlock-make-cancel-key id-for-lock
 246                                                           password))))
 247             (when (and locks (not match))
 248               (setq match (string-equal key-for-lock (pop locks)))))
 249           (setq locks (if match "good" "bad")))
 250         (prog1
 251             (when (member "bad" (list keys locks))
 252               "bad")
 253           (cond ((and keys locks)
 254                  (message "Cancel-Key is %s, Cancel-Lock is %s" keys locks))
 255                 (locks
 256                  (message "Cancel-Lock is %s" locks))
 257                 (keys
 258                  (message "Cancel-Key is %s" keys))))))))
 259
 260 (provide 'canlock)
 261
 262 ;;; canlock.el ends here