all messages for Guix-related lists mirrored at yhetil.org
 help / color / mirror / code / Atom feed
blob d81a0e1ffb4a4706d7fdd45d21ad446b6eafdffd 11321 bytes (raw)
name: guix/scripts/git/authenticate.scm 	 # note: path name is non-authoritative(*)

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
 
;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2020, 2024 Ludovic Courtès <ludo@gnu.org>
;;;
;;; This file is part of GNU Guix.
;;;
;;; GNU Guix is free software; you can redistribute it and/or modify it
;;; under the terms of the GNU General Public License as published by
;;; the Free Software Foundation; either version 3 of the License, or (at
;;; your option) any later version.
;;;
;;; GNU Guix is distributed in the hope that it will be useful, but
;;; WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;;; GNU General Public License for more details.
;;;
;;; You should have received a copy of the GNU General Public License
;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.

(define-module (guix scripts git authenticate)
  #:use-module (git)
  #:use-module (guix ui)
  #:use-module (guix scripts)
  #:use-module (guix git-authenticate)
  #:autoload   (guix openpgp) (openpgp-format-fingerprint
                               openpgp-public-key-fingerprint)
  #:use-module ((guix channels) #:select (openpgp-fingerprint))
  #:use-module ((guix git) #:select (with-git-error-handling))
  #:use-module (guix progress)
  #:use-module (guix base64)
  #:autoload   (rnrs bytevectors) (bytevector-length)
  #:use-module (srfi srfi-1)
  #:use-module (srfi srfi-26)
  #:use-module (srfi srfi-37)
  #:use-module (srfi srfi-71)
  #:use-module (ice-9 format)
  #:use-module (ice-9 match)
  #:export (guix-git-authenticate))

;;; Commentary:
;;;
;;; Authenticate a Git checkout by reading '.guix-authorizations' files and
;;; following the "authorizations invariant" also used by (guix channels).
;;;
;;; Code:

(define %options
  ;; Specifications of the command-line options.
  (list (option '(#\h "help") #f #f
                (lambda args
                  (show-help)
                  (exit 0)))
        (option '(#\V "version") #f #f
                (lambda args
                  (show-version-and-exit "guix git authenticate")))

        (option '(#\r "repository") #t #f
                (lambda (opt name arg result)
                  (alist-cons 'directory arg result)))
        (option '(#\e "end") #t #f
                (lambda (opt name arg result)
                  (alist-cons 'end-commit (string->oid arg) result)))
        (option '(#\k "keyring") #t #f
                (lambda (opt name arg result)
                  (alist-cons 'keyring-reference arg result)))
        (option '("cache-key") #t #f
                (lambda (opt name arg result)
                  (alist-cons 'cache-key arg result)))
        (option '("historical-authorizations") #t #f
                (lambda (opt name arg result)
                  (alist-cons 'historical-authorizations arg
                              result)))
        (option '("stats") #f #f
                (lambda (opt name arg result)
                  (alist-cons 'show-stats? #t result)))))

(define %default-options
  '())

(define (current-branch repository)
  "Return the name of the checked out branch of REPOSITORY or #f if it could
not be determined."
  (and (not (repository-head-detached? repository))
       (let* ((head (repository-head repository))
              (name (reference-name head)))
         (and (string-prefix? "refs/heads/" name)
              (string-drop name (string-length "refs/heads/"))))))

(define (config-value repository key)
  "Return the config value associated with KEY in the 'guix.authentication' or
'guix.authentication-BRANCH' name space in REPOSITORY, or #f if no such config
was found."
  (let-syntax ((false-if-git-error
                (syntax-rules ()
                  ((_ exp)
                   (catch 'git-error (lambda () exp) (const #f))))))
    (let* ((config (repository-config repository))
           (branch (current-branch repository)))
      ;; First try the BRANCH-specific value, then the generic one.`
      (or (and branch
               (false-if-git-error
                (config-entry-value
                 (config-get-entry config
                                   (string-append "guix.authentication-"
                                                  branch "." key)))))
          (false-if-git-error
           (config-entry-value
            (config-get-entry config
                              (string-append "guix.authentication."
                                             key))))))))

(define (configured-introduction repository)
  "Return two values: the commit and signer fingerprint (strings) as
configured in REPOSITORY.  Error out if one or both were missing."
  (let* ((commit (config-value repository "introduction-commit"))
         (signer (config-value repository "introduction-signer")))
    (unless (and commit signer)
      (leave (G_ "unknown introductory commit and signer~%")))
    (values commit signer)))

(define (configured-keyring-reference repository)
  "Return the keyring reference configured in REPOSITORY or #f if missing."
  (config-value repository "keyring"))

(define (configured? repository)
  "Return true if REPOSITORY already container introduction info in its
'config' file."
  (and (config-value repository "introduction-commit")
       (config-value repository "introduction-signer")))

(define* (record-configuration repository
                               #:key commit signer keyring-reference)
  "Record COMMIT, SIGNER, and KEYRING-REFERENCE in the 'config' file of
REPOSITORY."
  (define config
    (repository-config repository))

  ;; Guile-Git < 0.7.0 lacks 'set-config-string'.
  (if (module-defined? (resolve-interface '(git)) 'set-config-string)
      (begin
        (set-config-string config "guix.authentication.introduction-commit"
                           commit)
        (set-config-string config "guix.authentication.introduction-signer"
                           signer)
        (set-config-string config "guix.authentication.keyring"
                           keyring-reference)
        (info (G_ "introduction and keyring recorded \
in repository configuration file~%")))
      (warning (G_ "could not record introduction and keyring configuration\
 (Guile-Git too old?)~%"))))

(define (show-stats stats)
  "Display STATS, an alist containing commit signing stats as returned by
'authenticate-repository'."
  (format #t (G_ "Signing statistics:~%"))
  (for-each (match-lambda
              ((signer . count)
               (format #t "  ~a ~10d~%"
                       (openpgp-format-fingerprint
                        (openpgp-public-key-fingerprint signer))
                       count)))
            (sort stats
                  (match-lambda*
                    (((_ . count1) (_ . count2))
                     (> count1 count2))))))

(define (show-help)
  (display (G_ "Usage: guix git authenticate COMMIT SIGNER [OPTIONS...]
Authenticate the given Git checkout using COMMIT/SIGNER as its introduction.\n"))
  (display (G_ "
  -r, --repository=DIRECTORY
                         open the Git repository at DIRECTORY"))
  (display (G_ "
  -k, --keyring=REFERENCE
                         load keyring from REFERENCE, a Git branch"))
  (display (G_ "
      --end=COMMIT       authenticate revisions up to COMMIT"))
  (display (G_ "
      --stats            display commit signing statistics upon completion"))
  (display (G_ "
      --cache-key=KEY    cache authenticated commits under KEY"))
  (display (G_ "
      --historical-authorizations=FILE
                         read historical authorizations from FILE"))
  (newline)
  (display (G_ "
  -h, --help             display this help and exit"))
  (display (G_ "
  -V, --version          display version information and exit"))
  (newline)
  (show-bug-report-information))

\f
;;;
;;; Entry point.
;;;

(define (guix-git-authenticate . args)
  (define options
    (parse-command-line args %options (list %default-options)
                        #:build-options? #f))

  (define (command-line-arguments lst)
    (reverse (filter-map (match-lambda
                           (('argument . arg) arg)
                           (_ #f))
                         lst)))

  (define commit-short-id
    (compose (cut string-take <> 7) oid->string commit-id))

  (define (openpgp-fingerprint* str)
    (unless (string-every (char-set-union char-set:hex-digit
                                          char-set:whitespace)
                          str)
      (leave (G_ "~a: invalid OpenPGP fingerprint~%") str))
    (let ((fingerprint (openpgp-fingerprint str)))
      (unless (= 20 (bytevector-length fingerprint))
        (leave (G_ "~a: wrong length for OpenPGP fingerprint~%") str))
      fingerprint))

  (define (make-reporter start-commit end-commit commits)
    (format (current-error-port)
            (G_ "Authenticating commits ~a to ~a (~h new \
commits)...~%")
            (commit-short-id start-commit)
            (commit-short-id end-commit)
            (length commits))

    (if (isatty? (current-error-port))
        (progress-reporter/bar (length commits))
        progress-reporter/silent))

  (define (missing-arguments)
    (leave (G_ "wrong number of arguments; \
expected COMMIT and SIGNER~%")))

  (with-error-handling
    (with-git-error-handling
     (let* ((show-stats? (assoc-ref options 'show-stats?))
            (repository  (repository-open (or (assoc-ref options 'directory)
                                              (repository-discover "."))))
            (commit signer (match (command-line-arguments options)
                             ((commit signer)
                              (values commit signer))
                             (()
                              (configured-introduction repository))
                             (_
                              (missing-arguments))))
            (keyring     (or (assoc-ref options 'keyring-reference)
                             (configured-keyring-reference repository)
                             "keyring"))
            (end         (match (assoc-ref options 'end-commit)
                           (#f  (reference-target
                                 (repository-head repository)))
                           (oid oid)))
            (history     (match (assoc-ref options 'historical-authorizations)
                           (#f '())
                           (file (call-with-input-file file
                                   read-authorizations))))
            (cache-key   (or (assoc-ref options 'cache-key)
                             (repository-cache-key repository))))
       (define stats
         (authenticate-repository repository (string->oid commit)
                                  (openpgp-fingerprint* signer)
                                  #:end end
                                  #:keyring-reference keyring
                                  #:historical-authorizations history
                                  #:cache-key cache-key
                                  #:make-reporter make-reporter))

       (unless (configured? repository)
         (record-configuration repository
                               #:commit commit #:signer signer
                               #:keyring-reference keyring))

       (when (and show-stats? (not (null? stats)))
         (show-stats stats))))))

debug log:

solving d81a0e1ffb ...
found d81a0e1ffb in https://git.savannah.gnu.org/cgit/guix.git

(*) Git path names are given by the tree(s) the blob belongs to.
    Blobs themselves have no identifier aside from the hash of its contents.^

Code repositories for project(s) associated with this external index

	https://git.savannah.gnu.org/cgit/guix.git

This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.