epg.el

   1 (defgroup epg ()
   2   "EasyPG, yet another GnuPG interface.")
   3
   4 (defcustom epg-gpg-program "gpg"
   5   "The `gpg' executable."
   6   :group 'epg
   7   :type 'string)
   8
   9 (defvar epg-user-id nil
  10   "GnuPG ID of your default identity.")
  11
  12 (defvar epg-user-id-alist nil
  13   "An alist mapping from key ID to user ID.")
  14
  15 (defvar epg-read-point nil)
  16 (defvar epg-pending-status-list nil)
  17 (defvar epg-key-id nil)
  18 (defvar epg-context nil)
  19 (defvar epg-debug nil)
  20
  21 (defvar epg-colons-pub-spec
  22   '((trust "[^:]")
  23     (length "[0-9]+" 0 string-to-number)
  24     (algorithm "[0-9]+" 0 string-to-number)
  25     (key-id "[^:]+")
  26     (creation-date "[0-9]+")
  27     (expiration-date "[0-9]+")
  28     nil
  29     (ownertrust "[^:]")
  30     nil
  31     nil
  32     (capability "[escaESCA]*"))
  33   "The schema of keylisting output whose type is \"pub\".
  34 This is used by `epg-list-keys'.")
  35
  36 (defvar epg-colons-sec-spec
  37   '((trust "[^:]")
  38     (length "[0-9]+" 0 string-to-number)
  39     (algorithm "[0-9]+" 0 string-to-number)
  40     (key-id "[^:]+")
  41     (creation-date "[0-9]+")
  42     (expiration-date "[0-9]+")
  43     nil
  44     (ownertrust "[^:]"))
  45 "The schema of keylisting output whose type is \"sec\".
  46 This is used by `epg-list-keys'.")
  47
  48 (defvar epg-colons-uid-spec
  49   '((trust "[^:]")
  50     nil
  51     nil
  52     nil
  53     (creation-date "[0-9]+")
  54     (expiration-date "[0-9]+")
  55     (hash "[^:]+")
  56     nil
  57     (user-id "[^:]+"))
  58   "The schema of keylisting output whose type is \"uid\".
  59 This is used by `epg-list-keys'.")
  60
  61 (defun epg-make-context (&optional protocol armor textmode include-certs)
  62   "Return a context object."
  63   (vector protocol armor textmode include-certs
  64           (cons #'epg-passphrase-callback-function nil)
  65           (cons #'epg-progress-callback-function nil)
  66           nil nil nil nil))
  67
  68 (defun epg-context-protocol (context)
  69   "Return the protocol used within the context."
  70   (aref context 0))
  71
  72 (defun epg-context-armor (context)
  73   "Return t if the output shouled be ASCII armored in the CONTEXT context."
  74   (aref context 1))
  75
  76 (defun epg-context-textmode (context)
  77   "Return t if canonical text mode should be used in the CONTEXT context."
  78   (aref context 2))
  79
  80 (defun epg-context-include-certs (context)
  81   "Return how many certificates should be included in an S/MIME signed
  82 message."
  83   (aref context 3))
  84
  85 (defun epg-context-passphrase-callback-info (context)
  86   "Return the function used to query passphrase."
  87   (aref context 4))
  88
  89 (defun epg-context-progress-callback-info (context)
  90   "Return the function which handles progress update."
  91   (aref context 5))
  92
  93 (defun epg-context-signers (context)
  94   "Return the list of key-id for singning."
  95   (aref context 6))
  96
  97 (defun epg-context-process (context)
  98   "Return the process object of `epg-gpg-program'.
  99 This function is for internal use only."
 100   (aref context 7))
 101
 102 (defun epg-context-output-file (context)
 103   "Return the output file of `epg-gpg-program'.
 104 This function is for internal use only."
 105   (aref context 8))
 106
 107 (defun epg-context-result (context)
 108   "Return the result of the previous cryptographic operation."
 109   (aref context 9))
 110
 111 (defun epg-context-set-protocol (context protocol)
 112   "Set the protocol used within the context."
 113   (aset context 0 protocol))
 114
 115 (defun epg-context-set-armor (context armor)
 116   "Specify if the output shouled be ASCII armored in the CONTEXT context."
 117   (aset context 1 armor))
 118
 119 (defun epg-context-set-textmode (context textmode)
 120   "Specify if canonical text mode should be used in the CONTEXT context."
 121   (aset context 2 textmode))
 122
 123 (defun epg-context-set-include-certs (context include-certs)
 124  "Set how many certificates should be included in an S/MIME signed message."
 125   (aset context 3 include-certs))
 126
 127 (defun epg-context-set-passphrase-callback-info (context
 128                                                  passphrase-callback-info)
 129   "Set the function used to query passphrase."
 130   (aset context 4 passphrase-callback-info))
 131
 132 (defun epg-context-set-progress-callback-info (context progress-callback-info)
 133   "Set the function which handles progress update."
 134   (aset context 5 progress-callback-info))
 135
 136 (defun epg-context-set-signers (context signers)
 137  "Set the list of key-id for singning."
 138   (aset context 6 signers))
 139
 140 (defun epg-context-set-process (context process)
 141   "Set the process object of `epg-gpg-program'.
 142 This function is for internal use only."
 143   (aset context 7 process))
 144
 145 (defun epg-context-set-output-file (context output-file)
 146   "Set the output file of `epg-gpg-program'.
 147 This function is for internal use only."
 148   (aset context 8 output-file))
 149
 150 (defun epg-context-set-result (context result)
 151   "Set the result of the previous cryptographic operation."
 152   (aset context 9 result))
 153
 154 (defun epg-make-signature (status key-id user-id)
 155   "Return a signature object."
 156   (vector status key-id user-id nil))
 157
 158 (defun epg-signature-status (signature)
 159   "Return the status code of SIGNATURE."
 160   (aref signature 0))
 161
 162 (defun epg-signature-key-id (signature)
 163   "Return the key-id of SIGNATURE."
 164   (aref signature 1))
 165
 166 (defun epg-signature-user-id (signature)
 167   "Return the user-id of SIGNATURE."
 168   (aref signature 2))
 169
 170 (defun epg-signature-validity (signature)
 171   "Return the validity of SIGNATURE."
 172   (aref signature 3))
 173
 174 (defun epg-signature-set-status (signature status)
 175  "Set the status code of SIGNATURE."
 176   (aset signature 0 status))
 177
 178 (defun epg-signature-set-key-id (signature key-id)
 179  "Set the key-id of SIGNATURE."
 180   (aset signature 1 key-id))
 181
 182 (defun epg-signature-set-user-id (signature user-id)
 183  "Set the user-id of SIGNATURE."
 184   (aset signature 2 user-id))
 185
 186 (defun epg-signature-set-validity (signature validity)
 187  "Set the validity of SIGNATURE."
 188   (aset signature 3 validity))
 189
 190 (defun epg-context-result-for (context name)
 191   (cdr (assq name (epg-context-result context))))
 192
 193 (defun epg-context-set-result-for (context name value)
 194   (let* ((result (epg-context-result context))
 195          (entry (assq name result)))
 196     (if entry
 197         (setcdr entry value)
 198       (epg-context-set-result context (cons (cons name value) result)))))
 199
 200 (defun epg-start (context args)
 201   "Start `epg-gpg-program' in a subprocess with given ARGS."
 202   (let* ((args (append (list "--no-tty"
 203                              "--status-fd" "1"
 204                              "--command-fd" "0"
 205                              "--yes") ; overwrite
 206                        (if (epg-context-armor context) '("--armor"))
 207                        (if (epg-context-textmode context) '("--textmode"))
 208                        (if (epg-context-output-file context)
 209                            (list "--output" (epg-context-output-file context)))
 210                        args))
 211          (coding-system-for-write 'binary)
 212          process-connection-type
 213          (orig-mode (default-file-modes))
 214          (buffer (generate-new-buffer " *epg*"))
 215          process)
 216     (with-current-buffer buffer
 217       (make-local-variable 'epg-read-point)
 218       (setq epg-read-point (point-min))
 219       (make-local-variable 'epg-pending-status-list)
 220       (setq epg-pending-status-list nil)
 221       (make-local-variable 'epg-key-id)
 222       (setq epg-key-id nil)
 223       (make-local-variable 'epg-context)
 224       (setq epg-context context))
 225     (unwind-protect
 226         (progn
 227           (set-default-file-modes 448)
 228           (setq process
 229                 (apply #'start-process "epg" buffer epg-gpg-program args)))
 230       (set-default-file-modes orig-mode))
 231     (set-process-filter process #'epg-process-filter)
 232     (epg-context-set-process context process)))
 233
 234 (defun epg-process-filter (process input)
 235   (if epg-debug
 236       (save-excursion
 237         (set-buffer (get-buffer-create  " *epg-debug*"))
 238         (goto-char (point-max))
 239         (insert input)))
 240   (if (buffer-live-p (process-buffer process))
 241       (save-excursion
 242         (set-buffer (process-buffer process))
 243         (goto-char (point-max))
 244         (insert input)
 245         (goto-char epg-read-point)
 246         (beginning-of-line)
 247         (while (looking-at ".*\n")      ;the input line is finished
 248           (save-excursion
 249             (if (looking-at "\\[GNUPG:] \\([A-Z_]+\\) ?\\(.*\\)")
 250                 (let* ((status (match-string 1))
 251                        (string (match-string 2))
 252                        (symbol (intern-soft (concat "epg-status-" status))))
 253                   (if (member status epg-pending-status-list)
 254                       (setq epg-pending-status-list nil))
 255                   (if (and symbol
 256                            (fboundp symbol))
 257                       (funcall symbol process string)))))
 258           (forward-line))
 259         (setq epg-read-point (point)))))
 260
 261 (defun epg-read-output (context)
 262   (with-temp-buffer
 263     (if (fboundp 'set-buffer-multibyte)
 264         (set-buffer-multibyte nil))
 265     (if (file-exists-p (epg-context-output-file context))
 266         (let ((coding-system-for-read (if (epg-context-textmode context)
 267                                           'raw-text
 268                                         'binary)))
 269           (insert-file-contents (epg-context-output-file context))
 270           (buffer-string)))))
 271
 272 (defun epg-wait-for-status (context status-list)
 273   (with-current-buffer (process-buffer (epg-context-process context))
 274     (setq epg-pending-status-list status-list)
 275     (while (and (eq (process-status (epg-context-process context)) 'run)
 276                 epg-pending-status-list)
 277       (accept-process-output (epg-context-process context) 1))))
 278
 279 (defun epg-wait-for-completion (context)
 280   (if (eq (process-status (epg-context-process context)) 'run)
 281       (process-send-eof (epg-context-process context)))
 282   (while (eq (process-status (epg-context-process context)) 'run)
 283     ;; We can't use accept-process-output instead of sit-for here
 284     ;; because it may cause an interrupt during the sentinel execution.
 285     (sit-for 0.1)))
 286
 287 (defun epg-reset (context)
 288   (if (and (epg-context-process context)
 289            (buffer-live-p (process-buffer (epg-context-process context))))
 290       (kill-buffer (process-buffer (epg-context-process context))))
 291   (epg-context-set-process context nil)
 292   (if (file-exists-p (epg-context-output-file context))
 293       (delete-file (epg-context-output-file context)))
 294   (aset context 9 nil))
 295
 296 (defun epg-status-USERID_HINT (process string)
 297   (if (string-match "\\`\\([^ ]+\\) \\(.*\\)" string)
 298       (let* ((key-id (match-string 1 string))
 299              (user-id (match-string 2 string))
 300              (entry (assoc key-id epg-user-id-alist)))
 301         (if entry
 302             (setcdr entry user-id)
 303           (setq epg-user-id-alist (cons (cons key-id user-id)
 304                                         epg-user-id-alist))))))
 305
 306 (defun epg-status-NEED_PASSPHRASE (process string)
 307   (if (string-match "\\`\\([^ ]+\\)" string)
 308       (setq epg-key-id (match-string 1 string))))
 309
 310 (defun epg-status-NEED_PASSPHRASE_SYM (process string)
 311   (setq epg-key-id 'SYM))
 312
 313 (defun epg-status-NEED_PASSPHRASE_PIN (process string)
 314   (setq epg-key-id 'PIN))
 315
 316 (defun epg-status-GET_HIDDEN (process string)
 317   (let ((passphrase
 318          (funcall (car (epg-context-passphrase-callback-info epg-context))
 319                   epg-key-id
 320                   (cdr (epg-context-passphrase-callback-info epg-context))))
 321         string)
 322     (if passphrase
 323         (unwind-protect
 324             (progn
 325               (setq string (concat passphrase "\n"))
 326               (fillarray passphrase 0)
 327               (setq passphrase nil)
 328               (process-send-string process string))
 329           (if string
 330               (fillarray string 0))))))
 331
 332 (defun epg-status-GOODSIG (process string)
 333   (if (string-match "\\`\\([^ ]+\\) \\(.*\\)" string)
 334       (epg-context-set-result-for
 335        epg-context
 336        'verify
 337        (cons (epg-make-signature 'good
 338                                  (match-string 1 string)
 339                                  (match-string 2 string))
 340              (epg-context-result-for epg-context 'verify)))))
 341
 342 (defun epg-status-EXPSIG (process string)
 343   (if (string-match "\\`\\([^ ]+\\) \\(.*\\)" string)
 344       (epg-context-set-result-for
 345        epg-context
 346        'verify
 347        (cons (epg-make-signature 'expired
 348                                  (match-string 1 string)
 349                                  (match-string 2 string))
 350              (epg-context-result-for epg-context 'verify)))))
 351
 352 (defun epg-status-EXPKEYSIG (process string)
 353   (if (string-match "\\`\\([^ ]+\\) \\(.*\\)" string)
 354       (epg-context-set-result-for
 355        epg-context
 356        'verify
 357        (cons (epg-make-signature 'expired-key
 358                                  (match-string 1 string)
 359                                  (match-string 2 string))
 360              (epg-context-result-for epg-context 'verify)))))
 361
 362 (defun epg-status-REVKEYSIG (process string)
 363   (if (string-match "\\`\\([^ ]+\\) \\(.*\\)" string)
 364       (epg-context-set-result-for
 365        epg-context
 366        'verify
 367        (cons (epg-make-signature 'revoked-key
 368                                  (match-string 1 string)
 369                                  (match-string 2 string))
 370              (epg-context-result-for epg-context 'verify)))))
 371
 372 (defun epg-status-BADSIG (process string)
 373   (if (string-match "\\`\\([^ ]+\\) \\(.*\\)" string)
 374       (epg-context-set-result-for
 375        epg-context
 376        'verify
 377        (cons (epg-make-signature 'bad
 378                                  (match-string 1 string)
 379                                  (match-string 2 string))
 380              (epg-context-result-for epg-context 'verify)))))
 381
 382 (defun epg-status-TRUST_UNDEFINED (process string)
 383   (let ((signature (car (epg-context-result-for epg-context 'verify))))
 384     (if (and signature
 385              (eq (epg-signature-status signature) 'good))
 386         (epg-signature-set-validity signature 'unknown))))
 387
 388 (defun epg-status-TRUST_NEVER (process string)
 389   (let ((signature (car (epg-context-result-for epg-context 'verify))))
 390     (if (and signature
 391              (eq (epg-signature-status signature) 'good))
 392         (epg-signature-set-validity signature 'never))))
 393
 394 (defun epg-status-TRUST_MARGINAL (process string)
 395   (let ((signature (car (epg-context-result-for epg-context 'verify))))
 396     (if (and signature
 397              (eq (epg-signature-status signature) 'marginal))
 398         (epg-signature-set-validity signature 'marginal))))
 399
 400 (defun epg-status-TRUST_FULLY (process string)
 401   (let ((signature (car (epg-context-result-for epg-context 'verify))))
 402     (if (and signature
 403              (eq (epg-signature-status signature) 'good))
 404         (epg-signature-set-validity signature 'full))))
 405
 406 (defun epg-status-TRUST_ULTIMATE (process string)
 407   (let ((signature (car (epg-context-result-for epg-context 'verify))))
 408     (if (and signature
 409              (eq (epg-signature-status signature) 'good))
 410         (epg-signature-set-validity signature 'full))))
 411
 412 (defun epg-status-PROGRESS (process string)
 413   (if (string-match "\\`\\([^ ]+\\) \\([^ ]\\) \\([0-9]+\\) \\([0-9]+\\)"
 414                     string)
 415       (funcall (car (epg-context-progress-callback-info epg-context))
 416                (match-string 1 string)
 417                (match-string 2 string)
 418                (string-to-number (match-string 3 string))
 419                (string-to-number (match-string 4 string))
 420                (cdr (epg-context-progress-callback-info epg-context)))))
 421
 422 (defun epg-status-DECRYPTION_FAILED (process string)
 423   (epg-context-set-result-for
 424    epg-context 'error
 425    (cons 'decryption-failed
 426          (epg-context-result-for epg-context 'error))))
 427
 428 (defun epg-status-NODATA (process string)
 429   (epg-context-set-result-for
 430    epg-context 'error
 431    (cons (cons 'no-data (string-to-number string))
 432          (epg-context-result-for epg-context 'error))))
 433
 434 (defun epg-status-UNEXPECTED (process string)
 435   (epg-context-set-result-for
 436    epg-context 'error
 437    (cons (cons 'unexpected (string-to-number string))
 438          (epg-context-result-for epg-context 'error))))
 439
 440 (defun epg-status-KEYEXPIRED (process string)
 441   (epg-context-set-result-for
 442    epg-context 'error
 443    (cons (cons 'key-expired string)
 444          (epg-context-result-for epg-context 'error))))
 445
 446 (defun epg-status-KEYREVOKED (process string)
 447   (epg-context-set-result-for
 448    epg-context 'error
 449    (cons 'key-revoked
 450          (epg-context-result-for epg-context 'error))))
 451
 452 (defun epg-status-BADARMOR (process string)
 453   (epg-context-set-result-for
 454    epg-context 'error
 455    (cons 'bad-armor
 456          (epg-context-result-for epg-context 'error))))
 457
 458 (defun epg-passphrase-callback-function (key-id handback)
 459   (read-passwd
 460    (if (eq key-id 'SYM)
 461        "Passphrase for symmetric encryption: "
 462      (if (eq key-id 'PIN)
 463          "Passphrase for PIN: "
 464        (let ((entry (assoc key-id epg-user-id-alist)))
 465          (if entry
 466              (format "Passphrase for %s %s: " key-id (cdr entry))
 467            (format "Passphrase for %s: " key-id)))))))
 468
 469 (defun epg-progress-callback-function (what char current total handback)
 470   (message "%s: %d%%/%d%%" what current total))
 471
 472 (defun epg-list-keys (name &optional secret)
 473   "List keys associated with STRING."
 474   (let ((args (list "--with-colons" "--no-greeting" "--batch"
 475                     "--fixed-list-mode"
 476                     (if secret "--list-secret-keys" "--list-keys")
 477                     name))
 478         keys type symbol pointer)
 479     (with-temp-buffer
 480       (apply #'call-process epg-gpg-program nil (list t nil) nil args)
 481       (goto-char (point-min))
 482       (while (looking-at "\\([a-z][a-z][a-z]\\):\\(.*\\)")
 483         (setq type (match-string 1)
 484               symbol (intern-soft (format "epg-colons-%s-spec" type)))
 485         (if (member type '("pub" "sec"))
 486             (setq keys (cons nil keys)))
 487         (if (and symbol
 488                  (boundp symbol))
 489             (setcar keys (cons (cons (intern type)
 490                                      (epg-parse-colons
 491                                       (symbol-value symbol)
 492                                       (match-string 2)))
 493                                (car keys))))
 494         (forward-line)))
 495     (setq pointer keys)
 496     (while pointer
 497       (setcar pointer (nreverse (car pointer)))
 498       (setq pointer (cdr pointer)))
 499     (nreverse keys)))
 500
 501 (defun epg-parse-colons (alist string)
 502   (let ((index 0)
 503         result)
 504     (while (and alist
 505                 (or (null (car alist))
 506                     (eq index
 507                         (string-match
 508                          (concat "\\(" (nth 1 (car alist)) "\\)?:")
 509                          string index))))
 510       (if (car alist)
 511           (progn
 512             (setq index (match-end 0))
 513             (if (match-beginning 1)
 514                 (setq result
 515                       (cons (cons (car (car alist))
 516                                   (funcall (or (nth 3 (car alist)) #'identity)
 517                                            (match-string
 518                                             (1+ (or (nth 2 (car alist)) 0))
 519                                             string)))
 520                             result))))
 521         (setq index (1+ index)))
 522       (setq alist (cdr alist)))
 523     (nreverse result)))
 524
 525 (if (fboundp 'make-temp-file)
 526     (defalias 'epg-make-temp-file 'make-temp-file)
 527   ;; stolen from poe.el.
 528   (defun epg-make-temp-file (prefix)
 529     "Create a temporary file.
 530 The returned file name (created by appending some random characters at the end
 531 of PREFIX, and expanding against `temporary-file-directory' if necessary),
 532 is guaranteed to point to a newly created empty file.
 533 You can then use `write-region' to write new data into the file."
 534     (let (tempdir tempfile)
 535       (unwind-protect
 536           (let (file)
 537             ;; First, create a temporary directory.
 538             (while (condition-case ()
 539                        (progn
 540                          (setq tempdir (make-temp-name
 541                                         (concat
 542                                          (file-name-directory prefix)
 543                                          "DIR")))
 544                          ;; return nil or signal an error.
 545                          (make-directory tempdir))
 546                      ;; let's try again.
 547                      (file-already-exists t)))
 548             (set-file-modes tempdir 448)
 549             ;; Second, create a temporary file in the tempdir.
 550             ;; There *is* a race condition between `make-temp-name'
 551             ;; and `write-region', but we don't care it since we are
 552             ;; in a private directory now.
 553             (setq tempfile (make-temp-name (concat tempdir "/EMU")))
 554             (write-region "" nil tempfile nil 'silent)
 555             (set-file-modes tempfile 384)
 556             ;; Finally, make a hard-link from the tempfile.
 557             (while (condition-case ()
 558                        (progn
 559                          (setq file (make-temp-name prefix))
 560                          ;; return nil or signal an error.
 561                          (add-name-to-file tempfile file))
 562                      ;; let's try again.
 563                      (file-already-exists t)))
 564             file)
 565         ;; Cleanup the tempfile.
 566         (and tempfile
 567              (file-exists-p tempfile)
 568              (delete-file tempfile))
 569         ;; Cleanup the tempdir.
 570         (and tempdir
 571              (file-directory-p tempdir)
 572              (delete-directory tempdir))))))
 573
 574 ;;;###autoload
 575 (defun epg-start-decrypt (context input-file)
 576   "Initiate a decrypt operation on INPUT-FILE.
 577
 578 If you use this function, you will need to wait for the completion of
 579 `epg-gpg-program' by using `epg-wait-for-completion' and call
 580 `epg-reset' to clear a temporaly output file.
 581 If you are unsure, use synchronous version of this function
 582 `epg-decrypt-string' instead."
 583   (epg-context-set-output-file context (epg-make-temp-file "epg-output"))
 584   (epg-start context
 585              (list "--decrypt" input-file))
 586   (epg-wait-for-status context '("BEGIN_DECRYPTION")))
 587
 588 ;;;###autoload
 589 (defun epg-decrypt-file (context input-file)
 590   "Decrypt INPUT-FILE and return the plain text."
 591   (unwind-protect
 592       (progn
 593         (epg-start-decrypt context input-file)
 594         (epg-wait-for-completion context)
 595         (if (epg-context-result-for context 'error)
 596             (error "Decryption failed"))
 597         (epg-read-output context))
 598     (epg-reset context)))
 599
 600 ;;;###autoload
 601 (defun epg-decrypt-string (context string)
 602   "Decrypt STRING and return the plain text."
 603   (let ((input-file (epg-make-temp-file "epg-input"))
 604         (coding-system-for-write 'binary))
 605     (unwind-protect
 606         (progn
 607           (write-region string nil input-file)
 608           (epg-decrypt-file context input-file))
 609       (if (file-exists-p input-file)
 610           (delete-file input-file)))))
 611
 612 ;;;###autoload
 613 (defun epg-start-verify (context signature &optional string)
 614   "Initiate a verify operation on SIGNATURE.
 615
 616 For a detached signature, both SIGNATURE and STRING should be string.
 617 For a normal or a clear text signature, STRING should be nil.
 618
 619 If you use this function, you will need to wait for the completion of
 620 `epg-gpg-program' by using `epg-wait-for-completion' and call
 621 `epg-reset' to clear a temporaly output file.
 622 If you are unsure, use synchronous version of this function
 623 `epg-verify-string' instead."
 624   (epg-context-set-output-file context (epg-make-temp-file "epg-output"))
 625   (if string
 626       ;; Detached signature.
 627       (progn
 628         (epg-start context
 629                    (append (list "--verify")
 630                            (list signature "-")))
 631         (if (eq (process-status (epg-context-process context)) 'run)
 632             (process-send-string (epg-context-process context) string)))
 633     ;; Normal (or cleartext) signature.
 634     (epg-start context (list "--verify"))
 635     (if (eq (process-status (epg-context-process context)) 'run)
 636         (process-send-string (epg-context-process context) signature))))
 637
 638 ;;;###autoload
 639 (defun epg-verify-string (context signature &optional string)
 640   "Verify SIGNATURE.
 641
 642 For a detached signature, both SIGNATURE and STRING should be string.
 643 For a normal or a clear text signature, STRING should be nil."
 644   (let ((input-file (epg-make-temp-file "epg-input"))
 645         (coding-system-for-write 'binary))
 646     (unwind-protect
 647         (progn
 648           (if string
 649               (write-region signature nil input-file))
 650           (epg-verify-file context input-file string))
 651       (if (file-exists-p input-file)
 652           (delete-file input-file)))))
 653
 654 ;;;###autoload
 655 (defun epg-verify-file (context input-file &optional string)
 656   "Verify INPUT-FILE.
 657
 658 For a detached signature, both INPUT-FILE and STRING should be string.
 659 For a normal or a clear text signature, STRING should be nil."
 660   (unwind-protect
 661       (progn
 662         (epg-start-verify context input-file string)
 663         (epg-wait-for-completion context)
 664         (epg-context-result-for context 'verify))
 665     (epg-reset context))))
 666
 667 ;;;###autoload
 668 (defun epg-start-sign (context string &optional mode)
 669   "Initiate a sign operation on STRING.
 670
 671 If optional 3rd argument MODE is 'clearsign, it makes a clear text signature.
 672 If MODE is t or 'detached, it makes a detached signature.
 673 Otherwise, it makes a normal signature.
 674
 675 If you use this function, you will need to wait for the completion of
 676 `epg-gpg-program' by using `epg-wait-for-completion' and call
 677 `epg-reset' to clear a temporaly output file.
 678 If you are unsure, use synchronous version of this function
 679 `epg-sign-string' instead."
 680   (epg-context-set-output-file context (epg-make-temp-file "epg-output"))
 681   (epg-start context
 682              (append (list (if (eq mode 'clearsign)
 683                                "--clearsign"
 684                              (if (or (eq mode t) (eq mode 'detached))
 685                                  "--detach-sign"
 686                                "--sign")))
 687                      (apply #'nconc
 688                             (mapcar (lambda (signer)
 689                                       (list "-u" signer))
 690                                     (epg-context-signers context)))))
 691   (epg-wait-for-status context '("BEGIN_SIGNING"))
 692   (if (eq (process-status (epg-context-process context)) 'run)
 693       (process-send-string (epg-context-process context) string)))
 694
 695 ;;;###autoload
 696 (defun epg-sign-string (context string &optional mode)
 697   "Sign STRING and return the output as string.
 698 If optional 3rd argument MODE is 'clearsign, it makes a clear text signature.
 699 If MODE is t or 'detached, it makes a detached signature.
 700 Otherwise, it makes a normal signature."
 701   (unwind-protect
 702       (progn
 703         (epg-start-sign context string mode)
 704         (epg-wait-for-completion context)
 705         (if (epg-context-result-for context 'error)
 706             (error "Sign failed"))
 707         (epg-read-output context))
 708     (epg-reset context)))
 709
 710 ;;;###autoload
 711 (defun epg-start-encrypt (context string recipients
 712                                   &optional sign always-trust)
 713   "Initiate an encrypt operation on STRING.
 714 If RECIPIENTS is nil, it performs symmetric encryption.
 715
 716 If you use this function, you will need to wait for the completion of
 717 `epg-gpg-program' by using `epg-wait-for-completion' and call
 718 `epg-reset' to clear a temporaly output file.
 719 If you are unsure, use synchronous version of this function
 720 `epg-encrypt-string' instead."
 721   (epg-context-set-output-file context (epg-make-temp-file "epg-output"))
 722   (epg-start context
 723              (append (if always-trust '("--always-trust"))
 724                      (if recipients '("--encrypt") '("--symmetric"))
 725                      (if sign
 726                          (cons "--sign"
 727                                (apply #'nconc
 728                                       (mapcar (lambda (signer)
 729                                                 (list "-u" signer))
 730                                               (epg-context-signers context)))))
 731                      (apply #'nconc
 732                             (mapcar (lambda (recipient)
 733                                       (list "-r" recipient))
 734                                     recipients))))
 735   (if sign
 736       (epg-wait-for-status context '("BEGIN_SIGNING"))
 737     (if (null recipients)
 738         (epg-wait-for-status context '("BEGIN_ENCRYPTION"))))
 739   (if (eq (process-status (epg-context-process context)) 'run)
 740       (process-send-string (epg-context-process context) string)))
 741
 742 ;;;###autoload
 743 (defun epg-encrypt-string (context string recipients
 744                                    &optional sign always-trust)
 745   "Encrypt STRING.
 746 If RECIPIENTS is nil, it performs symmetric encryption."
 747   (unwind-protect
 748       (progn
 749         (epg-start-encrypt context string recipients sign always-trust)
 750         (epg-wait-for-completion context)
 751         (if (epg-context-result-for context 'error)
 752             (error "Encrypt failed"))
 753         (epg-read-output context))
 754     (epg-reset context)))
 755
 756 ;;;###autoload
 757 (defun epg-start-export-keys (context pattern)
 758   "Initiate an export keys operation.
 759
 760 If you use this function, you will need to wait for the completion of
 761 `epg-gpg-program' by using `epg-wait-for-completion' and call
 762 `epg-reset' to clear a temporaly output file.
 763 If you are unsure, use synchronous version of this function
 764 `epg-export-keys' instead."
 765   (epg-context-set-output-file context (epg-make-temp-file "epg-output"))
 766   (epg-start context (list "--export" pattern)))
 767
 768 ;;;###autoload
 769 (defun epg-export-keys (context pattern)
 770   "Extract public keys matched with PATTERN and return them."
 771   (unwind-protect
 772       (progn
 773         (epg-start-export-keys context pattern)
 774         (epg-wait-for-completion context)
 775         (if (epg-context-result-for context 'error)
 776             (error "Export keys failed"))
 777         (epg-read-output context))
 778     (epg-reset context)))
 779
 780 ;;;###autoload
 781 (defun epg-start-import-keys (context keys)
 782   "Initiate an import key operation.
 783
 784 If you use this function, you will need to wait for the completion of
 785 `epg-gpg-program' by using `epg-wait-for-completion' and call
 786 `epg-reset' to clear a temporaly output file.
 787 If you are unsure, use synchronous version of this function
 788 `epg-import-keys' instead."
 789   (epg-context-set-output-file context (epg-make-temp-file "epg-output"))
 790   (epg-start context (list "--import"))
 791   (if (eq (process-status (epg-context-process context)) 'run)
 792       (process-send-string (epg-context-process context) keys)))
 793
 794 ;;;###autoload
 795 (defun epg-import-keys (context keys)
 796   "Add KEYS."
 797   (unwind-protect
 798       (progn
 799         (epg-start-import-keys context keys)
 800         (epg-wait-for-completion context)
 801         (if (epg-context-result-for context 'error)
 802             (error "Import keys failed"))
 803         (epg-read-output context))
 804     (epg-reset context)))
 805
 806 (provide 'epg)
 807
 808 ;;; epg.el ends here