auth-source.el 90.2 KB
Newer Older
Miles Bader's avatar
Miles Bader committed
1 2
;;; auth-source.el --- authentication sources for Gnus and Emacs

3
;; Copyright (C) 2008-2013 Free Software Foundation, Inc.
Miles Bader's avatar
Miles Bader committed
4 5 6 7 8 9

;; Author: Ted Zlatanov <tzz@lifelogs.com>
;; Keywords: news

;; This file is part of GNU Emacs.

10
;; GNU Emacs is free software: you can redistribute it and/or modify
Miles Bader's avatar
Miles Bader committed
11
;; it under the terms of the GNU General Public License as published by
12 13
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.
Miles Bader's avatar
Miles Bader committed
14 15 16

;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
17
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
Miles Bader's avatar
Miles Bader committed
18 19 20
;; GNU General Public License for more details.

;; 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/>.
Miles Bader's avatar
Miles Bader committed
22 23 24 25 26 27 28

;;; Commentary:

;; This is the auth-source.el package.  It lets users tell Gnus how to
;; authenticate in a single place.  Simplicity is the goal.  Instead
;; of providing 5000 options, we'll stick to simple, easy to
;; understand options.
Miles Bader's avatar
Miles Bader committed
29

Katsumi Yamaoka's avatar
Katsumi Yamaoka committed
30
;; See the auth.info Info documentation for details.
Miles Bader's avatar
Miles Bader committed
31

32 33 34 35 36 37 38 39
;; TODO:

;; - never decode the backend file unless it's necessary
;; - a more generic way to match backends and search backend contents
;; - absorb netrc.el and simplify it
;; - protect passwords better
;; - allow creating and changing netrc lines (not files) e.g. change a password

Miles Bader's avatar
Miles Bader committed
40 41
;;; Code:

42
(require 'password-cache)
43
(require 'mm-util)
Miles Bader's avatar
Miles Bader committed
44
(require 'gnus-util)
45

Miles Bader's avatar
Miles Bader committed
46
(eval-when-compile (require 'cl))
47
(require 'eieio)
48

49 50
(autoload 'secrets-create-item "secrets")
(autoload 'secrets-delete-item "secrets")
Katsumi Yamaoka's avatar
Katsumi Yamaoka committed
51
(autoload 'secrets-get-alias "secrets")
52
(autoload 'secrets-get-attributes "secrets")
53
(autoload 'secrets-get-secret "secrets")
54 55
(autoload 'secrets-list-collections "secrets")
(autoload 'secrets-search-items "secrets")
Miles Bader's avatar
Miles Bader committed
56

57 58
(autoload 'rfc2104-hash "rfc2104")

59 60 61
(autoload 'plstore-open "plstore")
(autoload 'plstore-find "plstore")
(autoload 'plstore-put "plstore")
Daiki Ueno's avatar
Daiki Ueno committed
62
(autoload 'plstore-delete "plstore")
63
(autoload 'plstore-save "plstore")
64
(autoload 'plstore-get-file "plstore")
65

66 67 68 69 70 71
(autoload 'epg-make-context "epg")
(autoload 'epg-context-set-passphrase-callback "epg")
(autoload 'epg-decrypt-string "epg")
(autoload 'epg-context-set-armor "epg")
(autoload 'epg-encrypt-string "epg")

72 73
(autoload 'help-mode "help-mode" nil t)

74 75
(defvar secrets-enabled)

Miles Bader's avatar
Miles Bader committed
76 77
(defgroup auth-source nil
  "Authentication sources."
Miles Bader's avatar
Miles Bader committed
78
  :version "23.1" ;; No Gnus
Miles Bader's avatar
Miles Bader committed
79 80
  :group 'gnus)

81 82 83 84 85
;;;###autoload
(defcustom auth-source-cache-expiry 7200
  "How many seconds passwords are cached, or nil to disable
expiring.  Overrides `password-cache-expiry' through a
let-binding."
86
  :version "24.1"
87 88 89 90 91 92 93
  :group 'auth-source
  :type '(choice (const :tag "Never" nil)
                 (const :tag "All Day" 86400)
                 (const :tag "2 Hours" 7200)
                 (const :tag "30 Minutes" 1800)
                 (integer :tag "Seconds")))

94 95 96
;; The slots below correspond with the `auth-source-search' spec,
;; so a backend with :host set, for instance, would match only
;; searches for that host.  Normally they are nil.
97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116
(defclass auth-source-backend ()
  ((type :initarg :type
         :initform 'netrc
         :type symbol
         :custom symbol
         :documentation "The backend type.")
   (source :initarg :source
           :type string
           :custom string
           :documentation "The backend source.")
   (host :initarg :host
         :initform t
         :type t
         :custom string
         :documentation "The backend host.")
   (user :initarg :user
         :initform t
         :type t
         :custom string
         :documentation "The backend user.")
117 118 119 120 121
   (port :initarg :port
         :initform t
         :type t
         :custom string
         :documentation "The backend protocol.")
122
   (data :initarg :data
123 124
         :initform nil
         :documentation "Internal backend data.")
125 126 127 128 129 130 131 132 133 134 135
   (create-function :initarg :create-function
                    :initform ignore
                    :type function
                    :custom function
                    :documentation "The create function.")
   (search-function :initarg :search-function
                    :initform ignore
                    :type function
                    :custom function
                    :documentation "The search function.")))

Miles Bader's avatar
Miles Bader committed
136
(defcustom auth-source-protocols '((imap "imap" "imaps" "143" "993")
137 138 139 140
                                   (pop3 "pop3" "pop" "pop3s" "110" "995")
                                   (ssh  "ssh" "22")
                                   (sftp "sftp" "115")
                                   (smtp "smtp" "25"))
Miles Bader's avatar
Miles Bader committed
141 142 143
  "List of authentication protocols and their names"

  :group 'auth-source
Katsumi Yamaoka's avatar
Katsumi Yamaoka committed
144
  :version "23.2" ;; No Gnus
Miles Bader's avatar
Miles Bader committed
145
  :type '(repeat :tag "Authentication Protocols"
146 147 148 149
                 (cons :tag "Protocol Entry"
                       (symbol :tag "Protocol")
                       (repeat :tag "Names"
                               (string :tag "Name")))))
Miles Bader's avatar
Miles Bader committed
150

151 152
;; Generate all the protocols in a format Customize can use.
;; TODO: generate on the fly from auth-source-protocols
Miles Bader's avatar
Miles Bader committed
153 154
(defconst auth-source-protocols-customize
  (mapcar (lambda (a)
155 156 157 158 159
            (let ((p (car-safe a)))
              (list 'const
                    :tag (upcase (symbol-name p))
                    p)))
          auth-source-protocols))
Miles Bader's avatar
Miles Bader committed
160

161 162 163
(defvar auth-source-creation-defaults nil
  "Defaults for creating token values.  Usually let-bound.")

164 165 166
(defvar auth-source-creation-prompts nil
  "Default prompts for token values.  Usually let-bound.")

167 168
(make-obsolete 'auth-source-hide-passwords nil "Emacs 24.1")

169 170 171 172 173 174 175 176 177 178
(defcustom auth-source-save-behavior 'ask
  "If set, auth-source will respect it for save behavior."
  :group 'auth-source
  :version "23.2" ;; No Gnus
  :type `(choice
          :tag "auth-source new token save behavior"
          (const :tag "Always save" t)
          (const :tag "Never save" nil)
          (const :tag "Ask" ask)))

179 180 181 182 183
;; TODO: make the default (setq auth-source-netrc-use-gpg-tokens `((,(if (boundp 'epa-file-auto-mode-alist-entry) (car (symbol-value 'epa-file-auto-mode-alist-entry)) "\\.gpg\\'") never) (t gpg)))
;; TODO: or maybe leave as (setq auth-source-netrc-use-gpg-tokens 'never)

(defcustom auth-source-netrc-use-gpg-tokens 'never
  "Set this to tell auth-source when to create GPG password
184 185
tokens in netrc files.  It's either an alist or `never'.
Note that if EPA/EPG is not available, this should NOT be used."
186 187 188
  :group 'auth-source
  :version "23.2" ;; No Gnus
  :type `(choice
189 190 191 192 193 194 195 196 197 198 199 200 201 202 203
          (const :tag "Always use GPG password tokens" (t gpg))
          (const :tag "Never use GPG password tokens" never)
          (repeat :tag "Use a lookup list"
                  (list
                   (choice :tag "Matcher"
                           (const :tag "Match anything" t)
                           (const :tag "The EPA encrypted file extensions"
                                  ,(if (boundp 'epa-file-auto-mode-alist-entry)
                                       (car (symbol-value
                                             'epa-file-auto-mode-alist-entry))
                                     "\\.gpg\\'"))
                           (regexp :tag "Regular expression"))
                   (choice :tag "What to do"
                           (const :tag "Save GPG-encrypted password tokens" gpg)
                           (const :tag "Don't encrypt tokens" never))))))
204

205
(defvar auth-source-magic "auth-source-magic ")
Miles Bader's avatar
Miles Bader committed
206 207

(defcustom auth-source-do-cache t
208
  "Whether auth-source should cache information with `password-cache'."
Miles Bader's avatar
Miles Bader committed
209
  :group 'auth-source
Katsumi Yamaoka's avatar
Katsumi Yamaoka committed
210
  :version "23.2" ;; No Gnus
Miles Bader's avatar
Miles Bader committed
211 212
  :type `boolean)

213
(defcustom auth-source-debug nil
Katsumi Yamaoka's avatar
Katsumi Yamaoka committed
214 215 216
  "Whether auth-source should log debug messages.

If the value is nil, debug messages are not logged.
217 218 219 220 221

If the value is t, debug messages are logged with `message'.  In
that case, your authentication data will be in the clear (except
for passwords).

Katsumi Yamaoka's avatar
Katsumi Yamaoka committed
222 223 224
If the value is a function, debug messages are logged by calling
 that function using the same arguments as `message'."
  :group 'auth-source
Katsumi Yamaoka's avatar
Katsumi Yamaoka committed
225
  :version "23.2" ;; No Gnus
226 227 228
  :type `(choice
          :tag "auth-source debugging mode"
          (const :tag "Log using `message' to the *Messages* buffer" t)
229 230
          (const :tag "Log all trivia with `message' to the *Messages* buffer"
                 trivia)
231 232
          (function :tag "Function that takes arguments like `message'")
          (const :tag "Don't log anything" nil)))
Katsumi Yamaoka's avatar
Katsumi Yamaoka committed
233

234
(defcustom auth-sources '("~/.authinfo" "~/.authinfo.gpg" "~/.netrc")
Miles Bader's avatar
Miles Bader committed
235 236
  "List of authentication sources.

237 238 239
The default will get login and password information from
\"~/.authinfo.gpg\", which you should set up with the EPA/EPG
packages to be encrypted.  If that file doesn't exist, it will
240 241
try the unencrypted version \"~/.authinfo\" and the famous
\"~/.netrc\" file.
242 243

See the auth.info manual for details.
244

Katsumi Yamaoka's avatar
Katsumi Yamaoka committed
245 246 247 248
Each entry is the authentication type with optional properties.

It's best to customize this with `M-x customize-variable' because the choices
can get pretty complex."
Miles Bader's avatar
Miles Bader committed
249
  :group 'auth-source
250
  :version "24.1" ;; No Gnus
Miles Bader's avatar
Miles Bader committed
251
  :type `(repeat :tag "Authentication Sources"
252 253 254
                 (choice
                  (string :tag "Just a file")
                  (const :tag "Default Secrets API Collection" 'default)
255
                  (const :tag "Login Secrets API Collection" "secrets:Login")
256
                  (const :tag "Temp Secrets API Collection" "secrets:session")
257 258

                  (const :tag "Default internet Mac OS Keychain"
259
                         macos-keychain-internet)
260 261

                  (const :tag "Default generic Mac OS Keychain"
262
                         macos-keychain-generic)
263

264 265 266 267 268 269 270 271 272 273
                  (list :tag "Source definition"
                        (const :format "" :value :source)
                        (choice :tag "Authentication backend choice"
                                (string :tag "Authentication Source (file)")
                                (list
                                 :tag "Secret Service API/KWallet/GNOME Keyring"
                                 (const :format "" :value :secrets)
                                 (choice :tag "Collection to use"
                                         (string :tag "Collection name")
                                         (const :tag "Default" 'default)
274
                                         (const :tag "Login" "Login")
275
                                         (const
276 277 278 279 280 281 282
                                          :tag "Temporary" "session")))
                                (list
                                 :tag "Mac OS internet Keychain"
                                 (const :format ""
                                        :value :macos-keychain-internet)
                                 (choice :tag "Collection to use"
                                         (string :tag "internet Keychain path")
283
                                         (const :tag "default" 'default)))
284 285 286 287 288 289 290
                                (list
                                 :tag "Mac OS generic Keychain"
                                 (const :format ""
                                        :value :macos-keychain-generic)
                                 (choice :tag "Collection to use"
                                         (string :tag "generic Keychain path")
                                         (const :tag "default" 'default))))
291 292 293 294 295 296 297 298 299 300 301
                        (repeat :tag "Extra Parameters" :inline t
                                (choice :tag "Extra parameter"
                                        (list
                                         :tag "Host"
                                         (const :format "" :value :host)
                                         (choice :tag "Host (machine) choice"
                                                 (const :tag "Any" t)
                                                 (regexp
                                                  :tag "Regular expression")))
                                        (list
                                         :tag "Protocol"
302
                                         (const :format "" :value :port)
303 304 305 306 307 308
                                         (choice
                                          :tag "Protocol"
                                          (const :tag "Any" t)
                                          ,@auth-source-protocols-customize))
                                        (list :tag "User" :inline t
                                              (const :format "" :value :user)
309 310
                                              (choice
                                               :tag "Personality/Username"
311 312 313
                                               (const :tag "Any" t)
                                               (string
                                                :tag "Name")))))))))
Miles Bader's avatar
Miles Bader committed
314

315 316 317 318
(defcustom auth-source-gpg-encrypt-to t
  "List of recipient keys that `authinfo.gpg' encrypted to.
If the value is not a list, symmetric encryption will be used."
  :group 'auth-source
319
  :version "24.1" ;; No Gnus
320
  :type '(choice (const :tag "Symmetric encryption" t)
321 322
                 (repeat :tag "Recipient public keys"
                         (string :tag "Recipient public key"))))
323

Miles Bader's avatar
Miles Bader committed
324
;; temp for debugging
Miles Bader's avatar
Miles Bader committed
325 326 327 328 329 330 331 332
;; (unintern 'auth-source-protocols)
;; (unintern 'auth-sources)
;; (customize-variable 'auth-sources)
;; (setq auth-sources nil)
;; (format "%S" auth-sources)
;; (customize-variable 'auth-source-protocols)
;; (setq auth-source-protocols nil)
;; (format "%S" auth-source-protocols)
333
;; (auth-source-pick nil :host "a" :port 'imap)
Miles Bader's avatar
Miles Bader committed
334 335 336 337 338 339
;; (auth-source-user-or-password "login" "imap.myhost.com" 'imap)
;; (auth-source-user-or-password "password" "imap.myhost.com" 'imap)
;; (auth-source-user-or-password-imap "login" "imap.myhost.com")
;; (auth-source-user-or-password-imap "password" "imap.myhost.com")
;; (auth-source-protocol-defaults 'imap)

340 341 342
;; (let ((auth-source-debug 'debug)) (auth-source-do-debug "hello"))
;; (let ((auth-source-debug t)) (auth-source-do-debug "hello"))
;; (let ((auth-source-debug nil)) (auth-source-do-debug "hello"))
Katsumi Yamaoka's avatar
Katsumi Yamaoka committed
343 344
(defun auth-source-do-debug (&rest msg)
  (when auth-source-debug
345 346
    (apply 'auth-source-do-warn msg)))

347 348 349 350 351
(defun auth-source-do-trivia (&rest msg)
  (when (or (eq auth-source-debug 'trivia)
            (functionp auth-source-debug))
    (apply 'auth-source-do-warn msg)))

352 353
(defun auth-source-do-warn (&rest msg)
  (apply
354 355
   ;; set logger to either the function in auth-source-debug or 'message
   ;; note that it will be 'message if auth-source-debug is nil
356 357 358 359 360
   (if (functionp auth-source-debug)
       auth-source-debug
     'message)
   msg))

Katsumi Yamaoka's avatar
Katsumi Yamaoka committed
361

362
;; (auth-source-read-char-choice "enter choice? " '(?a ?b ?q))
363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383
(defun auth-source-read-char-choice (prompt choices)
  "Read one of CHOICES by `read-char-choice', or `read-char'.
`dropdown-list' support is disabled because it doesn't work reliably.
Only one of CHOICES will be returned.  The PROMPT is augmented
with \"[a/b/c] \" if CHOICES is '\(?a ?b ?c\)."
  (when choices
    (let* ((prompt-choices
            (apply 'concat (loop for c in choices
                                 collect (format "%c/" c))))
           (prompt-choices (concat "[" (substring prompt-choices 0 -1) "] "))
           (full-prompt (concat prompt prompt-choices))
           k)

      (while (not (memq k choices))
        (setq k (cond
                 ((fboundp 'read-char-choice)
                  (read-char-choice full-prompt choices))
                 (t (message "%s" full-prompt)
                    (setq k (read-char))))))
      k)))

384 385 386 387 388 389
;; (auth-source-pick nil :host "any" :port 'imap :user "joe")
;; (auth-source-pick t :host "any" :port 'imap :user "joe")
;; (setq auth-sources '((:source (:secrets default) :host t :port t :user "joe")
;;                   (:source (:secrets "session") :host t :port t :user "joe")
;;                   (:source (:secrets "Login") :host t :port t)
;;                   (:source "~/.authinfo.gpg" :host t :port t)))
390

391 392 393
;; (setq auth-sources '((:source (:secrets default) :host t :port t :user "joe")
;;                   (:source (:secrets "session") :host t :port t :user "joe")
;;                   (:source (:secrets "Login") :host t :port t)
394
;;                   ))
395

396
;; (setq auth-sources '((:source "~/.authinfo.gpg" :host t :port t)))
397

398 399
;; (auth-source-backend-parse "myfile.gpg")
;; (auth-source-backend-parse 'default)
400
;; (auth-source-backend-parse "secrets:Login")
401 402 403 404
;; (auth-source-backend-parse 'macos-keychain-internet)
;; (auth-source-backend-parse 'macos-keychain-generic)
;; (auth-source-backend-parse "macos-keychain-internet:/path/here.keychain")
;; (auth-source-backend-parse "macos-keychain-generic:/path/here.keychain")
405 406 407 408 409 410 411 412 413 414 415 416 417 418

(defun auth-source-backend-parse (entry)
  "Creates an auth-source-backend from an ENTRY in `auth-sources'."
  (auth-source-backend-parse-parameters
   entry
   (cond
    ;; take 'default and recurse to get it as a Secrets API default collection
    ;; matching any user, host, and protocol
    ((eq entry 'default)
     (auth-source-backend-parse '(:source (:secrets default))))
    ;; take secrets:XYZ and recurse to get it as Secrets API collection "XYZ"
    ;; matching any user, host, and protocol
    ((and (stringp entry) (string-match "^secrets:\\(.+\\)" entry))
     (auth-source-backend-parse `(:source (:secrets ,(match-string 1 entry)))))
419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440

    ;; take 'macos-keychain-internet and recurse to get it as a Mac OS
    ;; Keychain collection matching any user, host, and protocol
    ((eq entry 'macos-keychain-internet)
     (auth-source-backend-parse '(:source (:macos-keychain-internet default))))
    ;; take 'macos-keychain-generic and recurse to get it as a Mac OS
    ;; Keychain collection matching any user, host, and protocol
    ((eq entry 'macos-keychain-generic)
     (auth-source-backend-parse '(:source (:macos-keychain-generic default))))
    ;; take macos-keychain-internet:XYZ and recurse to get it as MacOS
    ;; Keychain "XYZ" matching any user, host, and protocol
    ((and (stringp entry) (string-match "^macos-keychain-internet:\\(.+\\)"
                                        entry))
     (auth-source-backend-parse `(:source (:macos-keychain-internet
                                           ,(match-string 1 entry)))))
    ;; take macos-keychain-generic:XYZ and recurse to get it as MacOS
    ;; Keychain "XYZ" matching any user, host, and protocol
    ((and (stringp entry) (string-match "^macos-keychain-generic:\\(.+\\)"
                                        entry))
     (auth-source-backend-parse `(:source (:macos-keychain-generic
                                           ,(match-string 1 entry)))))

441 442 443 444 445 446 447
    ;; take just a file name and recurse to get it as a netrc file
    ;; matching any user, host, and protocol
    ((stringp entry)
     (auth-source-backend-parse `(:source ,entry)))

    ;; a file name with parameters
    ((stringp (plist-get entry :source))
448
     (if (equal (file-name-extension (plist-get entry :source)) "plist")
449 450 451 452 453 454 455
         (auth-source-backend
          (plist-get entry :source)
          :source (plist-get entry :source)
          :type 'plstore
          :search-function 'auth-source-plstore-search
          :create-function 'auth-source-plstore-create
          :data (plstore-open (plist-get entry :source)))
456
       (auth-source-backend
457 458 459 460 461
        (plist-get entry :source)
        :source (plist-get entry :source)
        :type 'netrc
        :search-function 'auth-source-netrc-search
        :create-function 'auth-source-netrc-create)))
462

463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489
    ;; the MacOS Keychain
    ((and
      (not (null (plist-get entry :source))) ; the source must not be nil
      (listp (plist-get entry :source))      ; and it must be a list
      (or
       (plist-get (plist-get entry :source) :macos-keychain-generic)
       (plist-get (plist-get entry :source) :macos-keychain-internet)))

     (let* ((source-spec (plist-get entry :source))
            (keychain-generic (plist-get source-spec :macos-keychain-generic))
            (keychain-type (if keychain-generic
                               'macos-keychain-generic
                             'macos-keychain-internet))
            (source (plist-get source-spec (if keychain-generic
                                               :macos-keychain-generic
                                             :macos-keychain-internet))))

       (when (symbolp source)
         (setq source (symbol-name source)))

       (auth-source-backend
        (format "Mac OS Keychain (%s)" source)
        :source source
        :type keychain-type
        :search-function 'auth-source-macos-keychain-search
        :create-function 'auth-source-macos-keychain-create)))

490 491 492 493 494 495 496 497 498 499 500 501 502 503
    ;; the Secrets API.  We require the package, in order to have a
    ;; defined value for `secrets-enabled'.
    ((and
      (not (null (plist-get entry :source))) ; the source must not be nil
      (listp (plist-get entry :source))      ; and it must be a list
      (require 'secrets nil t)               ; and we must load the Secrets API
      secrets-enabled)                       ; and that API must be enabled

     ;; the source is either the :secrets key in ENTRY or
     ;; if that's missing or nil, it's "session"
     (let ((source (or (plist-get (plist-get entry :source) :secrets)
                       "session")))

       ;; if the source is a symbol, we look for the alias named so,
504
       ;; and if that alias is missing, we use "Login"
505 506
       (when (symbolp source)
         (setq source (or (secrets-get-alias (symbol-name source))
507
                          "Login")))
508

509 510 511 512 513 514 515 516 517 518 519 520 521
       (if (featurep 'secrets)
           (auth-source-backend
            (format "Secrets API (%s)" source)
            :source source
            :type 'secrets
            :search-function 'auth-source-secrets-search
            :create-function 'auth-source-secrets-create)
         (auth-source-do-warn
          "auth-source-backend-parse: no Secrets API, ignoring spec: %S" entry)
         (auth-source-backend
          (format "Ignored Secrets API (%s)" source)
          :source ""
          :type 'ignore))))
522 523 524

    ;; none of them
    (t
525
     (auth-source-do-warn
526 527 528 529 530 531 532 533
      "auth-source-backend-parse: invalid backend spec: %S" entry)
     (auth-source-backend
      "Empty"
      :source ""
      :type 'ignore)))))

(defun auth-source-backend-parse-parameters (entry backend)
  "Fills in the extra auth-source-backend parameters of ENTRY.
534 535
Using the plist ENTRY, get the :host, :port, and :user search
parameters."
536 537 538 539
  (let ((entry (if (stringp entry)
                   nil
                 entry))
        val)
540 541 542 543
    (when (setq val (plist-get entry :host))
      (oset backend host val))
    (when (setq val (plist-get entry :user))
      (oset backend user val))
544 545
    (when (setq val (plist-get entry :port))
      (oset backend port val)))
546 547 548 549 550
  backend)

;; (mapcar 'auth-source-backend-parse auth-sources)

(defun* auth-source-search (&rest spec
551
                                  &key type max host user port secret
552
                                  require create delete
553 554 555 556 557 558 559 560 561 562 563
                                  &allow-other-keys)
  "Search or modify authentication backends according to SPEC.

This function parses `auth-sources' for matches of the SPEC
plist.  It can optionally create or update an authentication
token if requested.  A token is just a standard Emacs property
list with a :secret property that can be a function; all the
other properties will always hold scalar values.

Typically the :secret property, if present, contains a password.

564
Common search keys are :max, :host, :port, and :user.  In
565 566 567 568 569 570 571 572 573 574 575 576 577
addition, :create specifies how tokens will be or created.
Finally, :type can specify which backend types you want to check.

A string value is always matched literally.  A symbol is matched
as its string value, literally.  All the SPEC values can be
single values (symbol or string) or lists thereof (in which case
any of the search terms matches).

:create t means to create a token if possible.

A new token will be created if no matching tokens were found.
The new token will have only the keys the backend requires.  For
the netrc backend, for instance, that's the user, host, and
578
port keys.
579 580 581 582 583 584 585 586 587 588 589 590 591 592 593

Here's an example:

\(let ((auth-source-creation-defaults '((user . \"defaultUser\")
                                        (A    . \"default A\"))))
  (auth-source-search :host \"mine\" :type 'netrc :max 1
                      :P \"pppp\" :Q \"qqqq\"
                      :create t))

which says:

\"Search for any entry matching host 'mine' in backends of type
 'netrc', maximum one result.

 Create a new entry if you found none.  The netrc backend will
594
 automatically require host, user, and port.  The host will be
595
 'mine'.  We prompt for the user with default 'defaultUser' and
596
 for the port without a default.  We will not prompt for A, Q,
597
 or P.  The resulting token will only have keys user, host, and
598
 port.\"
599 600 601 602 603 604 605 606

:create '(A B C) also means to create a token if possible.

The behavior is like :create t but if the list contains any
parameter, that parameter will be required in the resulting
token.  The value for that parameter will be obtained from the
search parameters or from user input.  If any queries are needed,
the alist `auth-source-creation-defaults' will be checked for the
607 608 609 610 611
default value.  If the user, host, or port are missing, the alist
`auth-source-creation-prompts' will be used to look up the
prompts IN THAT ORDER (so the 'user prompt will be queried first,
then 'host, then 'port, and finally 'secret).  Each prompt string
can use %u, %h, and %p to show the user, host, and port.
612 613 614 615

Here's an example:

\(let ((auth-source-creation-defaults '((user . \"defaultUser\")
616 617 618
                                        (A    . \"default A\")))
       (auth-source-creation-prompts
        '((password . \"Enter IMAP password for %h:%p: \"))))
619 620 621 622 623 624 625 626 627 628
  (auth-source-search :host '(\"nonesuch\" \"twosuch\") :type 'netrc :max 1
                      :P \"pppp\" :Q \"qqqq\"
                      :create '(A B Q)))

which says:

\"Search for any entry matching host 'nonesuch'
 or 'twosuch' in backends of type 'netrc', maximum one result.

 Create a new entry if you found none.  The netrc backend will
629
 automatically require host, user, and port.  The host will be
630 631 632 633 634
 'nonesuch' and Q will be 'qqqq'.  We prompt for the password
 with the shown prompt.  We will not prompt for Q.  The resulting
 token will have keys user, host, port, A, B, and Q.  It will not
 have P with any value, even though P is used in the search to
 find only entries that have P set to 'pppp'.\"
635 636

When multiple values are specified in the search parameter, the
637 638
user is prompted for which one.  So :host (X Y Z) would ask the
user to choose between X, Y, and Z.
639 640 641 642 643 644 645

This creation can fail if the search was not specific enough to
create a new token (it's up to the backend to decide that).  You
should `catch' the backend-specific error as usual.  Some
backends (netrc, at least) will prompt the user rather than throw
an error.

646 647 648 649 650
:require (A B C) means that only results that contain those
tokens will be returned.  Thus for instance requiring :secret
will ensure that any results will actually have a :secret
property.

651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668
:delete t means to delete any found entries.  nil by default.
Use `auth-source-delete' in ELisp code instead of calling
`auth-source-search' directly with this parameter.

:type (X Y Z) will check only those backend types.  'netrc and
'secrets are the only ones supported right now.

:max N means to try to return at most N items (defaults to 1).
When 0 the function will return just t or nil to indicate if any
matches were found.  More than N items may be returned, depending
on the search and the backend.

:host (X Y Z) means to match only hosts X, Y, or Z according to
the match rules above.  Defaults to t.

:user (X Y Z) means to match only users X, Y, or Z according to
the match rules above.  Defaults to t.

669
:port (P Q R) means to match only protocols P, Q, or R.
670 671 672 673 674 675
Defaults to t.

:K (V1 V2 V3) for any other key K will match values V1, V2, or
V3 (note the match rules above).

The return value is a list with at most :max tokens.  Each token
676
is a plist with keys :backend :host :port :user, plus any other
677 678 679
keys provided by the backend (notably :secret).  But note the
exception for :max 0, which see above.

680 681 682 683 684 685
The token can hold a :save-function key.  If you call that, the
user will be prompted to save the data to the backend.  You can't
request that this should happen right after creation, because
`auth-source-search' has no way of knowing if the token is
actually useful.  So the caller must arrange to call this function.

686 687 688 689
The token's :secret key can hold a function.  In that case you
must call it to obtain the actual value."
  (let* ((backends (mapcar 'auth-source-backend-parse auth-sources))
         (max (or max 1))
690
         (ignored-keys '(:require :create :delete :max))
691 692 693
         (keys (loop for i below (length spec) by 2
                     unless (memq (nth i spec) ignored-keys)
                     collect (nth i spec)))
694 695 696
         (cached (auth-source-remembered-p spec))
         ;; note that we may have cached results but found is still nil
         ;; (there were no results from the search)
697
         (found (auth-source-recall spec))
698
         filtered-backends accessor-key backend)
699

700
    (if (and cached auth-source-do-cache)
701 702 703 704 705 706
        (auth-source-do-debug
         "auth-source-search: found %d CACHED results matching %S"
         (length found) spec)

      (assert
       (or (eq t create) (listp create)) t
707
       "Invalid auth-source :create parameter (must be t or a list): %s %s")
708

709 710 711 712
      (assert
       (listp require) t
       "Invalid auth-source :require parameter (must be a list): %s")

713
      (setq filtered-backends (copy-sequence backends))
714 715 716 717 718 719 720 721 722 723 724
      (dolist (backend backends)
        (dolist (key keys)
          ;; ignore invalid slots
          (condition-case signal
              (unless (eval `(auth-source-search-collection
                              (plist-get spec key)
                              (oref backend ,key)))
                (setq filtered-backends (delq backend filtered-backends))
                (return))
            (invalid-slot-name))))

725
      (auth-source-do-trivia
726 727 728 729
       "auth-source-search: found %d backends matching %S"
       (length filtered-backends) spec)

      ;; (debug spec "filtered" filtered-backends)
730 731
      ;; First go through all the backends without :create, so we can
      ;; query them all.
732 733 734 735
      (setq found (auth-source-search-backends filtered-backends
                                               spec
                                               ;; to exit early
                                               max
736 737 738
                                               ;; create is always nil here
                                               nil delete
                                               require))
739 740 741 742 743

      (auth-source-do-debug
       "auth-source-search: found %d results (max %d) matching %S"
       (length found) max spec)

744 745
      ;; If we didn't find anything, then we allow the backend(s) to
      ;; create the entries.
746
      (when (and create
747 748 749 750 751
                 (not found))
        (setq found (auth-source-search-backends filtered-backends
                                                 spec
                                                 ;; to exit early
                                                 max
752 753 754
                                                 create delete
                                                 require))
        (auth-source-do-debug
755 756 757
         "auth-source-search: CREATED %d results (max %d) matching %S"
         (length found) max spec))

758 759
      ;; note we remember the lack of result too, if it's applicable
      (when auth-source-do-cache
760 761
        (auth-source-remember spec found)))

762
    found))
763

764
(defun auth-source-search-backends (backends spec max create delete require)
765 766 767
  (let (matches)
    (dolist (backend backends)
      (when (> max (length matches))   ; when we need more matches...
768 769 770
        (let* ((bmatches (apply
                          (slot-value backend 'search-function)
                          :backend backend
771
                          :type (slot-value backend :type)
772 773 774 775 776 777
                          ;; note we're overriding whatever the spec
                          ;; has for :require, :create, and :delete
                          :require require
                          :create create
                          :delete delete
                          spec)))
778 779 780 781 782 783 784 785 786
          (when bmatches
            (auth-source-do-trivia
             "auth-source-search-backend: got %d (max %d) in %s:%s matching %S"
             (length bmatches) max
             (slot-value backend :type)
             (slot-value backend :source)
             spec)
            (setq matches (append matches bmatches))))))
    matches))
787

788 789 790 791
;; (auth-source-search :max 1)
;; (funcall (plist-get (nth 0 (auth-source-search :max 1)) :secret))
;; (auth-source-search :host "nonesuch" :type 'netrc :K 1)
;; (auth-source-search :host "nonesuch" :type 'secrets)
792 793 794 795 796 797 798 799 800 801 802 803

(defun* auth-source-delete (&rest spec
                                  &key delete
                                  &allow-other-keys)
  "Delete entries from the authentication backends according to SPEC.
Calls `auth-source-search' with the :delete property in SPEC set to t.
The backend may not actually delete the entries.

Returns the deleted entries."
  (auth-source-search (plist-put spec :delete t)))

(defun auth-source-search-collection (collection value)
804
  "Returns t is VALUE is t or COLLECTION is t or COLLECTION contains VALUE."
805 806 807 808 809 810 811 812
  (when (and (atom collection) (not (eq t collection)))
    (setq collection (list collection)))

  ;; (debug :collection collection :value value)
  (or (eq collection t)
      (eq value t)
      (equal collection value)
      (member value collection)))
Miles Bader's avatar
Miles Bader committed
813

814 815
(defvar auth-source-netrc-cache nil)

Miles Bader's avatar
Miles Bader committed
816
(defun auth-source-forget-all-cached ()
817
  "Forget all cached auth-source data."
Miles Bader's avatar
Miles Bader committed
818
  (interactive)
819 820 821 822 823
  (loop for sym being the symbols of password-data
        ;; when the symbol name starts with auth-source-magic
        when (string-match (concat "^" auth-source-magic)
                           (symbol-name sym))
        ;; remove that key
824 825
        do (password-cache-remove (symbol-name sym)))
  (setq auth-source-netrc-cache nil))
826

827 828 829 830
(defun auth-source-format-cache-entry (spec)
  "Format SPEC entry to put it in the password cache."
  (concat auth-source-magic (format "%S" spec)))

831 832
(defun auth-source-remember (spec found)
  "Remember FOUND search results for SPEC."
833 834
  (let ((password-cache-expiry auth-source-cache-expiry))
    (password-cache-add
835
     (auth-source-format-cache-entry spec) found)))
836 837 838

(defun auth-source-recall (spec)
  "Recall FOUND search results for SPEC."
839
  (password-read-from-cache (auth-source-format-cache-entry spec)))
840

841 842 843
(defun auth-source-remembered-p (spec)
  "Check if SPEC is remembered."
  (password-in-cache-p
844
   (auth-source-format-cache-entry spec)))
845

846 847 848 849 850
(defun auth-source-forget (spec)
  "Forget any cached data matching SPEC exactly.

This is the same SPEC you passed to `auth-source-search'.
Returns t or nil for forgotten or not found."
851
  (password-cache-remove (auth-source-format-cache-entry spec)))
852

853
;; (loop for sym being the symbols of password-data when (string-match (concat "^" auth-source-magic) (symbol-name sym)) collect (symbol-name sym))
854

855 856 857 858 859 860 861 862
;; (auth-source-remember '(:host "wedd") '(4 5 6))
;; (auth-source-remembered-p '(:host "wedd"))
;; (auth-source-remember '(:host "xedd") '(1 2 3))
;; (auth-source-remembered-p '(:host "xedd"))
;; (auth-source-remembered-p '(:host "zedd"))
;; (auth-source-recall '(:host "xedd"))
;; (auth-source-recall '(:host t))
;; (auth-source-forget+ :host t)
863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887

(defun* auth-source-forget+ (&rest spec &allow-other-keys)
  "Forget any cached data matching SPEC.  Returns forgotten count.

This is not a full `auth-source-search' spec but works similarly.
For instance, \(:host \"myhost\" \"yourhost\") would find all the
cached data that was found with a search for those two hosts,
while \(:host t) would find all host entries."
  (let ((count 0)
        sname)
    (loop for sym being the symbols of password-data
          ;; when the symbol name matches with auth-source-magic
          when (and (setq sname (symbol-name sym))
                    (string-match (concat "^" auth-source-magic "\\(.+\\)")
                                  sname)
                    ;; and the spec matches what was stored in the cache
                    (auth-source-specmatchp spec (read (match-string 1 sname))))
          ;; remove that key
          do (progn
               (password-cache-remove sname)
               (incf count)))
    count))

(defun auth-source-specmatchp (spec stored)
  (let ((keys (loop for i below (length spec) by 2
888
                    collect (nth i spec))))
889 890 891 892 893 894 895
    (not (eq
          (dolist (key keys)
            (unless (auth-source-search-collection (plist-get stored key)
                                                   (plist-get spec key))
              (return 'no)))
          'no))))

896 897
;; (auth-source-pick-first-password :host "z.lifelogs.com")
;; (auth-source-pick-first-password :port "imap")
898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913
(defun auth-source-pick-first-password (&rest spec)
  "Pick the first secret found from applying SPEC to `auth-source-search'."
  (let* ((result (nth 0 (apply 'auth-source-search (plist-put spec :max 1))))
         (secret (plist-get result :secret)))

    (if (functionp secret)
        (funcall secret)
      secret)))

;; (auth-source-format-prompt "test %u %h %p" '((?u "user") (?h "host")))
(defun auth-source-format-prompt (prompt alist)
  "Format PROMPT using %x (for any character x) specifiers in ALIST."
  (dolist (cell alist)
    (let ((c (nth 0 cell))
          (v (nth 1 cell)))
      (when (and c v)
914 915
        (setq prompt (replace-regexp-in-string (format "%%%c" c)
                                               (format "%s" v)
916
                                               prompt nil t)))))
917
  prompt)
918

919 920 921 922
(defun auth-source-ensure-strings (values)
  (unless (listp values)
    (setq values (list values)))
  (mapcar (lambda (value)
923 924 925 926
            (if (numberp value)
                (format "%s" value)
              value))
          values))
927

928 929
;;; Backend specific parsing: netrc/authinfo backend

930 931 932 933 934 935 936 937 938 939 940 941 942 943 944
(defun auth-source--aput-1 (alist key val)
  (let ((seen ())
        (rest alist))
    (while (and (consp rest) (not (equal key (caar rest))))
      (push (pop rest) seen))
    (cons (cons key val)
          (if (null rest) alist
            (nconc (nreverse seen)
                   (if (equal key (caar rest)) (cdr rest) rest))))))
(defmacro auth-source--aput (var key val)
  `(setq ,var (auth-source--aput-1 ,var ,key ,val)))

(defun auth-source--aget (alist key)
  (cdr (assoc key alist)))

945
;; (auth-source-netrc-parse :file "~/.authinfo.gpg")
946 947
(defun* auth-source-netrc-parse (&rest
                                 spec
948
                                 &key file max host user port delete require
949 950 951 952 953 954 955
                                 &allow-other-keys)
  "Parse FILE and return a list of all entries in the file.
Note that the MAX parameter is used so we can exit the parse early."
  (if (listp file)
      ;; We got already parsed contents; just return it.
      file
    (when (file-exists-p file)
956
      (setq port (auth-source-ensure-strings port))
957
      (with-temp-buffer
958
        (let* ((max (or max 5000))       ; sanity check: default to stop at 5K
959 960 961 962
               (modified 0)
               (cached (cdr-safe (assoc file auth-source-netrc-cache)))
               (cached-mtime (plist-get cached :mtime))
               (cached-secrets (plist-get cached :secret))
963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992
               (check (lambda(alist)
                        (and alist
                             (auth-source-search-collection
                              host
                              (or
                               (auth-source--aget alist "machine")
                               (auth-source--aget alist "host")
                               t))
                             (auth-source-search-collection
                              user
                              (or
                               (auth-source--aget alist "login")
                               (auth-source--aget alist "account")
                               (auth-source--aget alist "user")
                               t))
                             (auth-source-search-collection
                              port
                              (or
                               (auth-source--aget alist "port")
                               (auth-source--aget alist "protocol")
                               t))
                             (or
                              ;; the required list of keys is nil, or
                              (null require)
                              ;; every element of require is in n(ormalized)
                              (let ((n (nth 0 (auth-source-netrc-normalize
                                               (list alist) file))))
                                (loop for req in require
                                      always (plist-get n req)))))))
               result)
993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005

          (if (and (functionp cached-secrets)
                   (equal cached-mtime
                          (nth 5 (file-attributes file))))
              (progn
                (auth-source-do-trivia
                 "auth-source-netrc-parse: using CACHED file data for %s"
                 file)
                (insert (funcall cached-secrets)))
            (insert-file-contents file)
            ;; cache all netrc files (used to be just .gpg files)
            ;; Store the contents of the file heavily encrypted in memory.
            ;; (note for the irony-impaired: they are just obfuscated)
1006 1007 1008 1009 1010
            (auth-source--aput
             auth-source-netrc-cache file
             (list :mtime (nth 5 (file-attributes file))
                   :secret (lexical-let ((v (mapcar '1+ (buffer-string))))
                             (lambda () (apply 'string (mapcar '1- v)))))))
1011
          (goto-char (point-min))
1012 1013 1014 1015
          (let ((entries (auth-source-netrc-parse-entries check max))
                alist)
            (while (setq alist (pop entries))
                (push (nreverse alist) result)))
1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028

          (when (< 0 modified)
            (when auth-source-gpg-encrypt-to
              ;; (see bug#7487) making `epa-file-encrypt-to' local to
              ;; this buffer lets epa-file skip the key selection query
              ;; (see the `local-variable-p' check in
              ;; `epa-file-write-region').
              (unless (local-variable-p 'epa-file-encrypt-to (current-buffer))
                (make-local-variable 'epa-file-encrypt-to))
              (if (listp auth-source-gpg-encrypt-to)
                  (setq epa-file-encrypt-to auth-source-gpg-encrypt-to)))

            ;; ask AFTER we've successfully opened the file
1029
            (when (y-or-n-p (format "Save file %s? (%d deletions)"
1030 1031 1032 1033 1034 1035 1036 1037
                                    file modified))
              (write-region (point-min) (point-max) file nil 'silent)
              (auth-source-do-debug
               "auth-source-netrc-parse: modified %d lines in %s"
               modified file)))

          (nreverse result))))))

1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057
(defun auth-source-netrc-parse-next-interesting ()
  "Advance to the next interesting position in the current buffer."
  ;; If we're looking at a comment or are at the end of the line, move forward
  (while (or (looking-at "#")
             (and (eolp)
                  (not (eobp))))
    (forward-line 1))
  (skip-chars-forward "\t "))

(defun auth-source-netrc-parse-one ()
  "Read one thing from the current buffer."
  (auth-source-netrc-parse-next-interesting)

  (when (or (looking-at "'\\([^']+\\)'")
            (looking-at "\"\\([^\"]+\\)\"")
            (looking-at "\\([^ \t\n]+\\)"))
    (forward-char (length (match-string 0)))
    (auth-source-netrc-parse-next-interesting)
    (match-string-no-properties 1)))

1058 1059 1060 1061 1062 1063 1064
;; with thanks to org-mode
(defsubst auth-source-current-line (&optional pos)
  (save-excursion
    (and pos (goto-char pos))
    ;; works also in narrowed buffer, because we start at 1, not point-min
    (+ (if (bolp) 1 0) (count-lines 1 (point)))))

1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080
(defun auth-source-netrc-parse-entries(check max)
  "Parse up to MAX netrc entries, passed by CHECK, from the current buffer."
  (let ((adder (lambda(check alist all)
                 (when (and
                        alist
                        (> max (length all))
                        (funcall check alist))
                   (push alist all))
                 all))
        item item2 all alist default)
    (while (setq item (auth-source-netrc-parse-one))
      (setq default (equal item "default"))
      ;; We're starting a new machine.  Save the old one.
      (when (and alist
                 (or default
                     (equal item "machine")))
1081 1082
        ;; (auth-source-do-trivia
        ;;  "auth-source-netrc-parse-entries: got entry %S" alist)
1083 1084 1085 1086 1087 1088 1089 1090
        (setq all (funcall adder check alist all)
              alist nil))
      ;; In default entries, we don't have a next token.
      ;; We store them as ("machine" . t)
      (if default
          (push (cons "machine" t) alist)
        ;; Not a default entry.  Grab the next item.
        (when (setq item2 (auth-source-netrc-parse-one))
1091 1092 1093 1094 1095 1096 1097 1098 1099
          ;; Did we get a "machine" value?
          (if (equal item2 "machine")
              (progn
                (gnus-error 1
                 "%s: Unexpected 'machine' token at line %d"
                 "auth-source-netrc-parse-entries"
                 (auth-source-current-line))
                (forward-line 1))
            (push (cons item item2) alist)))))
1100 1101 1102

    ;; Clean up: if there's an entry left over, use it.
    (when alist
1103
      (setq all (funcall adder check alist all))
1104 1105 1106
      ;; (auth-source-do-trivia
      ;;  "auth-source-netrc-parse-entries: got2 entry %S" alist)
      )
1107 1108
    (nreverse all)))

1109 1110 1111
(defvar auth-source-passphrase-alist nil)

(defun auth-source-token-passphrase-callback-function (context key-id file)
Daiki Ueno's avatar
Daiki Ueno committed
1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129
  (let* ((file (file-truename file))
	 (entry (assoc file auth-source-passphrase-alist))
	 passphrase)
    ;; return the saved passphrase, calling a function if needed
    (or (copy-sequence (if (functionp (cdr entry))
			   (funcall (cdr entry))
			 (cdr entry)))
	(progn
	  (unless entry
	    (setq entry (list file))
	    (push entry auth-source-passphrase-alist))
	  (setq passphrase
		(read-passwd
		 (format "Passphrase for %s tokens: " file)
		 t))
	  (setcdr entry (lexical-let ((p (copy-sequence passphrase)))
			  (lambda () p)))
	  passphrase))))
1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145

;; (auth-source-epa-extract-gpg-token "gpg:LS0tLS1CRUdJTiBQR1AgTUVTU0FHRS0tLS0tClZlcnNpb246IEdudVBHIHYxLjQuMTEgKEdOVS9MaW51eCkKCmpBMEVBd01DT25qMjB1ak9rZnRneVI3K21iNm9aZWhuLzRad3cySkdlbnVaKzRpeEswWDY5di9icDI1U1dsQT0KPS9yc2wKLS0tLS1FTkQgUEdQIE1FU1NBR0UtLS0tLQo=" "~/.netrc")
(defun auth-source-epa-extract-gpg-token (secret file)
  "Pass either the decoded SECRET or the gpg:BASE64DATA version.
FILE is the file from which we obtained this token."
  (when (string-match "^gpg:\\(.+\\)" secret)
    (setq secret (base64-decode-string (match-string 1 secret))))
  (let ((context (epg-make-context 'OpenPGP))
        plain)
    (epg-context-set-passphrase-callback
     context
     (cons #'auth-source-token-passphrase-callback-function
           file))
    (epg-decrypt-string context secret)))

;; (insert (auth-source-epa-make-gpg-token "mysecret" "~/.netrc"))
1146
(defun auth-source-epa-make-gpg-token (secret file)
1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161
  (let ((context (epg-make-context 'OpenPGP))
        (pp-escape-newlines nil)
        cipher)
    (epg-context-set-armor context t)
    (epg-context-set-passphrase-callback
     context
     (cons #'auth-source-token-passphrase-callback-function
           file))
    (setq cipher (epg-encrypt-string context secret nil))
    (with-temp-buffer
      (insert cipher)
      (base64-encode-region (point-min) (point-max) t)
      (concat "gpg:" (buffer-substring-no-properties
                      (point-min)
                      (point-max))))))