lisp/epa.el

   1 ;;; epa.el --- the EasyPG Assistant -*- lexical-binding: t -*-
   2
   3 ;; Copyright (C) 2006-2013 Free Software Foundation, Inc.
   4
   5 ;; Author: Daiki Ueno <ueno@unixuser.org>
   6 ;; Keywords: PGP, GnuPG
   7
   8 ;; This file is part of GNU Emacs.
   9
  10 ;; GNU Emacs is free software: you can redistribute it and/or modify
  11 ;; it under the terms of the GNU General Public License as published by
  12 ;; the Free Software Foundation, either version 3 of the License, or
  13 ;; (at your option) any later version.
  14
  15 ;; GNU Emacs is distributed in the hope that it will be useful,
  16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 ;; GNU General Public License for more details.
  19
  20 ;; You should have received a copy of the GNU General Public License
  21 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
  22
  23 ;;; Code:
  24
  25 (require 'epg)
  26 (require 'font-lock)
  27 (require 'widget)
  28 (eval-when-compile (require 'wid-edit))
  29 (require 'derived)
  30
  31 (defgroup epa nil
  32   "The EasyPG Assistant"
  33   :version "23.1"
  34   :group 'epg)
  35
  36 (defcustom epa-popup-info-window t
  37   "If non-nil, status information from epa commands is displayed on
  38 the separate window."
  39   :type 'boolean
  40   :group 'epa)
  41
  42 (defcustom epa-info-window-height 5
  43   "Number of lines used to display status information."
  44   :type 'integer
  45   :group 'epa)
  46
  47 (defgroup epa-faces nil
  48   "Faces for epa-mode."
  49   :version "23.1"
  50   :group 'epa)
  51
  52 (defface epa-validity-high
  53   '((default :weight bold)
  54     (((class color) (background dark)) :foreground "PaleTurquoise"))
  55   "Face for high validity EPA information."
  56   :group 'epa-faces)
  57
  58 (defface epa-validity-medium
  59   '((default :slant italic)
  60     (((class color) (background dark)) :foreground "PaleTurquoise"))
  61   "Face for medium validity EPA information."
  62   :group 'epa-faces)
  63
  64 (defface epa-validity-low
  65   '((t :slant italic))
  66   "Face used for displaying the low validity."
  67   :group 'epa-faces)
  68
  69 (defface epa-validity-disabled
  70   '((t :slant italic :inverse-video t))
  71   "Face used for displaying the disabled validity."
  72   :group 'epa-faces)
  73
  74 (defface epa-string
  75   '((((class color) (background dark))
  76      :foreground "lightyellow")
  77     (((class color) (background light))
  78      :foreground "blue4"))
  79   "Face used for displaying the string."
  80   :group 'epa-faces)
  81
  82 (defface epa-mark
  83   '((default :weight bold)
  84     (((class color) (background dark))  :foreground "orange")
  85     (((class color) (background light)) :foreground "red"))
  86   "Face used for displaying the high validity."
  87   :group 'epa-faces)
  88
  89 (defface epa-field-name
  90   '((default :weight bold)
  91     (((class color) (background dark)) :foreground "PaleTurquoise"))
  92   "Face for the name of the attribute field."
  93   :group 'epa)
  94
  95 (defface epa-field-body
  96   '((default :slant italic)
  97     (((class color) (background dark)) :foreground "turquoise"))
  98   "Face for the body of the attribute field."
  99   :group 'epa)
 100
 101 (defcustom epa-validity-face-alist
 102   '((unknown . epa-validity-disabled)
 103     (invalid . epa-validity-disabled)
 104     (disabled . epa-validity-disabled)
 105     (revoked . epa-validity-disabled)
 106     (expired . epa-validity-disabled)
 107     (none . epa-validity-low)
 108     (undefined . epa-validity-low)
 109     (never . epa-validity-low)
 110     (marginal . epa-validity-medium)
 111     (full . epa-validity-high)
 112     (ultimate . epa-validity-high))
 113   "An alist mapping validity values to faces."
 114   :type '(repeat (cons symbol face))
 115   :group 'epa)
 116
 117 (defvar epa-font-lock-keywords
 118   '(("^\\*"
 119      (0 'epa-mark))
 120     ("^\t\\([^\t:]+:\\)[ \t]*\\(.*\\)$"
 121      (1 'epa-field-name)
 122      (2 'epa-field-body)))
 123   "Default expressions to addon in epa-mode.")
 124
 125 (defconst epa-pubkey-algorithm-letter-alist
 126   '((1 . ?R)
 127     (2 . ?r)
 128     (3 . ?s)
 129     (16 . ?g)
 130     (17 . ?D)
 131     (20 . ?G)))
 132
 133 (defvar epa-protocol 'OpenPGP
 134   "The default protocol.
 135 The value can be either OpenPGP or CMS.
 136
 137 You should bind this variable with `let', but do not set it globally.")
 138
 139 (defvar epa-armor nil
 140   "If non-nil, epa commands create ASCII armored output.
 141
 142 You should bind this variable with `let', but do not set it globally.")
 143
 144 (defvar epa-textmode nil
 145   "If non-nil, epa commands treat input files as text.
 146
 147 You should bind this variable with `let', but do not set it globally.")
 148
 149 (defvar epa-keys-buffer nil)
 150 (defvar epa-key-buffer-alist nil)
 151 (defvar epa-key nil)
 152 (defvar epa-list-keys-arguments nil)
 153 (defvar epa-info-buffer nil)
 154 (defvar epa-last-coding-system-specified nil)
 155
 156 (defvar epa-key-list-mode-map
 157   (let ((keymap (make-sparse-keymap))
 158         (menu-map (make-sparse-keymap)))
 159     (define-key keymap "m" 'epa-mark-key)
 160     (define-key keymap "u" 'epa-unmark-key)
 161     (define-key keymap "d" 'epa-decrypt-file)
 162     (define-key keymap "v" 'epa-verify-file)
 163     (define-key keymap "s" 'epa-sign-file)
 164     (define-key keymap "e" 'epa-encrypt-file)
 165     (define-key keymap "r" 'epa-delete-keys)
 166     (define-key keymap "i" 'epa-import-keys)
 167     (define-key keymap "o" 'epa-export-keys)
 168     (define-key keymap "g" 'revert-buffer)
 169     (define-key keymap "n" 'next-line)
 170     (define-key keymap "p" 'previous-line)
 171     (define-key keymap " " 'scroll-up-command)
 172     (define-key keymap [?\S-\ ] 'scroll-down-command)
 173     (define-key keymap [delete] 'scroll-down-command)
 174     (define-key keymap "q" 'epa-exit-buffer)
 175     (define-key keymap [menu-bar epa-key-list-mode] (cons "Keys" menu-map))
 176     (define-key menu-map [epa-key-list-unmark-key]
 177       '(menu-item "Unmark Key" epa-unmark-key
 178                   :help "Unmark a key"))
 179     (define-key menu-map [epa-key-list-mark-key]
 180       '(menu-item "Mark Key" epa-mark-key
 181                   :help "Mark a key"))
 182     (define-key menu-map [separator-epa-file] '(menu-item "--"))
 183     (define-key menu-map [epa-verify-file]
 184       '(menu-item "Verify File..." epa-verify-file
 185                   :help "Verify FILE"))
 186     (define-key menu-map [epa-sign-file]
 187       '(menu-item "Sign File..." epa-sign-file
 188                   :help "Sign FILE by SIGNERS keys selected"))
 189     (define-key menu-map [epa-decrypt-file]
 190       '(menu-item "Decrypt File..." epa-decrypt-file
 191                   :help "Decrypt FILE"))
 192     (define-key menu-map [epa-encrypt-file]
 193       '(menu-item "Encrypt File..." epa-encrypt-file
 194                   :help "Encrypt FILE for RECIPIENTS"))
 195     (define-key menu-map [separator-epa-key-list] '(menu-item "--"))
 196     (define-key menu-map [epa-key-list-delete-keys]
 197       '(menu-item "Delete Keys" epa-delete-keys
 198                   :help "Delete Marked Keys"))
 199     (define-key menu-map [epa-key-list-import-keys]
 200       '(menu-item "Import Keys" epa-import-keys
 201                   :help "Import keys from a file"))
 202     (define-key menu-map [epa-key-list-export-keys]
 203       '(menu-item "Export Keys" epa-export-keys
 204                   :help "Export marked keys to a file"))
 205     keymap))
 206
 207 (defvar epa-key-mode-map
 208   (let ((keymap (make-sparse-keymap)))
 209     (define-key keymap "q" 'epa-exit-buffer)
 210     keymap))
 211
 212 (defvar epa-info-mode-map
 213   (let ((keymap (make-sparse-keymap)))
 214     (define-key keymap "q" 'delete-window)
 215     keymap))
 216
 217 (defvar epa-exit-buffer-function #'bury-buffer)
 218
 219 (define-widget 'epa-key 'push-button
 220   "Button for representing a epg-key object."
 221   :format "%[%v%]"
 222   :button-face-get 'epa--key-widget-button-face-get
 223   :value-create 'epa--key-widget-value-create
 224   :action 'epa--key-widget-action
 225   :help-echo 'epa--key-widget-help-echo)
 226
 227 (defun epa--key-widget-action (widget &optional _event)
 228   (save-selected-window
 229     (epa--show-key (widget-get widget :value))))
 230
 231 (defun epa--key-widget-value-create (widget)
 232   (let* ((key (widget-get widget :value))
 233          (primary-sub-key (car (epg-key-sub-key-list key)))
 234          (primary-user-id (car (epg-key-user-id-list key))))
 235     (insert (format "%c "
 236                     (if (epg-sub-key-validity primary-sub-key)
 237                         (car (rassq (epg-sub-key-validity primary-sub-key)
 238                                     epg-key-validity-alist))
 239                       ? ))
 240             (epg-sub-key-id primary-sub-key)
 241             " "
 242             (if primary-user-id
 243                 (if (stringp (epg-user-id-string primary-user-id))
 244                     (epg-user-id-string primary-user-id)
 245                   (epg-decode-dn (epg-user-id-string primary-user-id)))
 246               ""))))
 247
 248 (defun epa--key-widget-button-face-get (widget)
 249   (let ((validity (epg-sub-key-validity (car (epg-key-sub-key-list
 250                                               (widget-get widget :value))))))
 251     (if validity
 252         (cdr (assq validity epa-validity-face-alist))
 253       'default)))
 254
 255 (defun epa--key-widget-help-echo (widget)
 256   (format "Show %s"
 257           (epg-sub-key-id (car (epg-key-sub-key-list
 258                                 (widget-get widget :value))))))
 259
 260 (eval-and-compile
 261   (if (fboundp 'encode-coding-string)
 262       (defalias 'epa--encode-coding-string 'encode-coding-string)
 263     (defalias 'epa--encode-coding-string 'identity)))
 264
 265 (eval-and-compile
 266   (if (fboundp 'decode-coding-string)
 267       (defalias 'epa--decode-coding-string 'decode-coding-string)
 268     (defalias 'epa--decode-coding-string 'identity)))
 269
 270 (defun epa-key-list-mode ()
 271   "Major mode for `epa-list-keys'."
 272   (kill-all-local-variables)
 273   (buffer-disable-undo)
 274   (setq major-mode 'epa-key-list-mode
 275         mode-name "Keys"
 276         truncate-lines t
 277         buffer-read-only t)
 278   (use-local-map epa-key-list-mode-map)
 279   (make-local-variable 'font-lock-defaults)
 280   (setq font-lock-defaults '(epa-font-lock-keywords t))
 281   ;; In XEmacs, auto-initialization of font-lock is not effective
 282   ;; if buffer-file-name is not set.
 283   (font-lock-set-defaults)
 284   (make-local-variable 'epa-exit-buffer-function)
 285   (make-local-variable 'revert-buffer-function)
 286   (setq revert-buffer-function 'epa--key-list-revert-buffer)
 287   (run-mode-hooks 'epa-key-list-mode-hook))
 288
 289 (defun epa-key-mode ()
 290   "Major mode for a key description."
 291   (kill-all-local-variables)
 292   (buffer-disable-undo)
 293   (setq major-mode 'epa-key-mode
 294         mode-name "Key"
 295         truncate-lines t
 296         buffer-read-only t)
 297   (use-local-map epa-key-mode-map)
 298   (make-local-variable 'font-lock-defaults)
 299   (setq font-lock-defaults '(epa-font-lock-keywords t))
 300   ;; In XEmacs, auto-initialization of font-lock is not effective
 301   ;; if buffer-file-name is not set.
 302   (font-lock-set-defaults)
 303   (make-local-variable 'epa-exit-buffer-function)
 304   (run-mode-hooks 'epa-key-mode-hook))
 305
 306 (defun epa-info-mode ()
 307   "Major mode for `epa-info-buffer'."
 308   (kill-all-local-variables)
 309   (buffer-disable-undo)
 310   (setq major-mode 'epa-info-mode
 311         mode-name "Info"
 312         truncate-lines t
 313         buffer-read-only t)
 314   (use-local-map epa-info-mode-map)
 315   (run-mode-hooks 'epa-info-mode-hook))
 316
 317 (defun epa-mark-key (&optional arg)
 318   "Mark a key on the current line.
 319 If ARG is non-nil, unmark the key."
 320   (interactive "P")
 321   (let ((inhibit-read-only t)
 322         buffer-read-only
 323         properties)
 324     (beginning-of-line)
 325     (unless (get-text-property (point) 'epa-key)
 326       (error "No key on this line"))
 327     (setq properties (text-properties-at (point)))
 328     (delete-char 1)
 329     (insert (if arg " " "*"))
 330     (set-text-properties (1- (point)) (point) properties)
 331     (forward-line)))
 332
 333 (defun epa-unmark-key (&optional arg)
 334   "Unmark a key on the current line.
 335 If ARG is non-nil, mark the key."
 336   (interactive "P")
 337   (epa-mark-key (not arg)))
 338
 339 (defun epa-exit-buffer ()
 340   "Exit the current buffer.
 341 `epa-exit-buffer-function' is called if it is set."
 342   (interactive)
 343   (funcall epa-exit-buffer-function))
 344
 345 (defun epa--insert-keys (keys)
 346   (save-excursion
 347     (save-restriction
 348       (narrow-to-region (point) (point))
 349       (let (point)
 350         (while keys
 351           (setq point (point))
 352           (insert "  ")
 353           (add-text-properties point (point)
 354                                (list 'epa-key (car keys)
 355                                      'front-sticky nil
 356                                      'rear-nonsticky t
 357                                      'start-open t
 358                                      'end-open t))
 359           (widget-create 'epa-key :value (car keys))
 360           (insert "\n")
 361           (setq keys (cdr keys))))
 362       (add-text-properties (point-min) (point-max)
 363                            (list 'epa-list-keys t
 364                                  'front-sticky nil
 365                                  'rear-nonsticky t
 366                                  'start-open t
 367                                  'end-open t)))))
 368
 369 (defun epa--list-keys (name secret)
 370   (unless (and epa-keys-buffer
 371                (buffer-live-p epa-keys-buffer))
 372     (setq epa-keys-buffer (generate-new-buffer "*Keys*")))
 373   (set-buffer epa-keys-buffer)
 374   (epa-key-list-mode)
 375   (let ((inhibit-read-only t)
 376         buffer-read-only
 377         (point (point-min))
 378         (context (epg-make-context epa-protocol)))
 379     (unless (get-text-property point 'epa-list-keys)
 380       (setq point (next-single-property-change point 'epa-list-keys)))
 381     (when point
 382       (delete-region point
 383                      (or (next-single-property-change point 'epa-list-keys)
 384                          (point-max)))
 385       (goto-char point))
 386     (epa--insert-keys (epg-list-keys context name secret))
 387     (widget-setup)
 388     (set-keymap-parent (current-local-map) widget-keymap))
 389   (make-local-variable 'epa-list-keys-arguments)
 390   (setq epa-list-keys-arguments (list name secret))
 391   (goto-char (point-min))
 392   (pop-to-buffer (current-buffer)))
 393
 394 ;;;###autoload
 395 (defun epa-list-keys (&optional name)
 396   "List all keys matched with NAME from the public keyring."
 397   (interactive
 398    (if current-prefix-arg
 399        (let ((name (read-string "Pattern: "
 400                                 (if epa-list-keys-arguments
 401                                     (car epa-list-keys-arguments)))))
 402          (list (if (equal name "") nil name)))
 403      (list nil)))
 404   (epa--list-keys name nil))
 405
 406 ;;;###autoload
 407 (defun epa-list-secret-keys (&optional name)
 408   "List all keys matched with NAME from the private keyring."
 409   (interactive
 410    (if current-prefix-arg
 411        (let ((name (read-string "Pattern: "
 412                                 (if epa-list-keys-arguments
 413                                     (car epa-list-keys-arguments)))))
 414          (list (if (equal name "") nil name)))
 415      (list nil)))
 416   (epa--list-keys name t))
 417
 418 (defun epa--key-list-revert-buffer (&optional _ignore-auto _noconfirm)
 419   (apply #'epa--list-keys epa-list-keys-arguments))
 420
 421 (defun epa--marked-keys ()
 422   (or (with-current-buffer epa-keys-buffer
 423         (goto-char (point-min))
 424         (let (keys key)
 425           (while (re-search-forward "^\\*" nil t)
 426             (if (setq key (get-text-property (match-beginning 0)
 427                                              'epa-key))
 428                 (setq keys (cons key keys))))
 429           (nreverse keys)))
 430       (let ((key (get-text-property (point-at-bol) 'epa-key)))
 431         (if key
 432             (list key)))))
 433
 434 (defun epa--select-keys (prompt keys)
 435   (unless (and epa-keys-buffer
 436                (buffer-live-p epa-keys-buffer))
 437     (setq epa-keys-buffer (generate-new-buffer "*Keys*")))
 438   (with-current-buffer epa-keys-buffer
 439     (epa-key-list-mode)
 440     ;; C-c C-c is the usual way to finish the selection (bug#11159).
 441     (define-key (current-local-map) "\C-c\C-c" 'exit-recursive-edit)
 442     (let ((inhibit-read-only t)
 443           buffer-read-only)
 444       (erase-buffer)
 445       (insert prompt "\n"
 446               (substitute-command-keys "\
 447 - `\\[epa-mark-key]' to mark a key on the line
 448 - `\\[epa-unmark-key]' to unmark a key on the line\n"))
 449       (widget-create 'link
 450                      :notify (lambda (&rest _ignore) (abort-recursive-edit))
 451                      :help-echo
 452                      (substitute-command-keys
 453                       "Click here or \\[abort-recursive-edit] to cancel")
 454                      "Cancel")
 455       (widget-create 'link
 456                      :notify (lambda (&rest _ignore) (exit-recursive-edit))
 457                      :help-echo
 458                      (substitute-command-keys
 459                       "Click here or \\[exit-recursive-edit] to finish")
 460                      "OK")
 461       (insert "\n\n")
 462       (epa--insert-keys keys)
 463       (widget-setup)
 464       (set-keymap-parent (current-local-map) widget-keymap)
 465       (setq epa-exit-buffer-function #'abort-recursive-edit)
 466       (goto-char (point-min))
 467       (let ((display-buffer-mark-dedicated 'soft))
 468         (pop-to-buffer (current-buffer))))
 469     (unwind-protect
 470         (progn
 471           (recursive-edit)
 472           (epa--marked-keys))
 473       (kill-buffer epa-keys-buffer))))
 474
 475 ;;;###autoload
 476 (defun epa-select-keys (context prompt &optional names secret)
 477   "Display a user's keyring and ask him to select keys.
 478 CONTEXT is an epg-context.
 479 PROMPT is a string to prompt with.
 480 NAMES is a list of strings to be matched with keys.  If it is nil, all
 481 the keys are listed.
 482 If SECRET is non-nil, list secret keys instead of public keys."
 483   (let ((keys (epg-list-keys context names secret)))
 484     (epa--select-keys prompt keys)))
 485
 486 (defun epa--show-key (key)
 487   (let* ((primary-sub-key (car (epg-key-sub-key-list key)))
 488          (entry (assoc (epg-sub-key-id primary-sub-key)
 489                        epa-key-buffer-alist))
 490          (inhibit-read-only t)
 491          buffer-read-only
 492          pointer)
 493     (unless entry
 494       (setq entry (cons (epg-sub-key-id primary-sub-key) nil)
 495             epa-key-buffer-alist (cons entry epa-key-buffer-alist)))
 496     (unless (and (cdr entry)
 497                  (buffer-live-p (cdr entry)))
 498       (setcdr entry (generate-new-buffer
 499                      (format "*Key*%s" (epg-sub-key-id primary-sub-key)))))
 500     (set-buffer (cdr entry))
 501     (epa-key-mode)
 502     (make-local-variable 'epa-key)
 503     (setq epa-key key)
 504     (erase-buffer)
 505     (setq pointer (epg-key-user-id-list key))
 506     (while pointer
 507       (if (car pointer)
 508           (insert " "
 509                   (if (epg-user-id-validity (car pointer))
 510                       (char-to-string
 511                        (car (rassq (epg-user-id-validity (car pointer))
 512                                    epg-key-validity-alist)))
 513                     " ")
 514                   " "
 515                   (if (stringp (epg-user-id-string (car pointer)))
 516                       (epg-user-id-string (car pointer))
 517                     (epg-decode-dn (epg-user-id-string (car pointer))))
 518                   "\n"))
 519       (setq pointer (cdr pointer)))
 520     (setq pointer (epg-key-sub-key-list key))
 521     (while pointer
 522       (insert " "
 523               (if (epg-sub-key-validity (car pointer))
 524                   (char-to-string
 525                    (car (rassq (epg-sub-key-validity (car pointer))
 526                                epg-key-validity-alist)))
 527                 " ")
 528               " "
 529               (epg-sub-key-id (car pointer))
 530               " "
 531               (format "%dbits"
 532                       (epg-sub-key-length (car pointer)))
 533               " "
 534               (cdr (assq (epg-sub-key-algorithm (car pointer))
 535                          epg-pubkey-algorithm-alist))
 536               "\n\tCreated: "
 537               (condition-case nil
 538                   (format-time-string "%Y-%m-%d"
 539                                       (epg-sub-key-creation-time (car pointer)))
 540                 (error "????-??-??"))
 541               (if (epg-sub-key-expiration-time (car pointer))
 542                   (format (if (time-less-p (current-time)
 543                                            (epg-sub-key-expiration-time
 544                                             (car pointer)))
 545                               "\n\tExpires: %s"
 546                             "\n\tExpired: %s")
 547                           (condition-case nil
 548                               (format-time-string "%Y-%m-%d"
 549                                                   (epg-sub-key-expiration-time
 550                                                    (car pointer)))
 551                             (error "????-??-??")))
 552                 "")
 553               "\n\tCapabilities: "
 554               (mapconcat #'symbol-name
 555                          (epg-sub-key-capability (car pointer))
 556                          " ")
 557               "\n\tFingerprint: "
 558               (epg-sub-key-fingerprint (car pointer))
 559               "\n")
 560       (setq pointer (cdr pointer)))
 561     (goto-char (point-min))
 562     (pop-to-buffer (current-buffer))))
 563
 564 (defun epa-display-info (info)
 565   (if epa-popup-info-window
 566       (save-selected-window
 567         (unless (and epa-info-buffer (buffer-live-p epa-info-buffer))
 568           (setq epa-info-buffer (generate-new-buffer "*Info*")))
 569         (if (get-buffer-window epa-info-buffer)
 570             (delete-window (get-buffer-window epa-info-buffer)))
 571         (with-current-buffer epa-info-buffer
 572           (let ((inhibit-read-only t)
 573                 buffer-read-only)
 574             (erase-buffer)
 575             (insert info))
 576           (epa-info-mode)
 577           (goto-char (point-min)))
 578         (if (> (window-height)
 579                epa-info-window-height)
 580             (set-window-buffer (split-window nil (- (window-height)
 581                                                     epa-info-window-height))
 582                                epa-info-buffer)
 583           (pop-to-buffer epa-info-buffer)
 584           (if (> (window-height) epa-info-window-height)
 585               (shrink-window (- (window-height) epa-info-window-height)))))
 586     (message "%s" info)))
 587
 588 (defun epa-display-verify-result (verify-result)
 589   (declare (obsolete epa-display-info "23.1"))
 590   (epa-display-info (epg-verify-result-to-string verify-result)))
 591
 592 (defun epa-passphrase-callback-function (context key-id handback)
 593   (if (eq key-id 'SYM)
 594       (read-passwd
 595        (format "Passphrase for symmetric encryption%s: "
 596                ;; Add the file name to the prompt, if any.
 597                (if (stringp handback)
 598                    (format " for %s" handback)
 599                  ""))
 600        (eq (epg-context-operation context) 'encrypt))
 601     (read-passwd
 602      (if (eq key-id 'PIN)
 603         "Passphrase for PIN: "
 604        (let ((entry (assoc key-id epg-user-id-alist)))
 605          (if entry
 606              (format "Passphrase for %s %s: " key-id (cdr entry))
 607            (format "Passphrase for %s: " key-id)))))))
 608
 609 (defun epa-progress-callback-function (_context what _char current total
 610                                                handback)
 611   (let ((prompt (or handback
 612                     (format "Processing %s: " what))))
 613     ;; According to gnupg/doc/DETAIL: a "total" of 0 indicates that
 614     ;; the total amount is not known. The condition TOTAL && CUR ==
 615     ;; TOTAL may be used to detect the end of an operation.
 616     (if (> total 0)
 617         (if (= current total)
 618             (message "%s...done" prompt)
 619           (message "%s...%d%%" prompt
 620                    (floor (* (/ current (float total)) 100))))
 621       (message "%s..." prompt))))
 622
 623 ;;;###autoload
 624 (defun epa-decrypt-file (decrypt-file plain-file)
 625   "Decrypt DECRYPT-FILE into PLAIN-FILE."
 626   (interactive
 627    (let (file default-name plain)
 628      (setq file (read-file-name "File to decrypt: "))
 629      (setq default-name (file-name-sans-extension (expand-file-name file)))
 630      (setq plain (expand-file-name
 631                   (read-file-name
 632                    (concat "To file (default "
 633                            (file-name-nondirectory default-name)
 634                            ") ")
 635                    (file-name-directory default-name)
 636                    default-name)))
 637      (list file plain)))
 638   (setq decrypt-file (expand-file-name decrypt-file))
 639   (let ((context (epg-make-context epa-protocol)))
 640     (epg-context-set-passphrase-callback context
 641                                          #'epa-passphrase-callback-function)
 642     (epg-context-set-progress-callback context
 643                                        (cons
 644                                         #'epa-progress-callback-function
 645                                         (format "Decrypting %s..."
 646                                                 (file-name-nondirectory decrypt-file))))
 647     (message "Decrypting %s..." (file-name-nondirectory decrypt-file))
 648     (epg-decrypt-file context decrypt-file plain-file)
 649     (message "Decrypting %s...wrote %s" (file-name-nondirectory decrypt-file)
 650              (file-name-nondirectory plain-file))
 651     (if (epg-context-result-for context 'verify)
 652         (epa-display-info (epg-verify-result-to-string
 653                            (epg-context-result-for context 'verify))))))
 654
 655 ;;;###autoload
 656 (defun epa-verify-file (file)
 657   "Verify FILE."
 658   (interactive "fFile: ")
 659   (setq file (expand-file-name file))
 660   (let* ((context (epg-make-context epa-protocol))
 661          (plain (if (equal (file-name-extension file) "sig")
 662                     (file-name-sans-extension file))))
 663     (epg-context-set-progress-callback context
 664                                        (cons
 665                                         #'epa-progress-callback-function
 666                                         (format "Verifying %s..."
 667                                                 (file-name-nondirectory file))))
 668     (message "Verifying %s..." (file-name-nondirectory file))
 669     (epg-verify-file context file plain)
 670     (message "Verifying %s...done" (file-name-nondirectory file))
 671     (if (epg-context-result-for context 'verify)
 672         (epa-display-info (epg-verify-result-to-string
 673                            (epg-context-result-for context 'verify))))))
 674
 675 (defun epa--read-signature-type ()
 676   (let (type c)
 677     (while (null type)
 678       (message "Signature type (n,c,d,?) ")
 679       (setq c (read-char))
 680       (cond ((eq c ?c)
 681              (setq type 'clear))
 682             ((eq c ?d)
 683              (setq type 'detached))
 684             ((eq c ??)
 685              (with-output-to-temp-buffer "*Help*"
 686                (with-current-buffer standard-output
 687                  (insert "\
 688 n - Create a normal signature
 689 c - Create a cleartext signature
 690 d - Create a detached signature
 691 ? - Show this help
 692 "))))
 693             (t
 694              (setq type 'normal))))
 695     type))
 696
 697 ;;;###autoload
 698 (defun epa-sign-file (file signers mode)
 699   "Sign FILE by SIGNERS keys selected."
 700   (interactive
 701    (let ((verbose current-prefix-arg))
 702      (list (expand-file-name (read-file-name "File: "))
 703            (if verbose
 704                (epa-select-keys (epg-make-context epa-protocol)
 705                                 "Select keys for signing.
 706 If no one is selected, default secret key is used.  "
 707                                 nil t))
 708            (if verbose
 709                (epa--read-signature-type)
 710              'clear))))
 711   (let ((signature (concat file
 712                            (if (eq epa-protocol 'OpenPGP)
 713                                (if (or epa-armor
 714                                        (not (memq mode
 715                                                   '(nil t normal detached))))
 716                                    ".asc"
 717                                  (if (memq mode '(t detached))
 718                                      ".sig"
 719                                    ".gpg"))
 720                              (if (memq mode '(t detached))
 721                                  ".p7s"
 722                                ".p7m"))))
 723         (context (epg-make-context epa-protocol)))
 724     (epg-context-set-armor context epa-armor)
 725     (epg-context-set-textmode context epa-textmode)
 726     (epg-context-set-signers context signers)
 727     (epg-context-set-passphrase-callback context
 728                                          #'epa-passphrase-callback-function)
 729     (epg-context-set-progress-callback context
 730                                        (cons
 731                                         #'epa-progress-callback-function
 732                                         (format "Signing %s..."
 733                                                 (file-name-nondirectory file))))
 734     (message "Signing %s..." (file-name-nondirectory file))
 735     (epg-sign-file context file signature mode)
 736     (message "Signing %s...wrote %s" (file-name-nondirectory file)
 737              (file-name-nondirectory signature))))
 738
 739 ;;;###autoload
 740 (defun epa-encrypt-file (file recipients)
 741   "Encrypt FILE for RECIPIENTS."
 742   (interactive
 743    (list (expand-file-name (read-file-name "File: "))
 744          (epa-select-keys (epg-make-context epa-protocol)
 745                           "Select recipients for encryption.
 746 If no one is selected, symmetric encryption will be performed.  ")))
 747   (let ((cipher (concat file (if (eq epa-protocol 'OpenPGP)
 748                                  (if epa-armor ".asc" ".gpg")
 749                                ".p7m")))
 750         (context (epg-make-context epa-protocol)))
 751     (epg-context-set-armor context epa-armor)
 752     (epg-context-set-textmode context epa-textmode)
 753     (epg-context-set-passphrase-callback context
 754                                          #'epa-passphrase-callback-function)
 755     (epg-context-set-progress-callback context
 756                                        (cons
 757                                         #'epa-progress-callback-function
 758                                         (format "Encrypting %s..."
 759                                                 (file-name-nondirectory file))))
 760     (message "Encrypting %s..." (file-name-nondirectory file))
 761     (epg-encrypt-file context file recipients cipher)
 762     (message "Encrypting %s...wrote %s" (file-name-nondirectory file)
 763              (file-name-nondirectory cipher))))
 764
 765 ;;;###autoload
 766 (defun epa-decrypt-region (start end &optional make-buffer-function)
 767   "Decrypt the current region between START and END.
 768
 769 If MAKE-BUFFER-FUNCTION is non-nil, call it to prepare an output buffer.
 770 It should return that buffer.  If it copies the input, it should
 771 delete the text now being decrypted.  It should leave point at the
 772 proper place to insert the plaintext.
 773
 774 Be careful about using this command in Lisp programs!
 775 Since this function operates on regions, it does some tricks such
 776 as coding-system detection and unibyte/multibyte conversion.  If
 777 you are sure how the data in the region should be treated, you
 778 should consider using the string based counterpart
 779 `epg-decrypt-string', or the file based counterpart
 780 `epg-decrypt-file' instead.
 781
 782 For example:
 783
 784 \(let ((context (epg-make-context 'OpenPGP)))
 785   (decode-coding-string
 786     (epg-decrypt-string context (buffer-substring start end))
 787     'utf-8))"
 788   (interactive "r")
 789   (save-excursion
 790     (let ((context (epg-make-context epa-protocol))
 791           plain)
 792       (epg-context-set-passphrase-callback context
 793                                            #'epa-passphrase-callback-function)
 794       (epg-context-set-progress-callback context
 795                                          (cons
 796                                           #'epa-progress-callback-function
 797                                           "Decrypting..."))
 798       (message "Decrypting...")
 799       (setq plain (epg-decrypt-string context (buffer-substring start end)))
 800       (message "Decrypting...done")
 801       (setq plain (epa--decode-coding-string
 802                    plain
 803                    (or coding-system-for-read
 804                        (get-text-property start 'epa-coding-system-used)
 805                        'undecided)))
 806       (if make-buffer-function
 807           (with-current-buffer (funcall make-buffer-function)
 808             (let ((inhibit-read-only t))
 809               (insert plain)))
 810         (if (y-or-n-p "Replace the original text? ")
 811             (let ((inhibit-read-only t))
 812               (delete-region start end)
 813               (goto-char start)
 814               (insert plain))
 815           (with-output-to-temp-buffer "*Temp*"
 816             (set-buffer standard-output)
 817               (insert plain)
 818               (epa-info-mode))))
 819       (if (epg-context-result-for context 'verify)
 820           (epa-display-info (epg-verify-result-to-string
 821                              (epg-context-result-for context 'verify)))))))
 822
 823 (defun epa--find-coding-system-for-mime-charset (mime-charset)
 824   (if (featurep 'xemacs)
 825       (if (fboundp 'find-coding-system)
 826           (find-coding-system mime-charset))
 827     ;; Find the first coding system which corresponds to MIME-CHARSET.
 828     (let ((pointer (coding-system-list)))
 829       (while (and pointer
 830                   (not (eq (coding-system-get (car pointer) 'mime-charset)
 831                            mime-charset)))
 832         (setq pointer (cdr pointer)))
 833       (car pointer))))
 834
 835 ;;;###autoload
 836 (defun epa-decrypt-armor-in-region (start end)
 837   "Decrypt OpenPGP armors in the current region between START and END.
 838
 839 Don't use this command in Lisp programs!
 840 See the reason described in the `epa-decrypt-region' documentation."
 841   (interactive "r")
 842   (save-excursion
 843     (save-restriction
 844       (narrow-to-region start end)
 845       (goto-char start)
 846       (let (armor-start armor-end)
 847         (while (re-search-forward "-----BEGIN PGP MESSAGE-----$" nil t)
 848           (setq armor-start (match-beginning 0)
 849                 armor-end (re-search-forward "^-----END PGP MESSAGE-----$"
 850                                              nil t))
 851           (unless armor-end
 852             (error "Encryption armor beginning has no matching end"))
 853           (goto-char armor-start)
 854           (let ((coding-system-for-read
 855                  (or coding-system-for-read
 856                      (if (re-search-forward "^Charset: \\(.*\\)" armor-end t)
 857                          (epa--find-coding-system-for-mime-charset
 858                           (intern (downcase (match-string 1))))))))
 859             (goto-char armor-end)
 860             (epa-decrypt-region armor-start armor-end)))))))
 861
 862 ;;;###autoload
 863 (defun epa-verify-region (start end)
 864   "Verify the current region between START and END.
 865
 866 Don't use this command in Lisp programs!
 867 Since this function operates on regions, it does some tricks such
 868 as coding-system detection and unibyte/multibyte conversion.  If
 869 you are sure how the data in the region should be treated, you
 870 should consider using the string based counterpart
 871 `epg-verify-string', or the file based counterpart
 872 `epg-verify-file' instead.
 873
 874 For example:
 875
 876 \(let ((context (epg-make-context 'OpenPGP)))
 877   (decode-coding-string
 878     (epg-verify-string context (buffer-substring start end))
 879     'utf-8))"
 880   (interactive "r")
 881   (let ((context (epg-make-context epa-protocol))
 882         plain)
 883     (epg-context-set-progress-callback context
 884                                        (cons
 885                                         #'epa-progress-callback-function
 886                                         "Verifying..."))
 887     (message "Verifying...")
 888     (setq plain (epg-verify-string
 889                  context
 890                  (epa--encode-coding-string
 891                   (buffer-substring start end)
 892                   (or coding-system-for-write
 893                       (get-text-property start 'epa-coding-system-used)))))
 894     (message "Verifying...done")
 895     (setq plain (epa--decode-coding-string
 896                  plain
 897                  (or coding-system-for-read
 898                      (get-text-property start 'epa-coding-system-used)
 899                      'undecided)))
 900     (if (y-or-n-p "Replace the original text? ")
 901         (let ((inhibit-read-only t)
 902               buffer-read-only)
 903           (delete-region start end)
 904           (goto-char start)
 905           (insert plain))
 906       (with-output-to-temp-buffer "*Temp*"
 907         (set-buffer standard-output)
 908         (insert plain)
 909         (epa-info-mode)))
 910     (if (epg-context-result-for context 'verify)
 911         (epa-display-info (epg-verify-result-to-string
 912                            (epg-context-result-for context 'verify))))))
 913
 914 ;;;###autoload
 915 (defun epa-verify-cleartext-in-region (start end)
 916   "Verify OpenPGP cleartext signed messages in the current region
 917 between START and END.
 918
 919 Don't use this command in Lisp programs!
 920 See the reason described in the `epa-verify-region' documentation."
 921   (interactive "r")
 922   (save-excursion
 923     (save-restriction
 924       (narrow-to-region start end)
 925       (goto-char start)
 926       (let (cleartext-start cleartext-end)
 927         (while (re-search-forward "-----BEGIN PGP SIGNED MESSAGE-----$"
 928                                   nil t)
 929           (setq cleartext-start (match-beginning 0))
 930           (unless (re-search-forward "^-----BEGIN PGP SIGNATURE-----$"
 931                                            nil t)
 932             (error "Invalid cleartext signed message"))
 933           (setq cleartext-end (re-search-forward
 934                            "^-----END PGP SIGNATURE-----$"
 935                            nil t))
 936           (unless cleartext-end
 937             (error "No cleartext tail"))
 938           (epa-verify-region cleartext-start cleartext-end))))))
 939
 940 (eval-and-compile
 941   (if (fboundp 'select-safe-coding-system)
 942       (defalias 'epa--select-safe-coding-system 'select-safe-coding-system)
 943     (defun epa--select-safe-coding-system (_from _to)
 944       buffer-file-coding-system)))
 945
 946 ;;;###autoload
 947 (defun epa-sign-region (start end signers mode)
 948   "Sign the current region between START and END by SIGNERS keys selected.
 949
 950 Don't use this command in Lisp programs!
 951 Since this function operates on regions, it does some tricks such
 952 as coding-system detection and unibyte/multibyte conversion.  If
 953 you are sure how the data should be treated, you should consider
 954 using the string based counterpart `epg-sign-string', or the file
 955 based counterpart `epg-sign-file' instead.
 956
 957 For example:
 958
 959 \(let ((context (epg-make-context 'OpenPGP)))
 960   (epg-sign-string
 961     context
 962     (encode-coding-string (buffer-substring start end) 'utf-8)))"
 963   (interactive
 964    (let ((verbose current-prefix-arg))
 965      (setq epa-last-coding-system-specified
 966            (or coding-system-for-write
 967                (epa--select-safe-coding-system
 968                 (region-beginning) (region-end))))
 969      (list (region-beginning) (region-end)
 970            (if verbose
 971                (epa-select-keys (epg-make-context epa-protocol)
 972                                 "Select keys for signing.
 973 If no one is selected, default secret key is used.  "
 974                                 nil t))
 975            (if verbose
 976                (epa--read-signature-type)
 977              'clear))))
 978   (save-excursion
 979     (let ((context (epg-make-context epa-protocol))
 980           signature)
 981       ;;(epg-context-set-armor context epa-armor)
 982       (epg-context-set-armor context t)
 983       ;;(epg-context-set-textmode context epa-textmode)
 984       (epg-context-set-textmode context t)
 985       (epg-context-set-signers context signers)
 986       (epg-context-set-passphrase-callback context
 987                                            #'epa-passphrase-callback-function)
 988       (epg-context-set-progress-callback context
 989                                          (cons
 990                                           #'epa-progress-callback-function
 991                                           "Signing..."))
 992       (message "Signing...")
 993       (setq signature (epg-sign-string context
 994                                        (epa--encode-coding-string
 995                                         (buffer-substring start end)
 996                                         epa-last-coding-system-specified)
 997                                        mode))
 998       (message "Signing...done")
 999       (delete-region start end)
1000       (goto-char start)
1001       (add-text-properties (point)
1002                            (progn
1003                              (insert (epa--decode-coding-string
1004                                       signature
1005                                       (or coding-system-for-read
1006                                           epa-last-coding-system-specified)))
1007                              (point))
1008                            (list 'epa-coding-system-used
1009                                  epa-last-coding-system-specified
1010                                  'front-sticky nil
1011                                  'rear-nonsticky t
1012                                  'start-open t
1013                                  'end-open t)))))
1014
1015 (eval-and-compile
1016   (if (fboundp 'derived-mode-p)
1017       (defalias 'epa--derived-mode-p 'derived-mode-p)
1018     (defun epa--derived-mode-p (&rest modes)
1019       "Non-nil if the current major mode is derived from one of MODES.
1020 Uses the `derived-mode-parent' property of the symbol to trace backwards."
1021       (let ((parent major-mode))
1022         (while (and (not (memq parent modes))
1023                     (setq parent (get parent 'derived-mode-parent))))
1024         parent))))
1025
1026 ;;;###autoload
1027 (defun epa-encrypt-region (start end recipients sign signers)
1028   "Encrypt the current region between START and END for RECIPIENTS.
1029
1030 Don't use this command in Lisp programs!
1031 Since this function operates on regions, it does some tricks such
1032 as coding-system detection and unibyte/multibyte conversion.  If
1033 you are sure how the data should be treated, you should consider
1034 using the string based counterpart `epg-encrypt-string', or the
1035 file based counterpart `epg-encrypt-file' instead.
1036
1037 For example:
1038
1039 \(let ((context (epg-make-context 'OpenPGP)))
1040   (epg-encrypt-string
1041     context
1042     (encode-coding-string (buffer-substring start end) 'utf-8)
1043     nil))"
1044   (interactive
1045    (let ((verbose current-prefix-arg)
1046          (context (epg-make-context epa-protocol))
1047          sign)
1048      (setq epa-last-coding-system-specified
1049            (or coding-system-for-write
1050                (epa--select-safe-coding-system
1051                 (region-beginning) (region-end))))
1052      (list (region-beginning) (region-end)
1053            (epa-select-keys context
1054                             "Select recipients for encryption.
1055 If no one is selected, symmetric encryption will be performed.  ")
1056            (setq sign (if verbose (y-or-n-p "Sign? ")))
1057            (if sign
1058                (epa-select-keys context
1059                                 "Select keys for signing.  ")))))
1060   (save-excursion
1061     (let ((context (epg-make-context epa-protocol))
1062           cipher)
1063       ;;(epg-context-set-armor context epa-armor)
1064       (epg-context-set-armor context t)
1065       ;;(epg-context-set-textmode context epa-textmode)
1066       (epg-context-set-textmode context t)
1067       (if sign
1068           (epg-context-set-signers context signers))
1069       (epg-context-set-passphrase-callback context
1070                                            #'epa-passphrase-callback-function)
1071       (epg-context-set-progress-callback context
1072                                          (cons
1073                                           #'epa-progress-callback-function
1074                                           "Encrypting..."))
1075       (message "Encrypting...")
1076       (setq cipher (epg-encrypt-string context
1077                                        (epa--encode-coding-string
1078                                         (buffer-substring start end)
1079                                         epa-last-coding-system-specified)
1080                                        recipients
1081                                        sign))
1082       (message "Encrypting...done")
1083       (delete-region start end)
1084       (goto-char start)
1085       (add-text-properties (point)
1086                            (progn
1087                              (insert cipher)
1088                              (point))
1089                            (list 'epa-coding-system-used
1090                                  epa-last-coding-system-specified
1091                                  'front-sticky nil
1092                                  'rear-nonsticky t
1093                                  'start-open t
1094                                  'end-open t)))))
1095
1096 ;;;###autoload
1097 (defun epa-delete-keys (keys &optional allow-secret)
1098   "Delete selected KEYS."
1099   (interactive
1100    (let ((keys (epa--marked-keys)))
1101      (unless keys
1102        (error "No keys selected"))
1103      (list keys
1104            (eq (nth 1 epa-list-keys-arguments) t))))
1105   (let ((context (epg-make-context epa-protocol)))
1106     (message "Deleting...")
1107     (epg-delete-keys context keys allow-secret)
1108     (message "Deleting...done")
1109     (apply #'epa--list-keys epa-list-keys-arguments)))
1110
1111 ;;;###autoload
1112 (defun epa-import-keys (file)
1113   "Import keys from FILE."
1114   (interactive "fFile: ")
1115   (setq file (expand-file-name file))
1116   (let ((context (epg-make-context epa-protocol)))
1117     (message "Importing %s..." (file-name-nondirectory file))
1118     (condition-case nil
1119         (progn
1120           (epg-import-keys-from-file context file)
1121           (message "Importing %s...done" (file-name-nondirectory file)))
1122       (error
1123        (message "Importing %s...failed" (file-name-nondirectory file))))
1124     (if (epg-context-result-for context 'import)
1125         (epa-display-info (epg-import-result-to-string
1126                            (epg-context-result-for context 'import))))
1127     (if (eq major-mode 'epa-key-list-mode)
1128         (apply #'epa--list-keys epa-list-keys-arguments))))
1129
1130 ;;;###autoload
1131 (defun epa-import-keys-region (start end)
1132   "Import keys from the region."
1133   (interactive "r")
1134   (let ((context (epg-make-context epa-protocol)))
1135     (message "Importing...")
1136     (condition-case nil
1137         (progn
1138           (epg-import-keys-from-string context (buffer-substring start end))
1139           (message "Importing...done"))
1140       (error
1141        (message "Importing...failed")))
1142     (if (epg-context-result-for context 'import)
1143         (epa-display-info (epg-import-result-to-string
1144                            (epg-context-result-for context 'import))))))
1145
1146 ;;;###autoload
1147 (defun epa-import-armor-in-region (start end)
1148   "Import keys in the OpenPGP armor format in the current region
1149 between START and END."
1150   (interactive "r")
1151   (save-excursion
1152     (save-restriction
1153       (narrow-to-region start end)
1154       (goto-char start)
1155       (let (armor-start armor-end)
1156         (while (re-search-forward
1157                 "-----BEGIN \\(PGP \\(PUBLIC\\|PRIVATE\\) KEY BLOCK\\)-----$"
1158                 nil t)
1159           (setq armor-start (match-beginning 0)
1160                 armor-end (re-search-forward
1161                            (concat "^-----END " (match-string 1) "-----$")
1162                            nil t))
1163           (unless armor-end
1164             (error "No armor tail"))
1165           (epa-import-keys-region armor-start armor-end))))))
1166
1167 ;;;###autoload
1168 (defun epa-export-keys (keys file)
1169   "Export selected KEYS to FILE."
1170   (interactive
1171    (let ((keys (epa--marked-keys))
1172          default-name)
1173      (unless keys
1174        (error "No keys selected"))
1175      (setq default-name
1176            (expand-file-name
1177             (concat (epg-sub-key-id (car (epg-key-sub-key-list (car keys))))
1178                     (if epa-armor ".asc" ".gpg"))
1179             default-directory))
1180      (list keys
1181            (expand-file-name
1182             (read-file-name
1183              (concat "To file (default "
1184                      (file-name-nondirectory default-name)
1185                      ") ")
1186              (file-name-directory default-name)
1187              default-name)))))
1188   (let ((context (epg-make-context epa-protocol)))
1189     (epg-context-set-armor context epa-armor)
1190     (message "Exporting to %s..." (file-name-nondirectory file))
1191     (epg-export-keys-to-file context keys file)
1192     (message "Exporting to %s...done" (file-name-nondirectory file))))
1193
1194 ;;;###autoload
1195 (defun epa-insert-keys (keys)
1196   "Insert selected KEYS after the point."
1197   (interactive
1198    (list (epa-select-keys (epg-make-context epa-protocol)
1199                                 "Select keys to export.
1200 If no one is selected, default public key is exported.  ")))
1201   (let ((context (epg-make-context epa-protocol)))
1202     ;;(epg-context-set-armor context epa-armor)
1203     (epg-context-set-armor context t)
1204     (insert (epg-export-keys-to-string context keys))))
1205
1206 ;; (defun epa-sign-keys (keys &optional local)
1207 ;;   "Sign selected KEYS.
1208 ;; If a prefix-arg is specified, the signature is marked as non exportable.
1209
1210 ;; Don't use this command in Lisp programs!"
1211 ;;   (interactive
1212 ;;    (let ((keys (epa--marked-keys)))
1213 ;;      (unless keys
1214 ;;        (error "No keys selected"))
1215 ;;      (list keys current-prefix-arg)))
1216 ;;   (let ((context (epg-make-context epa-protocol)))
1217 ;;     (epg-context-set-passphrase-callback context
1218 ;;                                       #'epa-passphrase-callback-function)
1219 ;;     (epg-context-set-progress-callback context
1220 ;;                                     (cons
1221 ;;                                      #'epa-progress-callback-function
1222 ;;                                      "Signing keys..."))
1223 ;;     (message "Signing keys...")
1224 ;;     (epg-sign-keys context keys local)
1225 ;;     (message "Signing keys...done")))
1226 ;; (make-obsolete 'epa-sign-keys "Do not use.")
1227
1228 (provide 'epa)
1229
1230 ;;; epa.el ends here