/mandos/release

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

« back to all changes in this revision

Viewing changes to mandos-keygen

  • Committer: Teddy Hogeborn
  • Date: 2018-08-15 09:26:02 UTC
  • mto: (237.7.594 trunk)
  • mto: This revision was merged to the branch mainline in revision 368.
  • Revision ID: teddy@recompile.se-20180815092602-xoyb5s6gf8376i7u
http://bugs.debian.org/894495
mandos-client: Set system clock if necessary

* plugins.d/mandos-client.c (init_gpgme/import_key): If the system
  clock is not set, or set to january 1970, set the system clock to
  the more plausible value that is the mtime of the key file.  This is
  required by GnuPG to be able to import the keys.  (We can't pass the
  --ignore-time-conflict or the --ignore-valid-from options though
  GPGME.)

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos-keygen
 
1
#!/bin/sh -e
 
2
# 
 
3
# Mandos key generator - create a new OpenPGP key for a Mandos client
 
4
# 
 
5
# Copyright © 2008-2018 Teddy Hogeborn
 
6
# Copyright © 2008-2018 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
 
12
# the Free Software Foundation, either version 3 of the License, or
 
13
# (at your option) any later version.
 
14
#
 
15
#     Mandos is distributed in the hope that it will be useful, but
 
16
#     WITHOUT ANY WARRANTY; without even the implied warranty of
 
17
#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
18
#     GNU General Public License for more details.
 
19
# 
 
20
# You should have received a copy of the GNU General Public License
 
21
# along with Mandos.  If not, see <http://www.gnu.org/licenses/>.
 
22
# 
 
23
# Contact the authors at <mandos@recompile.se>.
 
24
# 
 
25
 
 
26
VERSION="1.7.19"
 
27
 
 
28
KEYDIR="/etc/keys/mandos"
 
29
KEYTYPE=RSA
 
30
KEYLENGTH=4096
 
31
SUBKEYTYPE=RSA
 
32
SUBKEYLENGTH=4096
 
33
KEYNAME="`hostname --fqdn 2>/dev/null || hostname`"
 
34
KEYEMAIL=""
 
35
KEYCOMMENT=""
 
36
KEYEXPIRE=0
 
37
FORCE=no
 
38
SSH=yes
 
39
KEYCOMMENT_ORIG="$KEYCOMMENT"
 
40
mode=keygen
 
41
 
 
42
if [ ! -d "$KEYDIR" ]; then
 
43
    KEYDIR="/etc/mandos/keys"
 
44
fi
 
45
 
 
46
# Parse options
 
47
TEMP=`getopt --options vhpF:d:t:l:s:L:n:e:c:x:fS \
 
48
    --longoptions version,help,password,passfile:,dir:,type:,length:,subtype:,sublength:,name:,email:,comment:,expire:,force,no-ssh \
 
49
    --name "$0" -- "$@"`
 
50
 
 
51
help(){
 
52
basename="`basename "$0"`"
 
53
cat <<EOF
 
54
Usage: $basename [ -v | --version ]
 
55
       $basename [ -h | --help ]
 
56
   Key creation:
 
57
       $basename [ OPTIONS ]
 
58
   Encrypted password creation:
 
59
       $basename { -p | --password } [ --name NAME ] [ --dir DIR]
 
60
       $basename { -F | --passfile } FILE [ --name NAME ] [ --dir DIR]
 
61
 
 
62
Key creation options:
 
63
  -v, --version         Show program's version number and exit
 
64
  -h, --help            Show this help message and exit
 
65
  -d DIR, --dir DIR     Target directory for key files
 
66
  -t TYPE, --type TYPE  Key type.  Default is RSA.
 
67
  -l BITS, --length BITS
 
68
                        Key length in bits.  Default is 4096.
 
69
  -s TYPE, --subtype TYPE
 
70
                        Subkey type.  Default is RSA.
 
71
  -L BITS, --sublength BITS
 
72
                        Subkey length in bits.  Default is 4096.
 
73
  -n NAME, --name NAME  Name of key.  Default is the FQDN.
 
74
  -e ADDRESS, --email ADDRESS
 
75
                        Email address of key.  Default is empty.
 
76
  -c TEXT, --comment TEXT
 
77
                        Comment field for key.  The default is empty.
 
78
  -x TIME, --expire TIME
 
79
                        Key expire time.  Default is no expiration.
 
80
                        See gpg(1) for syntax.
 
81
  -f, --force           Force overwriting old key files.
 
82
 
 
83
Password creation options:
 
84
  -p, --password        Create an encrypted password using the key in
 
85
                        the key directory.  All options other than
 
86
                        --dir and --name are ignored.
 
87
  -F FILE, --passfile FILE
 
88
                        Encrypt a password from FILE using the key in
 
89
                        the key directory.  All options other than
 
90
                        --dir and --name are ignored.
 
91
  -S, --no-ssh          Don't get SSH key or set "checker" option.
 
92
EOF
 
93
}
 
94
 
 
95
eval set -- "$TEMP"
 
96
while :; do
 
97
    case "$1" in
 
98
        -p|--password) mode=password; shift;;
 
99
        -F|--passfile) mode=password; PASSFILE="$2"; shift 2;;
 
100
        -d|--dir) KEYDIR="$2"; shift 2;;
 
101
        -t|--type) KEYTYPE="$2"; shift 2;;
 
102
        -s|--subtype) SUBKEYTYPE="$2"; shift 2;;
 
103
        -l|--length) KEYLENGTH="$2"; shift 2;;
 
104
        -L|--sublength) SUBKEYLENGTH="$2"; shift 2;;
 
105
        -n|--name) KEYNAME="$2"; shift 2;;
 
106
        -e|--email) KEYEMAIL="$2"; shift 2;;
 
107
        -c|--comment) KEYCOMMENT="$2"; shift 2;;
 
108
        -x|--expire) KEYEXPIRE="$2"; shift 2;;
 
109
        -f|--force) FORCE=yes; shift;;
 
110
        -S|--no-ssh) SSH=no; shift;;
 
111
        -v|--version) echo "$0 $VERSION"; exit;;
 
112
        -h|--help) help; exit;;
 
113
        --) shift; break;;
 
114
        *) echo "Internal error" >&2; exit 1;;
 
115
    esac
 
116
done
 
117
if [ "$#" -gt 0 ]; then
 
118
    echo "Unknown arguments: '$*'" >&2
 
119
    exit 1
 
120
fi
 
121
 
 
122
SECKEYFILE="$KEYDIR/seckey.txt"
 
123
PUBKEYFILE="$KEYDIR/pubkey.txt"
 
124
 
 
125
# Check for some invalid values
 
126
if [ ! -d "$KEYDIR" ]; then
 
127
    echo "$KEYDIR not a directory" >&2
 
128
    exit 1
 
129
fi
 
130
if [ ! -r "$KEYDIR" ]; then
 
131
    echo "Directory $KEYDIR not readable" >&2
 
132
    exit 1
 
133
fi
 
134
 
 
135
if [ "$mode" = keygen ]; then
 
136
    if [ ! -w "$KEYDIR" ]; then
 
137
        echo "Directory $KEYDIR not writeable" >&2
 
138
        exit 1
 
139
    fi
 
140
    if [ -z "$KEYTYPE" ]; then
 
141
        echo "Empty key type" >&2
 
142
        exit 1
 
143
    fi
 
144
    
 
145
    if [ -z "$KEYNAME" ]; then
 
146
        echo "Empty key name" >&2
 
147
        exit 1
 
148
    fi
 
149
    
 
150
    if [ -z "$KEYLENGTH" ] || [ "$KEYLENGTH" -lt 512 ]; then
 
151
        echo "Invalid key length" >&2
 
152
        exit 1
 
153
    fi
 
154
    
 
155
    if [ -z "$KEYEXPIRE" ]; then
 
156
        echo "Empty key expiration" >&2
 
157
        exit 1
 
158
    fi
 
159
    
 
160
    # Make FORCE be 0 or 1
 
161
    case "$FORCE" in
 
162
        [Yy][Ee][Ss]|[Tt][Rr][Uu][Ee]) FORCE=1;;
 
163
        [Nn][Oo]|[Ff][Aa][Ll][Ss][Ee]|*) FORCE=0;;
 
164
    esac
 
165
    
 
166
    if { [ -e "$SECKEYFILE" ] || [ -e "$PUBKEYFILE" ]; } \
 
167
        && [ "$FORCE" -eq 0 ]; then
 
168
        echo "Refusing to overwrite old key files; use --force" >&2
 
169
        exit 1
 
170
    fi
 
171
    
 
172
    # Set lines for GnuPG batch file
 
173
    if [ -n "$KEYCOMMENT" ]; then
 
174
        KEYCOMMENTLINE="Name-Comment: $KEYCOMMENT"
 
175
    fi
 
176
    if [ -n "$KEYEMAIL" ]; then
 
177
        KEYEMAILLINE="Name-Email: $KEYEMAIL"
 
178
    fi
 
179
    
 
180
    # Create temporary gpg batch file
 
181
    BATCHFILE="`mktemp -t mandos-keygen-batch.XXXXXXXXXX`"
 
182
fi
 
183
 
 
184
if [ "$mode" = password ]; then
 
185
    # Create temporary encrypted password file
 
186
    SECFILE="`mktemp -t mandos-keygen-secfile.XXXXXXXXXX`"
 
187
fi
 
188
 
 
189
# Create temporary key ring directory
 
190
RINGDIR="`mktemp -d -t mandos-keygen-keyrings.XXXXXXXXXX`"
 
191
 
 
192
# Remove temporary files on exit
 
193
trap "
 
194
set +e; \
 
195
test -n \"$SECFILE\" && shred --remove \"$SECFILE\"; \
 
196
shred --remove \"$RINGDIR\"/sec* 2>/dev/null;
 
197
test -n \"$BATCHFILE\" && rm --force \"$BATCHFILE\"; \
 
198
rm --recursive --force \"$RINGDIR\";
 
199
tty --quiet && stty echo; \
 
200
" EXIT
 
201
 
 
202
set -e
 
203
 
 
204
umask 077
 
205
 
 
206
if [ "$mode" = keygen ]; then
 
207
    # Create batch file for GnuPG
 
208
    cat >"$BATCHFILE" <<-EOF
 
209
        Key-Type: $KEYTYPE
 
210
        Key-Length: $KEYLENGTH
 
211
        Key-Usage: sign,auth
 
212
        Subkey-Type: $SUBKEYTYPE
 
213
        Subkey-Length: $SUBKEYLENGTH
 
214
        Subkey-Usage: encrypt
 
215
        Name-Real: $KEYNAME
 
216
        $KEYCOMMENTLINE
 
217
        $KEYEMAILLINE
 
218
        Expire-Date: $KEYEXPIRE
 
219
        #Preferences: <string>
 
220
        #Handle: <no-spaces>
 
221
        #%pubring pubring.gpg
 
222
        #%secring secring.gpg
 
223
        %no-protection
 
224
        %commit
 
225
        EOF
 
226
    
 
227
    if tty --quiet; then
 
228
        cat <<-EOF
 
229
        Note: Due to entropy requirements, key generation could take
 
230
        anything from a few minutes to SEVERAL HOURS.  Please be
 
231
        patient and/or supply the system with more entropy if needed.
 
232
        EOF
 
233
        echo -n "Started: "
 
234
        date
 
235
    fi
 
236
    
 
237
    # Make sure trustdb.gpg exists;
 
238
    # this is a workaround for Debian bug #737128
 
239
    gpg --quiet --batch --no-tty --no-options --enable-dsa2 \
 
240
        --homedir "$RINGDIR" \
 
241
        --import-ownertrust < /dev/null
 
242
    # Generate a new key in the key rings
 
243
    gpg --quiet --batch --no-tty --no-options --enable-dsa2 \
 
244
        --homedir "$RINGDIR" --trust-model always \
 
245
        --gen-key "$BATCHFILE"
 
246
    rm --force "$BATCHFILE"
 
247
    
 
248
    if tty --quiet; then
 
249
        echo -n "Finished: "
 
250
        date
 
251
    fi
 
252
    
 
253
    # Backup any old key files
 
254
    if cp --backup=numbered --force "$SECKEYFILE" "$SECKEYFILE" \
 
255
        2>/dev/null; then
 
256
        shred --remove "$SECKEYFILE"
 
257
    fi
 
258
    if cp --backup=numbered --force "$PUBKEYFILE" "$PUBKEYFILE" \
 
259
        2>/dev/null; then
 
260
        rm --force "$PUBKEYFILE"
 
261
    fi
 
262
    
 
263
    FILECOMMENT="Mandos client key for $KEYNAME"
 
264
    if [ "$KEYCOMMENT" != "$KEYCOMMENT_ORIG" ]; then
 
265
        FILECOMMENT="$FILECOMMENT ($KEYCOMMENT)"
 
266
    fi
 
267
    
 
268
    if [ -n "$KEYEMAIL" ]; then
 
269
        FILECOMMENT="$FILECOMMENT <$KEYEMAIL>"
 
270
    fi
 
271
    
 
272
    # Export key from key rings to key files
 
273
    gpg --quiet --batch --no-tty --no-options --enable-dsa2 \
 
274
        --homedir "$RINGDIR" --armor --export-options export-minimal \
 
275
        --comment "$FILECOMMENT" --output "$SECKEYFILE" \
 
276
        --export-secret-keys
 
277
    gpg --quiet --batch --no-tty --no-options --enable-dsa2 \
 
278
        --homedir "$RINGDIR" --armor --export-options export-minimal \
 
279
        --comment "$FILECOMMENT" --output "$PUBKEYFILE" --export
 
280
fi
 
281
 
 
282
if [ "$mode" = password ]; then
 
283
    
 
284
    # Make SSH be 0 or 1
 
285
    case "$SSH" in
 
286
        [Yy][Ee][Ss]|[Tt][Rr][Uu][Ee]) SSH=1;;
 
287
        [Nn][Oo]|[Ff][Aa][Ll][Ss][Ee]|*) SSH=0;;
 
288
    esac
 
289
    
 
290
    if [ $SSH -eq 1 ]; then
 
291
        for ssh_keytype in ecdsa-sha2-nistp256 ed25519 rsa; do
 
292
            set +e
 
293
            ssh_fingerprint="`ssh-keyscan -t $ssh_keytype localhost 2>/dev/null`"
 
294
            err=$?
 
295
            set -e
 
296
            if [ $err -ne 0 ]; then
 
297
                ssh_fingerprint=""
 
298
                continue
 
299
            fi
 
300
            if [ -n "$ssh_fingerprint" ]; then
 
301
                ssh_fingerprint="${ssh_fingerprint#localhost }"
 
302
                break
 
303
            fi
 
304
        done
 
305
    fi
 
306
    
 
307
    # Import key into temporary key rings
 
308
    gpg --quiet --batch --no-tty --no-options --enable-dsa2 \
 
309
        --homedir "$RINGDIR" --trust-model always --armor \
 
310
        --import "$SECKEYFILE"
 
311
    gpg --quiet --batch --no-tty --no-options --enable-dsa2 \
 
312
        --homedir "$RINGDIR" --trust-model always --armor \
 
313
        --import "$PUBKEYFILE"
 
314
    
 
315
    # Get fingerprint of key
 
316
    FINGERPRINT="`gpg --quiet --batch --no-tty --no-options \
 
317
        --enable-dsa2 --homedir "$RINGDIR" --trust-model always \
 
318
        --fingerprint --with-colons \
 
319
        | sed --quiet \
 
320
        --expression='/^fpr:/{s/^fpr:.*:\\([0-9A-Z]*\\):\$/\\1/p;q}'`"
 
321
    
 
322
    test -n "$FINGERPRINT"
 
323
    
 
324
    FILECOMMENT="Encrypted password for a Mandos client"
 
325
    
 
326
    while [ ! -s "$SECFILE" ]; do
 
327
        if [ -n "$PASSFILE" ]; then
 
328
            cat "$PASSFILE"
 
329
        else
 
330
            tty --quiet && stty -echo
 
331
            echo -n "Enter passphrase: " >/dev/tty
 
332
            read -r first
 
333
            tty --quiet && echo >&2
 
334
            echo -n "Repeat passphrase: " >/dev/tty
 
335
            read -r second
 
336
            if tty --quiet; then
 
337
                echo >&2
 
338
                stty echo
 
339
            fi
 
340
            if [ "$first" != "$second" ]; then
 
341
                echo "Passphrase mismatch" >&2
 
342
                touch "$RINGDIR"/mismatch
 
343
            else
 
344
                echo -n "$first"
 
345
            fi
 
346
        fi | gpg --quiet --batch --no-tty --no-options --enable-dsa2 \
 
347
            --homedir "$RINGDIR" --trust-model always --armor \
 
348
            --encrypt --sign --recipient "$FINGERPRINT" --comment \
 
349
            "$FILECOMMENT" > "$SECFILE"
 
350
        if [ -e "$RINGDIR"/mismatch ]; then
 
351
            rm --force "$RINGDIR"/mismatch
 
352
            if tty --quiet; then
 
353
                > "$SECFILE"
 
354
            else
 
355
                exit 1
 
356
            fi
 
357
        fi
 
358
    done
 
359
    
 
360
    cat <<-EOF
 
361
        [$KEYNAME]
 
362
        host = $KEYNAME
 
363
        fingerprint = $FINGERPRINT
 
364
        secret =
 
365
        EOF
 
366
    sed --quiet --expression='
 
367
        /^-----BEGIN PGP MESSAGE-----$/,/^-----END PGP MESSAGE-----$/{
 
368
            /^$/,${
 
369
                # Remove 24-bit Radix-64 checksum
 
370
                s/=....$//
 
371
                # Indent four spaces
 
372
                /^[^-]/s/^/    /p
 
373
            }
 
374
        }' < "$SECFILE"
 
375
    if [ -n "$ssh_fingerprint" ]; then
 
376
        echo 'checker = ssh-keyscan -t '"$ssh_keytype"' %%(host)s 2>/dev/null | grep --fixed-strings --line-regexp --quiet --regexp=%%(host)s" %(ssh_fingerprint)s"'
 
377
        echo "ssh_fingerprint = ${ssh_fingerprint}"
 
378
    fi
 
379
fi
 
380
 
 
381
trap - EXIT
 
382
 
 
383
set +e
 
384
# Remove the password file, if any
 
385
if [ -n "$SECFILE" ]; then
 
386
    shred --remove "$SECFILE"
 
387
fi
 
388
# Remove the key rings
 
389
shred --remove "$RINGDIR"/sec* 2>/dev/null
 
390
rm --recursive --force "$RINGDIR"