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