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-start-verify context input-file string)
 651           (epg-wait-for-completion context)
 652           (epg-context-result-for context 'verify))
 653       (epg-reset context)
 654       (if (file-exists-p input-file)
 655           (delete-file input-file)))))
 656
 657 ;;;###autoload
 658 (defun epg-start-sign (context string &optional mode)
 659   "Initiate a sign operation on STRING.
 660
 661 If optional 3rd argument MODE is 'clearsign, it makes a clear text signature.
 662 If MODE is t or 'detached, it makes a detached signature.
 663 Otherwise, it makes a normal signature.
 664
 665 If you use this function, you will need to wait for the completion of
 666 `epg-gpg-program' by using `epg-wait-for-completion' and call
 667 `epg-reset' to clear a temporaly output file.
 668 If you are unsure, use synchronous version of this function
 669 `epg-sign-string' instead."
 670   (epg-context-set-output-file context (epg-make-temp-file "epg-output"))
 671   (epg-start context
 672              (append (list (if (eq mode 'clearsign)
 673                                "--clearsign"
 674                              (if (or (eq mode t) (eq mode 'detached))
 675                                  "--detach-sign"
 676                                "--sign")))
 677                      (apply #'nconc
 678                             (mapcar (lambda (signer)
 679                                       (list "-u" signer))
 680                                     (epg-context-signers context)))))
 681   (epg-wait-for-status context '("BEGIN_SIGNING"))
 682   (if (eq (process-status (epg-context-process context)) 'run)
 683       (process-send-string (epg-context-process context) string)))
 684
 685 ;;;###autoload
 686 (defun epg-sign-string (context string &optional mode)
 687   "Sign STRING and return the output as string.
 688 If optional 3rd argument MODE is 'clearsign, it makes a clear text signature.
 689 If MODE is t or 'detached, it makes a detached signature.
 690 Otherwise, it makes a normal signature."
 691   (unwind-protect
 692       (progn
 693         (epg-start-sign context string mode)
 694         (epg-wait-for-completion context)
 695         (if (epg-context-result-for context 'error)
 696             (error "Sign failed"))
 697         (epg-read-output context))
 698     (epg-reset context)))
 699
 700 ;;;###autoload
 701 (defun epg-start-encrypt (context string recipients
 702                                   &optional sign always-trust)
 703   "Initiate a encrypt operation on STRING.
 704 If RECIPIENTS is nil, it performs symmetric encryption.
 705
 706 If you use this function, you will need to wait for the completion of
 707 `epg-gpg-program' by using `epg-wait-for-completion' and call
 708 `epg-reset' to clear a temporaly output file.
 709 If you are unsure, use synchronous version of this function
 710 `epg-encrypt-string' instead."
 711   (epg-context-set-output-file context (epg-make-temp-file "epg-output"))
 712   (epg-start context
 713              (append (if always-trust '("--always-trust"))
 714                      (if recipients '("--encrypt") '("--symmetric"))
 715                      (if sign
 716                          (cons "--sign"
 717                                (apply #'nconc
 718                                       (mapcar (lambda (signer)
 719                                                 (list "-u" signer))
 720                                               (epg-context-signers context)))))
 721                      (apply #'nconc
 722                             (mapcar (lambda (recipient)
 723                                       (list "-r" recipient))
 724                                     recipients))))
 725   (if sign
 726       (epg-wait-for-status context '("BEGIN_SIGNING"))
 727     (if (null recipients)
 728         (epg-wait-for-status context '("BEGIN_ENCRYPTION"))))
 729   (if (eq (process-status (epg-context-process context)) 'run)
 730       (process-send-string (epg-context-process context) string)))
 731
 732 ;;;###autoload
 733 (defun epg-encrypt-string (context string recipients
 734                                    &optional sign always-trust)
 735   "Encrypt STRING.
 736 If RECIPIENTS is nil, it performs symmetric encryption."
 737   (unwind-protect
 738       (progn
 739         (epg-start-encrypt context string recipients sign always-trust)
 740         (epg-wait-for-completion context)
 741         (if (epg-context-result-for context 'error)
 742             (error "Encrypt failed"))
 743         (epg-read-output context))
 744     (epg-reset context)))
 745
 746 (provide 'epg)
 747
 748 ;;; epg.el ends here