/mandos/trunk

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/trunk

« back to all changes in this revision

Viewing changes to mandos-keygen

  • Committer: Teddy Hogeborn
  • Date: 2024-11-17 18:43:11 UTC
  • Revision ID: teddy@recompile.se-20241117184311-ox25kvngy62h209g
Debian package: Avoid suggesting a C compiler unnecessarily

The list of suggested packages, meant to enable the "mandos" program
to find the correct value of SO_BINDTODEVICE by using a C compiler,
are not necessary when Python 3.3 or later is used, since it has the
SO_BINDTODEVICE constant defined in the "socket" module.  Also, Python
2.6 or older has the same constant in the old "IN" module.  Therefore,
we should suggest these Python versions as alternatives to a C
compiler, so that a C compiler is not installed unnecessarily.

debian/control (Package: mandos/Suggests): Add "python3 (>= 3.3)" and
"python (<= 2.6)" as alternatives to "libc6-dev | libc-dev" and
"c-compiler".

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos-keygen
1
1
#!/bin/sh -e
2
2
# 
3
 
# Mandos key generator - create a new OpenPGP key for a Mandos client
4
 
# 
5
 
# Copyright © 2008-2014 Teddy Hogeborn
6
 
# Copyright © 2008-2014 Björn Påhlsson
7
 
# 
8
 
# This program is free software: you can redistribute it and/or modify
9
 
# it under the terms of the GNU General Public License as published by
 
3
# Mandos key generator - create new keys for a Mandos client
 
4
# 
 
5
# Copyright © 2008-2019 Teddy Hogeborn
 
6
# Copyright © 2008-2019 Björn Påhlsson
 
7
# 
 
8
# This file is part of Mandos.
 
9
#
 
10
# Mandos is free software: you can redistribute it and/or modify it
 
11
# under the terms of the GNU General Public License as published by
10
12
# the Free Software Foundation, either version 3 of the License, or
11
13
# (at your option) any later version.
12
14
#
13
 
#     This program is distributed in the hope that it will be useful,
14
 
#     but WITHOUT ANY WARRANTY; without even the implied warranty of
 
15
#     Mandos is distributed in the hope that it will be useful, but
 
16
#     WITHOUT ANY WARRANTY; without even the implied warranty of
15
17
#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
18
#     GNU General Public License for more details.
17
19
# 
18
20
# You should have received a copy of the GNU General Public License
19
 
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
21
# along with Mandos.  If not, see <http://www.gnu.org/licenses/>.
20
22
# 
21
23
# Contact the authors at <mandos@recompile.se>.
22
24
# 
23
25
 
24
 
VERSION="1.6.5"
 
26
VERSION="1.8.17"
25
27
 
26
28
KEYDIR="/etc/keys/mandos"
27
29
KEYTYPE=RSA
32
34
KEYEMAIL=""
33
35
KEYCOMMENT=""
34
36
KEYEXPIRE=0
 
37
TLS_KEYTYPE=ed25519
35
38
FORCE=no
 
39
SSH=yes
36
40
KEYCOMMENT_ORIG="$KEYCOMMENT"
37
41
mode=keygen
38
42
 
41
45
fi
42
46
 
43
47
# Parse options
44
 
TEMP=`getopt --options vhpF:d:t:l:s:L:n:e:c:x:f \
45
 
    --longoptions version,help,password,passfile:,dir:,type:,length:,subtype:,sublength:,name:,email:,comment:,expire:,force \
 
48
TEMP=`getopt --options vhpF:d:t:l:s:L:n:e:c:x:T:fS \
 
49
    --longoptions version,help,password,passfile:,dir:,type:,length:,subtype:,sublength:,name:,email:,comment:,expire:,tls-keytype:,force,no-ssh \
46
50
    --name "$0" -- "$@"`
47
51
 
48
52
help(){
49
 
basename="`basename $0`"
 
53
basename="`basename "$0"`"
50
54
cat <<EOF
51
55
Usage: $basename [ -v | --version ]
52
56
       $basename [ -h | --help ]
60
64
  -v, --version         Show program's version number and exit
61
65
  -h, --help            Show this help message and exit
62
66
  -d DIR, --dir DIR     Target directory for key files
63
 
  -t TYPE, --type TYPE  Key type.  Default is RSA.
 
67
  -t TYPE, --type TYPE  OpenPGP key type.  Default is RSA.
64
68
  -l BITS, --length BITS
65
 
                        Key length in bits.  Default is 4096.
 
69
                        OpenPGP key length in bits.  Default is 4096.
66
70
  -s TYPE, --subtype TYPE
67
 
                        Subkey type.  Default is RSA.
 
71
                        OpenPGP subkey type.  Default is RSA.
68
72
  -L BITS, --sublength BITS
69
 
                        Subkey length in bits.  Default is 4096.
 
73
                        OpenPGP subkey length in bits.  Default 4096.
70
74
  -n NAME, --name NAME  Name of key.  Default is the FQDN.
71
75
  -e ADDRESS, --email ADDRESS
72
 
                        Email address of key.  Default is empty.
 
76
                        Email address of OpenPGP key.  Default empty.
73
77
  -c TEXT, --comment TEXT
74
 
                        Comment field for key.  The default is empty.
 
78
                        Comment field for OpenPGP key.  Default empty.
75
79
  -x TIME, --expire TIME
76
 
                        Key expire time.  Default is no expiration.
 
80
                        OpenPGP key expire time.  Default is none.
77
81
                        See gpg(1) for syntax.
 
82
  -T TYPE, --tls-keytype TYPE
 
83
                        TLS key type.  Default is ed25519.
78
84
  -f, --force           Force overwriting old key files.
79
85
 
80
86
Password creation options:
85
91
                        Encrypt a password from FILE using the key in
86
92
                        the key directory.  All options other than
87
93
                        --dir and --name are ignored.
 
94
  -S, --no-ssh          Don't get SSH key or set "checker" option.
88
95
EOF
89
96
}
90
97
 
102
109
        -e|--email) KEYEMAIL="$2"; shift 2;;
103
110
        -c|--comment) KEYCOMMENT="$2"; shift 2;;
104
111
        -x|--expire) KEYEXPIRE="$2"; shift 2;;
 
112
        -T|--tls-keytype) TLS_KEYTYPE="$2"; shift 2;;
105
113
        -f|--force) FORCE=yes; shift;;
 
114
        -S|--no-ssh) SSH=no; shift;;
106
115
        -v|--version) echo "$0 $VERSION"; exit;;
107
116
        -h|--help) help; exit;;
108
117
        --) shift; break;;
110
119
    esac
111
120
done
112
121
if [ "$#" -gt 0 ]; then
113
 
    echo "Unknown arguments: '$@'" >&2
 
122
    echo "Unknown arguments: '$*'" >&2
114
123
    exit 1
115
124
fi
116
125
 
117
126
SECKEYFILE="$KEYDIR/seckey.txt"
118
127
PUBKEYFILE="$KEYDIR/pubkey.txt"
 
128
TLS_PRIVKEYFILE="$KEYDIR/tls-privkey.pem"
 
129
TLS_PUBKEYFILE="$KEYDIR/tls-pubkey.pem"
119
130
 
120
131
# Check for some invalid values
121
132
if [ ! -d "$KEYDIR" ]; then
136
147
        echo "Empty key type" >&2
137
148
        exit 1
138
149
    fi
139
 
    
 
150
 
140
151
    if [ -z "$KEYNAME" ]; then
141
152
        echo "Empty key name" >&2
142
153
        exit 1
143
154
    fi
144
 
    
 
155
 
145
156
    if [ -z "$KEYLENGTH" ] || [ "$KEYLENGTH" -lt 512 ]; then
146
157
        echo "Invalid key length" >&2
147
158
        exit 1
148
159
    fi
149
 
    
 
160
 
150
161
    if [ -z "$KEYEXPIRE" ]; then
151
162
        echo "Empty key expiration" >&2
152
163
        exit 1
153
164
    fi
154
 
    
 
165
 
155
166
    # Make FORCE be 0 or 1
156
167
    case "$FORCE" in
157
168
        [Yy][Ee][Ss]|[Tt][Rr][Uu][Ee]) FORCE=1;;
158
169
        [Nn][Oo]|[Ff][Aa][Ll][Ss][Ee]|*) FORCE=0;;
159
170
    esac
160
 
    
161
 
    if [ \( -e "$SECKEYFILE" -o -e "$PUBKEYFILE" \) \
162
 
        -a "$FORCE" -eq 0 ]; then
 
171
 
 
172
    if { [ -e "$SECKEYFILE" ] || [ -e "$PUBKEYFILE" ] \
 
173
             || [ -e "$TLS_PRIVKEYFILE" ] \
 
174
             || [ -e "$TLS_PUBKEYFILE" ]; } \
 
175
        && [ "$FORCE" -eq 0 ]; then
163
176
        echo "Refusing to overwrite old key files; use --force" >&2
164
177
        exit 1
165
178
    fi
166
 
    
 
179
 
167
180
    # Set lines for GnuPG batch file
168
181
    if [ -n "$KEYCOMMENT" ]; then
169
182
        KEYCOMMENTLINE="Name-Comment: $KEYCOMMENT"
171
184
    if [ -n "$KEYEMAIL" ]; then
172
185
        KEYEMAILLINE="Name-Email: $KEYEMAIL"
173
186
    fi
174
 
    
 
187
 
175
188
    # Create temporary gpg batch file
176
189
    BATCHFILE="`mktemp -t mandos-keygen-batch.XXXXXXXXXX`"
 
190
    TLS_PRIVKEYTMP="`mktemp -t mandos-keygen-privkey.XXXXXXXXXX`"
177
191
fi
178
192
 
179
193
if [ "$mode" = password ]; then
188
202
trap "
189
203
set +e; \
190
204
test -n \"$SECFILE\" && shred --remove \"$SECFILE\"; \
191
 
shred --remove \"$RINGDIR\"/sec*;
 
205
test -n \"$TLS_PRIVKEYTMP\" && shred --remove \"$TLS_PRIVKEYTMP\"; \
 
206
shred --remove \"$RINGDIR\"/sec* 2>/dev/null;
192
207
test -n \"$BATCHFILE\" && rm --force \"$BATCHFILE\"; \
193
208
rm --recursive --force \"$RINGDIR\";
194
209
tty --quiet && stty echo; \
215
230
        #Handle: <no-spaces>
216
231
        #%pubring pubring.gpg
217
232
        #%secring secring.gpg
 
233
        %no-protection
218
234
        %commit
219
235
        EOF
220
 
    
 
236
 
221
237
    if tty --quiet; then
222
238
        cat <<-EOF
223
239
        Note: Due to entropy requirements, key generation could take
227
243
        echo -n "Started: "
228
244
        date
229
245
    fi
230
 
    
 
246
 
 
247
    # Generate TLS private key
 
248
    if certtool --generate-privkey --password='' \
 
249
                --outfile "$TLS_PRIVKEYTMP" --sec-param ultra \
 
250
                --key-type="$TLS_KEYTYPE" --pkcs8 --no-text 2>/dev/null; then
 
251
        
 
252
        # Backup any old key files
 
253
        if cp --backup=numbered --force "$TLS_PRIVKEYFILE" "$TLS_PRIVKEYFILE" \
 
254
              2>/dev/null; then
 
255
            shred --remove "$TLS_PRIVKEYFILE" 2>/dev/null || :
 
256
        fi
 
257
        if cp --backup=numbered --force "$TLS_PUBKEYFILE" "$TLS_PUBKEYFILE" \
 
258
              2>/dev/null; then
 
259
            rm --force "$TLS_PUBKEYFILE"
 
260
        fi
 
261
        cp --archive "$TLS_PRIVKEYTMP" "$TLS_PRIVKEYFILE"
 
262
        shred --remove "$TLS_PRIVKEYTMP" 2>/dev/null || :
 
263
 
 
264
        ## TLS public key
 
265
 
 
266
        # First try certtool from GnuTLS
 
267
        if ! certtool --password='' --load-privkey="$TLS_PRIVKEYFILE" \
 
268
             --outfile="$TLS_PUBKEYFILE" --pubkey-info --no-text \
 
269
             2>/dev/null; then
 
270
            # Otherwise try OpenSSL
 
271
            if ! openssl pkey -in "$TLS_PRIVKEYFILE" \
 
272
                 -out "$TLS_PUBKEYFILE" -pubout; then
 
273
                rm --force "$TLS_PUBKEYFILE"
 
274
                # None of the commands succeded; give up
 
275
                return 1
 
276
            fi
 
277
        fi
 
278
    fi
 
279
 
231
280
    # Make sure trustdb.gpg exists;
232
281
    # this is a workaround for Debian bug #737128
233
282
    gpg --quiet --batch --no-tty --no-options --enable-dsa2 \
238
287
        --homedir "$RINGDIR" --trust-model always \
239
288
        --gen-key "$BATCHFILE"
240
289
    rm --force "$BATCHFILE"
241
 
    
 
290
 
242
291
    if tty --quiet; then
243
292
        echo -n "Finished: "
244
293
        date
245
294
    fi
246
 
    
 
295
 
247
296
    # Backup any old key files
248
297
    if cp --backup=numbered --force "$SECKEYFILE" "$SECKEYFILE" \
249
298
        2>/dev/null; then
250
 
        shred --remove "$SECKEYFILE"
 
299
        shred --remove "$SECKEYFILE" 2>/dev/null || :
251
300
    fi
252
301
    if cp --backup=numbered --force "$PUBKEYFILE" "$PUBKEYFILE" \
253
302
        2>/dev/null; then
254
303
        rm --force "$PUBKEYFILE"
255
304
    fi
256
 
    
 
305
 
257
306
    FILECOMMENT="Mandos client key for $KEYNAME"
258
307
    if [ "$KEYCOMMENT" != "$KEYCOMMENT_ORIG" ]; then
259
308
        FILECOMMENT="$FILECOMMENT ($KEYCOMMENT)"
260
309
    fi
261
 
    
 
310
 
262
311
    if [ -n "$KEYEMAIL" ]; then
263
312
        FILECOMMENT="$FILECOMMENT <$KEYEMAIL>"
264
313
    fi
265
 
    
 
314
 
266
315
    # Export key from key rings to key files
267
316
    gpg --quiet --batch --no-tty --no-options --enable-dsa2 \
268
317
        --homedir "$RINGDIR" --armor --export-options export-minimal \
274
323
fi
275
324
 
276
325
if [ "$mode" = password ]; then
 
326
 
 
327
    # Make SSH be 0 or 1
 
328
    case "$SSH" in
 
329
        [Yy][Ee][Ss]|[Tt][Rr][Uu][Ee]) SSH=1;;
 
330
        [Nn][Oo]|[Ff][Aa][Ll][Ss][Ee]|*) SSH=0;;
 
331
    esac
 
332
 
 
333
    if [ $SSH -eq 1 ]; then
 
334
        # The -q option is new in OpenSSH 9.8
 
335
        for ssh_keyscan_quiet in "-q " ""; do
 
336
            for ssh_keytype in ecdsa-sha2-nistp256 ed25519 rsa; do
 
337
                set +e
 
338
                ssh_fingerprint="`ssh-keyscan ${ssh_keyscan_quiet}-t $ssh_keytype localhost 2>/dev/null`"
 
339
                err=$?
 
340
                set -e
 
341
                if [ $err -ne 0 ]; then
 
342
                    ssh_fingerprint=""
 
343
                    continue
 
344
                fi
 
345
                if [ -n "$ssh_fingerprint" ]; then
 
346
                    ssh_fingerprint="${ssh_fingerprint#localhost }"
 
347
                    break 2
 
348
                fi
 
349
            done
 
350
        done
 
351
    fi
 
352
 
277
353
    # Import key into temporary key rings
278
354
    gpg --quiet --batch --no-tty --no-options --enable-dsa2 \
279
355
        --homedir "$RINGDIR" --trust-model always --armor \
281
357
    gpg --quiet --batch --no-tty --no-options --enable-dsa2 \
282
358
        --homedir "$RINGDIR" --trust-model always --armor \
283
359
        --import "$PUBKEYFILE"
284
 
    
 
360
 
285
361
    # Get fingerprint of key
286
362
    FINGERPRINT="`gpg --quiet --batch --no-tty --no-options \
287
 
        --enable-dsa2 --homedir \"$RINGDIR\" --trust-model always \
 
363
        --enable-dsa2 --homedir "$RINGDIR" --trust-model always \
288
364
        --fingerprint --with-colons \
289
365
        | sed --quiet \
290
366
        --expression='/^fpr:/{s/^fpr:.*:\\([0-9A-Z]*\\):\$/\\1/p;q}'`"
291
 
    
 
367
 
292
368
    test -n "$FINGERPRINT"
293
 
    
 
369
 
 
370
    if [ -r "$TLS_PUBKEYFILE" ]; then
 
371
       KEY_ID="$(certtool --key-id --hash=sha256 \
 
372
                       --infile="$TLS_PUBKEYFILE" 2>/dev/null || :)"
 
373
 
 
374
       if [ -z "$KEY_ID" ]; then
 
375
           KEY_ID=$(openssl pkey -pubin -in "$TLS_PUBKEYFILE" \
 
376
                            -outform der \
 
377
                        | openssl sha256 \
 
378
                        | sed --expression='s/^.*[^[:xdigit:]]//')
 
379
       fi
 
380
       test -n "$KEY_ID"
 
381
    fi
 
382
 
294
383
    FILECOMMENT="Encrypted password for a Mandos client"
295
 
    
 
384
 
296
385
    while [ ! -s "$SECFILE" ]; do
297
386
        if [ -n "$PASSFILE" ]; then
298
 
            cat "$PASSFILE"
 
387
            cat -- "$PASSFILE"
299
388
        else
300
389
            tty --quiet && stty -echo
301
 
            echo -n "Enter passphrase: " >&2
302
 
            read first
 
390
            echo -n "Enter passphrase: " >/dev/tty
 
391
            read -r first
303
392
            tty --quiet && echo >&2
304
 
            echo -n "Repeat passphrase: " >&2
305
 
            read second
 
393
            echo -n "Repeat passphrase: " >/dev/tty
 
394
            read -r second
306
395
            if tty --quiet; then
307
396
                echo >&2
308
397
                stty echo
311
400
                echo "Passphrase mismatch" >&2
312
401
                touch "$RINGDIR"/mismatch
313
402
            else
314
 
                echo -n "$first"
 
403
                printf "%s" "$first"
315
404
            fi
316
405
        fi | gpg --quiet --batch --no-tty --no-options --enable-dsa2 \
317
406
            --homedir "$RINGDIR" --trust-model always --armor \
326
415
            fi
327
416
        fi
328
417
    done
329
 
    
 
418
 
330
419
    cat <<-EOF
331
420
        [$KEYNAME]
332
421
        host = $KEYNAME
 
422
        EOF
 
423
    if [ -n "$KEY_ID" ]; then
 
424
        echo "key_id = $KEY_ID"
 
425
    fi
 
426
    cat <<-EOF
333
427
        fingerprint = $FINGERPRINT
334
428
        secret =
335
429
        EOF
342
436
                /^[^-]/s/^/    /p
343
437
            }
344
438
        }' < "$SECFILE"
 
439
    if [ -n "$ssh_fingerprint" ]; then
 
440
        echo 'checker = ssh-keyscan '"$ssh_keyscan_quiet"'-t '"$ssh_keytype"' %%(host)s 2>/dev/null | grep --fixed-strings --line-regexp --quiet --regexp=%%(host)s" %(ssh_fingerprint)s"'
 
441
        echo "ssh_fingerprint = ${ssh_fingerprint}"
 
442
    fi
345
443
fi
346
444
 
347
445
trap - EXIT
349
447
set +e
350
448
# Remove the password file, if any
351
449
if [ -n "$SECFILE" ]; then
352
 
    shred --remove "$SECFILE"
 
450
    shred --remove "$SECFILE" 2>/dev/null
353
451
fi
354
452
# Remove the key rings
355
 
shred --remove "$RINGDIR"/sec*
 
453
shred --remove "$RINGDIR"/sec* 2>/dev/null
356
454
rm --recursive --force "$RINGDIR"