/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: 2008-12-10 01:26:02 UTC
  • mfrom: (237.1.2 mandos)
  • Revision ID: teddy@fukt.bsnet.se-20081210012602-vhz3h75xkj24t340
First version of a somewhat complete D-Bus server interface.  Also
change user/group name to "_mandos".

* debian/mandos.postinst: Rename old "mandos" user and group to
                          "_mandos"; create "_mandos" user and group
                          if none exist.
* debian/mandos-client.postinst: - '' -

* initramfs-tools-hook: Try "_mandos" before "mandos" as user and
                        group name.

* mandos (_datetime_to_dbus_struct): New; was previously local.
  (Client.started): Renamed to "last_started".  All users changed.
  (Client.started): New; boolean.
  (Client.dbus_object_path): New.
  (Client.check_command): Renamed to "checker_command".  All users
                          changed.
  (Client.__init__): Set and use "self.dbus_object_path".  Set
                     "self.started".
  (Client.start): Update "self.started".  Emit "self.PropertyChanged"
                  signals for both "started" and "last_started".
  (Client.stop): Update "self.started".  Emit "self.PropertyChanged"
                 signal for "started".
  (Client.checker_callback): Take additional "command" argument.  All
                             callers changed. Emit
                             "self.PropertyChanged" signal.
  (Client.bump_timeout): Emit "self.PropertyChanged" signal for
                         "last_checked_ok".
  (Client.start_checker): Emit "self.PropertyChanged" signal for
                          "checker_running".
  (Client.stop_checker): Emit "self.PropertyChanged" signal for
                         "checker_running".
  (Client.still_valid): Bug fix: use "getattr(self, started, False)"
                        instead of "self.started" in case this client
                        object is so new that the "started" attribute
                        has not been created yet.
  (Client.IntervalChanged, Client.CheckerIsRunning, Client.GetChecker,
  Client.GetCreated, Client.GetFingerprint, Client.GetHost,
  Client.GetInterval, Client.GetName, Client.GetStarted,
  Client.GetTimeout, Client.StateChanged, Client.TimeoutChanged):
  Removed; all callers changed.
  (Client.CheckerCompleted): Add "condition" and "command" arguments.
                             All callers changed.
  (Client.GetAllProperties, Client.PropertyChanged): New.
  (Client.StillValid): Renamed to "IsStillValid".
  (Client.StartChecker): Changed to its own function to avoid the
                         return value from "Client.start_checker()".
  (Client.Stop): Changed to its own function to avoid the return value
                 from "Client.stop()".
  (main): Try "_mandos" before "mandos" as user and group name.
          Removed inner function "remove_from_clients".  New inner
          class "MandosServer".

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos-keygen
2
2
# 
3
3
# Mandos key generator - create a new OpenPGP key for a Mandos client
4
4
# 
5
 
# Copyright © 2007-2008 Teddy Hogeborn & Björn Påhlsson
 
5
# Copyright © 2008 Teddy Hogeborn
 
6
# Copyright © 2008 Björn Påhlsson
6
7
# 
7
8
# This program is free software: you can redistribute it and/or modify
8
9
# it under the terms of the GNU General Public License as published by
20
21
# Contact the authors at <mandos@fukt.bsnet.se>.
21
22
# 
22
23
 
23
 
VERSION="1.0"
 
24
VERSION="1.0.2"
24
25
 
25
 
KEYDIR="/etc/mandos"
 
26
KEYDIR="/etc/keys/mandos"
26
27
KEYTYPE=DSA
27
28
KEYLENGTH=2048
28
29
SUBKEYTYPE=ELG-E
29
30
SUBKEYLENGTH=2048
30
 
KEYNAME="`hostname --fqdn`"
 
31
KEYNAME="`hostname --fqdn 2>/dev/null || hostname`"
31
32
KEYEMAIL=""
32
33
KEYCOMMENT="Mandos client key"
33
34
KEYEXPIRE=0
35
36
KEYCOMMENT_ORIG="$KEYCOMMENT"
36
37
mode=keygen
37
38
 
 
39
if [ ! -d "$KEYDIR" ]; then
 
40
    KEYDIR="/etc/mandos/keys"
 
41
fi
 
42
 
38
43
# Parse options
39
 
TEMP=`getopt --options vhd:t:l:n:e:c:x:f \
40
 
    --longoptions version,help,password,dir:,type:,length:,subtype:,sublength:,name:,email:,comment:,expire:,force \
 
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 \
41
46
    --name "$0" -- "$@"`
42
47
 
43
48
help(){
49
54
       $basename [ OPTIONS ]
50
55
   Encrypted password creation:
51
56
       $basename { -p | --password } [ --name NAME ] [ --dir DIR]
 
57
       $basename { -F | --passfile } FILE [ --name NAME ] [ --dir DIR]
52
58
 
53
59
Key creation options:
54
60
  -v, --version         Show program's version number and exit
64
70
  -n NAME, --name NAME  Name of key.  Default is the FQDN.
65
71
  -e ADDRESS, --email ADDRESS
66
72
                        Email address of key.  Default is empty.
67
 
  -c COMMENT, --comment COMMENT
 
73
  -c TEXT, --comment TEXT
68
74
                        Comment field for key.  The default value is
69
75
                        "Mandos client key".
70
76
  -x TIME, --expire TIME
71
77
                        Key expire time.  Default is no expiration.
72
78
                        See gpg(1) for syntax.
73
 
  -f, --force           Force overwriting old keys.
 
79
  -f, --force           Force overwriting old key files.
74
80
 
75
81
Password creation options:
76
 
  -p, --password        Create an encrypted password using the keys in
77
 
                        the key directory.  All options other than
78
 
                        --keydir and --name are ignored.
 
82
  -p, --password        Create an encrypted password using the key in
 
83
                        the key directory.  All options other than
 
84
                        --dir and --name are ignored.
 
85
  -F FILE, --passfile FILE
 
86
                        Encrypt a password from FILE using the key in
 
87
                        the key directory.  All options other than
 
88
                        --dir and --name are ignored.
79
89
EOF
80
90
}
81
91
 
83
93
while :; do
84
94
    case "$1" in
85
95
        -p|--password) mode=password; shift;;
 
96
        -F|--passfile) mode=password; PASSFILE="$2"; shift 2;;
86
97
        -d|--dir) KEYDIR="$2"; shift 2;;
87
98
        -t|--type) KEYTYPE="$2"; shift 2;;
88
99
        -s|--subtype) SUBKEYTYPE="$2"; shift 2;;
108
119
PUBKEYFILE="$KEYDIR/pubkey.txt"
109
120
 
110
121
# Check for some invalid values
111
 
if [ -d "$KEYDIR" ]; then :; else
 
122
if [ ! -d "$KEYDIR" ]; then
112
123
    echo "$KEYDIR not a directory" >&2
113
124
    exit 1
114
125
fi
115
 
if [ -w "$KEYDIR" ]; then :; else
116
 
    echo "Directory $KEYDIR not writeable" >&2
117
 
    exit 1
118
 
fi
119
 
 
120
 
if [ "$mode" = password -a -e "$KEYDIR/trustdb.gpg.lock" ]; then
121
 
    echo "Key directory has locked trustdb; aborting." >&2
 
126
if [ ! -r "$KEYDIR" ]; then
 
127
    echo "Directory $KEYDIR not readable" >&2
122
128
    exit 1
123
129
fi
124
130
 
125
131
if [ "$mode" = keygen ]; then
 
132
    if [ ! -w "$KEYDIR" ]; then
 
133
        echo "Directory $KEYDIR not writeable" >&2
 
134
        exit 1
 
135
    fi
126
136
    if [ -z "$KEYTYPE" ]; then
127
137
        echo "Empty key type" >&2
128
138
        exit 1
149
159
        [Nn][Oo]|[Ff][Aa][Ll][Ss][Ee]|*) FORCE=0;;
150
160
    esac
151
161
    
152
 
    if { [ -e "$SECKEYFILE" ] || [ -e "$PUBKEYFILE" ]; } \
153
 
        && [ "$FORCE" -eq 0 ]; then
 
162
    if [ \( -e "$SECKEYFILE" -o -e "$PUBKEYFILE" \) \
 
163
        -a "$FORCE" -eq 0 ]; then
154
164
        echo "Refusing to overwrite old key files; use --force" >&2
155
165
        exit 1
156
166
    fi
164
174
    fi
165
175
 
166
176
    # Create temporary gpg batch file
167
 
    BATCHFILE="`mktemp -t mandos-gpg-batch.XXXXXXXXXX`"
 
177
    BATCHFILE="`mktemp -t mandos-keygen-batch.XXXXXXXXXX`"
168
178
fi
169
179
 
170
180
if [ "$mode" = password ]; then
171
181
    # Create temporary encrypted password file
172
 
    SECFILE="`mktemp -t mandos-gpg-secfile.XXXXXXXXXX`"
173
 
fi
174
 
 
175
 
# Create temporary key rings
176
 
SECRING="`mktemp -t mandos-gpg-secring.XXXXXXXXXX`"
177
 
PUBRING="`mktemp -t mandos-gpg-pubring.XXXXXXXXXX`"
178
 
 
179
 
if [ "$mode" = password ]; then
180
 
    # If a trustdb.gpg file does not already exist, schedule it for
181
 
    # deletion when we are done.
182
 
    if ! [ -e "$KEYDIR/trustdb.gpg" ]; then
183
 
        TRUSTDB="$KEYDIR/trustdb.gpg"
184
 
    fi
185
 
fi
 
182
    SECFILE="`mktemp -t mandos-keygen-secfile.XXXXXXXXXX`"
 
183
fi
 
184
 
 
185
# Create temporary key ring directory
 
186
RINGDIR="`mktemp -d -t mandos-keygen-keyrings.XXXXXXXXXX`"
186
187
 
187
188
# Remove temporary files on exit
188
189
trap "
189
190
set +e; \
190
 
rm --force $PUBRING ${PUBRING}~ $BATCHFILE $TRUSTDB; \
191
 
shred --remove $SECRING $SECFILE; \
 
191
test -n \"$SECFILE\" && shred --remove \"$SECFILE\"; \
 
192
shred --remove \"$RINGDIR\"/sec*;
 
193
test -n \"$BATCHFILE\" && rm --force \"$BATCHFILE\"; \
 
194
rm --recursive --force \"$RINGDIR\";
192
195
stty echo; \
193
196
" EXIT
194
197
 
195
 
umask 027
 
198
umask 077
196
199
 
197
200
if [ "$mode" = keygen ]; then
198
201
    # Create batch file for GnuPG
209
212
        Expire-Date: $KEYEXPIRE
210
213
        #Preferences: <string>
211
214
        #Handle: <no-spaces>
212
 
        %pubring $PUBRING
213
 
        %secring $SECRING
 
215
        #%pubring pubring.gpg
 
216
        #%secring secring.gpg
214
217
        %commit
215
218
        EOF
216
219
    
217
220
    # Generate a new key in the key rings
218
 
    gpg --no-random-seed-file --quiet --batch --no-tty \
219
 
        --no-default-keyring --no-options --enable-dsa2 \
220
 
        --secret-keyring "$SECRING" --keyring "$PUBRING" \
 
221
    gpg --quiet --batch --no-tty --no-options --enable-dsa2 \
 
222
        --homedir "$RINGDIR" --trust-model always \
221
223
        --gen-key "$BATCHFILE"
222
224
    rm --force "$BATCHFILE"
223
 
 
 
225
    
224
226
    # Backup any old key files
225
227
    if cp --backup=numbered --force "$SECKEYFILE" "$SECKEYFILE" \
226
228
        2>/dev/null; then
240
242
        FILECOMMENT="$FILECOMMENT <$KEYEMAIL>"
241
243
    fi
242
244
    
243
 
    # Export keys from key rings to key files
244
 
    gpg --no-random-seed-file --quiet --batch --no-tty --armor \
245
 
        --no-default-keyring --no-options --enable-dsa2 \
246
 
        --secret-keyring "$SECRING" --keyring "$PUBRING" \
247
 
        --export-options export-minimal --comment "$FILECOMMENT" \
248
 
        --output "$SECKEYFILE" --export-secret-keys
249
 
    gpg --no-random-seed-file --quiet --batch --no-tty --armor \
250
 
        --no-default-keyring --no-options --enable-dsa2 \
251
 
        --secret-keyring "$SECRING" --keyring "$PUBRING" \
252
 
        --export-options export-minimal --comment "$FILECOMMENT" \
253
 
        --output "$PUBKEYFILE" --export
 
245
    # Export key from key rings to key files
 
246
    gpg --quiet --batch --no-tty --no-options --enable-dsa2 \
 
247
        --homedir "$RINGDIR" --armor --export-options export-minimal \
 
248
        --comment "$FILECOMMENT" --output "$SECKEYFILE" \
 
249
        --export-secret-keys
 
250
    gpg --quiet --batch --no-tty --no-options --enable-dsa2 \
 
251
        --homedir "$RINGDIR" --armor --export-options export-minimal \
 
252
        --comment "$FILECOMMENT" --output "$PUBKEYFILE" --export
254
253
fi
255
254
 
256
255
if [ "$mode" = password ]; then
257
 
    # Import keys into temporary key rings
258
 
    gpg --no-random-seed-file --quiet --batch --no-tty --armor \
259
 
        --no-default-keyring --no-options --enable-dsa2 \
260
 
        --homedir "$KEYDIR" --no-permission-warning \
261
 
        --secret-keyring "$SECRING" --keyring "$PUBRING" \
262
 
        --trust-model always --import "$SECKEYFILE"
263
 
    gpg --no-random-seed-file --quiet --batch --no-tty --armor \
264
 
        --no-default-keyring --no-options --enable-dsa2 \
265
 
        --homedir "$KEYDIR" --no-permission-warning \
266
 
        --secret-keyring "$SECRING" --keyring "$PUBRING" \
267
 
        --trust-model always --import "$PUBKEYFILE"
268
 
 
 
256
    # Import key into temporary key rings
 
257
    gpg --quiet --batch --no-tty --no-options --enable-dsa2 \
 
258
        --homedir "$RINGDIR" --trust-model always --armor \
 
259
        --import "$SECKEYFILE"
 
260
    gpg --quiet --batch --no-tty --no-options --enable-dsa2 \
 
261
        --homedir "$RINGDIR" --trust-model always --armor \
 
262
        --import "$PUBKEYFILE"
 
263
    
269
264
    # Get fingerprint of key
270
 
    FINGERPRINT="`gpg --no-random-seed-file --quiet --batch --no-tty \
271
 
        --armor --no-default-keyring --no-options --enable-dsa2 \
272
 
        --homedir \"$KEYDIR\" --no-permission-warning \
273
 
        --secret-keyring \"$SECRING\" --keyring \"$PUBRING\" \
274
 
        --trust-model always --fingerprint --with-colons \
275
 
        | sed -n -e '/^fpr:/{s/^fpr:.*:\\([0-9A-Z]*\\):\$/\\1/p;q}'`"
 
265
    FINGERPRINT="`gpg --quiet --batch --no-tty --no-options \
 
266
        --enable-dsa2 --homedir \"$RINGDIR\" --trust-model always \
 
267
        --fingerprint --with-colons \
 
268
        | sed --quiet \
 
269
        --expression='/^fpr:/{s/^fpr:.*:\\([0-9A-Z]*\\):\$/\\1/p;q}'`"
276
270
    
277
271
    test -n "$FINGERPRINT"
278
272
    
279
273
    FILECOMMENT="Encrypted password for a Mandos client"
280
274
    
281
 
    stty -echo
282
 
    echo -n "Enter passphrase: " >&2
283
 
    sed -e '1q' \
284
 
        | gpg --no-random-seed-file --batch --no-tty --armor \
285
 
        --no-default-keyring --no-options --enable-dsa2 \
286
 
        --homedir "$KEYDIR" --no-permission-warning \
287
 
        --secret-keyring "$SECRING" --keyring "$PUBRING" \
288
 
        --trust-model always --encrypt --recipient "$FINGERPRINT" \
289
 
        --comment "$FILECOMMENT" \
 
275
    if [ -n "$PASSFILE" ]; then
 
276
        cat "$PASSFILE"
 
277
    else
 
278
        stty -echo
 
279
        echo -n "Enter passphrase: " >&2
 
280
        first="$(head --lines=1 | tr --delete '\n')"
 
281
        echo -n -e "\nRepeat passphrase: " >&2
 
282
        second="$(head --lines=1 | tr --delete '\n')"
 
283
        echo >&2
 
284
        stty echo
 
285
        if [ "$first" != "$second" ]; then
 
286
            echo -e "Passphrase mismatch" >&2
 
287
            false
 
288
        else
 
289
            echo -n "$first"
 
290
        fi
 
291
    fi | gpg --quiet --batch --no-tty --no-options --enable-dsa2 \
 
292
        --homedir "$RINGDIR" --trust-model always --armor --encrypt \
 
293
        --sign --recipient "$FINGERPRINT" --comment "$FILECOMMENT" \
290
294
        > "$SECFILE"
291
 
    echo >&2
292
 
    stty echo
 
295
    status="${PIPESTATUS[0]}"
 
296
    if [ "$status" -ne 0 ]; then
 
297
        exit "$status"
 
298
    fi
293
299
    
294
300
    cat <<-EOF
295
301
        [$KEYNAME]
296
302
        host = $KEYNAME
297
303
        fingerprint = $FINGERPRINT
298
304
        secret =
299
 
EOF
300
 
    sed -n -e '
 
305
        EOF
 
306
    sed --quiet --expression='
301
307
        /^-----BEGIN PGP MESSAGE-----$/,/^-----END PGP MESSAGE-----$/{
302
308
            /^$/,${
303
309
                # Remove 24-bit Radix-64 checksum
316
322
    shred --remove "$SECFILE"
317
323
fi
318
324
# Remove the key rings
319
 
shred --remove "$SECRING"
320
 
rm --force "$PUBRING" "${PUBRING}~"
321
 
# Remove the trustdb, if one did not exist when we started
322
 
if [ -n "$TRUSTDB" ]; then
323
 
    rm --force "$TRUSTDB"
324
 
fi
 
325
shred --remove "$RINGDIR"/sec*
 
326
rm --recursive --force "$RINGDIR"