src/monkeysphere-server

   1 #!/bin/bash
   2
   3 # monkeysphere-server: MonkeySphere server admin tool
   4 #
   5 # The monkeysphere scripts are written by:
   6 # Jameson Rollins <jrollins@fifthhorseman.net>
   7 #
   8 # They are Copyright 2008, and are all released under the GPL, version 3
   9 # or later.
  10
  11 ########################################################################
  12 PGRM=$(basename $0)
  13
  14 SHARE=${MONKEYSPHERE_SHARE:="/usr/share/monkeysphere"}
  15 export SHARE
  16 . "${SHARE}/common" || exit 1
  17
  18 VARLIB="/var/lib/monkeysphere"
  19 export VARLIB
  20
  21 # date in UTF format if needed
  22 DATE=$(date -u '+%FT%T')
  23
  24 # unset some environment variables that could screw things up
  25 unset GREP_OPTIONS
  26
  27 # default return code
  28 RETURN=0
  29
  30 ########################################################################
  31 # FUNCTIONS
  32 ########################################################################
  33
  34 usage() {
  35     cat <<EOF
  36 usage: $PGRM <subcommand> [options] [args]
  37 MonkeySphere server admin tool.
  38
  39 subcommands:
  40  update-users (u) [USER]...          update user authorized_keys files
  41
  42  gen-key (g) [NAME[:PORT]]           generate gpg key for the server
  43    -l|--length BITS                    key length in bits (2048)
  44    -e|--expire EXPIRE                  date to expire
  45    -r|--revoker FINGERPRINT            add a revoker
  46  add-hostname (n+) NAME[:PORT]       add hostname user ID to server key
  47  revoke-hostname (n-) NAME[:PORT]    revoke hostname user ID
  48  show-key (s)                        output all server host key information
  49  fingerprint (f)                     output just the key fingerprint
  50  publish-key (p)                     publish server host key to keyserver
  51  diagnostics (d)                     report on server monkeysphere status
  52
  53  add-id-certifier (c+) KEYID         import and tsign a certification key
  54    -n|--domain DOMAIN                  limit ID certifications to DOMAIN
  55    -t|--trust TRUST                    trust level of certifier (full)
  56    -d|--depth DEPTH                    trust depth for certifier (1)
  57  remove-id-certifier (c-) KEYID      remove a certification key
  58  list-id-certifiers (c)              list certification keys
  59
  60  gpg-authentication-cmd CMD          gnupg-authentication command
  61
  62  -h|--help|help (h,?)                this help
  63 EOF
  64 }
  65
  66 su_monkeysphere_user() {
  67     su --preserve-environment "$MONKEYSPHERE_USER" -- -c "$@"
  68 }
  69
  70 # function to interact with the host gnupg keyring
  71 gpg_host() {
  72     local returnCode
  73
  74     GNUPGHOME="$GNUPGHOME_HOST"
  75     export GNUPGHOME
  76
  77     # NOTE: we supress this warning because we need the monkeysphere
  78     # user to be able to read the host pubring.  we realize this might
  79     # be problematic, but it's the simplest solution, without too much
  80     # loss of security.
  81     gpg --no-permission-warning "$@"
  82     returnCode="$?"
  83
  84     # always reset the permissions on the host pubring so that the
  85     # monkeysphere user can read the trust signatures
  86     chgrp "$MONKEYSPHERE_USER" "${GNUPGHOME_HOST}/pubring.gpg"
  87     chmod g+r "${GNUPGHOME_HOST}/pubring.gpg"
  88
  89     return "$returnCode"
  90 }
  91
  92 # function to interact with the authentication gnupg keyring
  93 # FIXME: this function requires basically accepts only a single
  94 # argument because of problems with quote expansion.  this needs to be
  95 # fixed/improved.
  96 gpg_authentication() {
  97     GNUPGHOME="$GNUPGHOME_AUTHENTICATION"
  98     export GNUPGHOME
  99
 100     su_monkeysphere_user "gpg $@"
 101 }
 102
 103 # output key information
 104 show_server_key() {
 105     gpg_host --list-secret-keys --fingerprint
 106 }
 107
 108 # output just key fingerprint
 109 fingerprint_server_key() {
 110     gpg_host --list-secret-keys --fingerprint --with-colons --fixed-list-mode | \
 111         grep '^fpr:' | head -1 | cut -d: -f10
 112 }
 113
 114 # update authorized_keys for users
 115 update_users() {
 116     if [ "$1" ] ; then
 117         # get users from command line
 118         unames="$@"
 119     else
 120         # or just look at all users if none specified
 121         unames=$(getent passwd | cut -d: -f1)
 122     fi
 123
 124     # set mode
 125     MODE="authorized_keys"
 126
 127     # set gnupg home
 128     GNUPGHOME="$GNUPGHOME_AUTHENTICATION"
 129
 130     # check to see if the gpg trust database has been initialized
 131     if [ ! -s "${GNUPGHOME}/trustdb.gpg" ] ; then
 132         failure "GNUPG trust database uninitialized.  Please see MONKEYSPHERE-SERVER(8)."
 133     fi
 134
 135     # make sure the authorized_keys directory exists
 136     mkdir -p "${VARLIB}/authorized_keys"
 137
 138     # loop over users
 139     for uname in $unames ; do
 140         # check all specified users exist
 141         if ! getent passwd "$uname" >/dev/null ; then
 142             log "----- unknown user '$uname' -----"
 143             continue
 144         fi
 145
 146         # set authorized_user_ids and raw authorized_keys variables,
 147         # translating ssh-style path variables
 148         authorizedUserIDs=$(translate_ssh_variables "$uname" "$AUTHORIZED_USER_IDS")
 149         rawAuthorizedKeys=$(translate_ssh_variables "$uname" "$RAW_AUTHORIZED_KEYS")
 150
 151         # if neither is found, skip user
 152         if [ ! -s "$authorizedUserIDs" ] ; then
 153             if [ "$rawAuthorizedKeys" = '-' -o ! -s "$rawAuthorizedKeys" ] ; then
 154                 continue
 155             fi
 156         fi
 157
 158         log "----- user: $uname -----"
 159
 160         # exit if the authorized_user_ids file is empty
 161         if ! check_key_file_permissions "$uname" "$AUTHORIZED_USER_IDS" ; then
 162             log "Improper permissions on authorized_user_ids file path."
 163             continue
 164         fi
 165
 166         # check permissions on the authorized_keys file path
 167         if ! check_key_file_permissions "$uname" "$RAW_AUTHORIZED_KEYS" ; then
 168             log "Improper permissions on authorized_keys file path path."
 169             continue
 170         fi
 171
 172         # make temporary directory
 173         TMPDIR=$(mktemp -d)
 174
 175         # trap to delete temporary directory on exit
 176         trap "rm -rf $TMPDIR" EXIT
 177
 178         # create temporary authorized_user_ids file
 179         TMP_AUTHORIZED_USER_IDS="${TMPDIR}/authorized_user_ids"
 180         touch "$TMP_AUTHORIZED_USER_IDS"
 181
 182         # create temporary authorized_keys file
 183         AUTHORIZED_KEYS="${TMPDIR}/authorized_keys"
 184         touch "$AUTHORIZED_KEYS"
 185
 186         # set restrictive permissions on the temporary files
 187         # FIXME: is there a better way to do this?
 188         chmod 0700 "$TMPDIR"
 189         chmod 0600 "$AUTHORIZED_KEYS"
 190         chmod 0600 "$TMP_AUTHORIZED_USER_IDS"
 191         chown -R "$MONKEYSPHERE_USER" "$TMPDIR"
 192
 193         # if the authorized_user_ids file exists...
 194         if [ -s "$authorizedUserIDs" ] ; then
 195             # copy user authorized_user_ids file to temporary
 196             # location
 197             cat "$authorizedUserIDs" > "$TMP_AUTHORIZED_USER_IDS"
 198
 199             # export needed variables
 200             export AUTHORIZED_KEYS
 201             export TMP_AUTHORIZED_USER_IDS
 202
 203             # process authorized_user_ids file, as monkeysphere
 204             # user
 205             su_monkeysphere_user \
 206                 ". ${SHARE}/common; process_authorized_user_ids $TMP_AUTHORIZED_USER_IDS"
 207             RETURN="$?"
 208         fi
 209
 210         # add user-controlled authorized_keys file path if specified
 211         if [ "$rawAuthorizedKeys" != '-' -a -s "$rawAuthorizedKeys" ] ; then
 212             log -n "adding raw authorized_keys file... "
 213             cat "$rawAuthorizedKeys" >> "$AUTHORIZED_KEYS"
 214             loge "done."
 215         fi
 216
 217         # openssh appears to check the contents of the
 218         # authorized_keys file as the user in question, so the
 219         # file must be readable by that user at least.
 220         # FIXME: is there a better way to do this?
 221         chown root "$AUTHORIZED_KEYS"
 222         chgrp $(getent passwd "$uname" | cut -f4 -d:) "$AUTHORIZED_KEYS"
 223         chmod g+r "$AUTHORIZED_KEYS"
 224
 225         # move the resulting authorized_keys file into place
 226         mv -f "$AUTHORIZED_KEYS" "${VARLIB}/authorized_keys/${uname}"
 227
 228         # destroy temporary directory
 229         rm -rf "$TMPDIR"
 230     done
 231 }
 232
 233 # generate server gpg key
 234 gen_key() {
 235     local keyType
 236     local keyLength
 237     local keyUsage
 238     local keyExpire
 239     local revoker
 240     local hostName
 241     local userID
 242     local keyParameters
 243     local fingerprint
 244
 245     # set default key parameter values
 246     keyType="RSA"
 247     keyLength="2048"
 248     keyUsage="auth"
 249     keyExpire=
 250     revoker=
 251
 252     # get options
 253     TEMP=$(getopt -o e:l:r -l expire:,length:,revoker: -n "$PGRM" -- "$@")
 254
 255     if [ $? != 0 ] ; then
 256         exit 1
 257     fi
 258
 259     # Note the quotes around `$TEMP': they are essential!
 260     eval set -- "$TEMP"
 261
 262     while true ; do
 263         case "$1" in
 264             -l|--length)
 265                 keyLength="$2"
 266                 shift 2
 267                 ;;
 268             -e|--expire)
 269                 keyExpire="$2"
 270                 shift 2
 271                 ;;
 272             -r|--revoker)
 273                 revoker="$2"
 274                 shift 2
 275                 ;;
 276             --)
 277                 shift
 278                 ;;
 279             *)
 280                 break
 281                 ;;
 282         esac
 283     done
 284
 285     hostName=${1:-$(hostname --fqdn)}
 286     userID="ssh://${hostName}"
 287
 288     # check for presense of key with user ID
 289     if gpg_host --list-key ="$userID" > /dev/null 2>&1 ; then
 290         failure "Key for '$userID' already exists"
 291     fi
 292
 293     # prompt about key expiration if not specified
 294     if [ -z "$keyExpire" ] ; then
 295         cat <<EOF
 296 Please specify how long the key should be valid.
 297          0 = key does not expire
 298       <n>  = key expires in n days
 299       <n>w = key expires in n weeks
 300       <n>m = key expires in n months
 301       <n>y = key expires in n years
 302 EOF
 303         while [ -z "$keyExpire" ] ; do
 304             read -p "Key is valid for? (0) " keyExpire
 305             if ! test_gpg_expire ${keyExpire:=0} ; then
 306                 echo "invalid value"
 307                 unset keyExpire
 308             fi
 309         done
 310     elif ! test_gpg_expire "$keyExpire" ; then
 311         failure "invalid key expiration value '$keyExpire'."
 312     fi
 313
 314     # set key parameters
 315     keyParameters=$(cat <<EOF
 316 Key-Type: $keyType
 317 Key-Length: $keyLength
 318 Key-Usage: $keyUsage
 319 Name-Real: $userID
 320 Expire-Date: $keyExpire
 321 EOF
 322 )
 323
 324     # add the revoker field if specified
 325     # FIXME: the "1:" below assumes that $REVOKER's key is an RSA key.
 326     # FIXME: key is marked "sensitive"?  is this appropriate?
 327     if [ "$revoker" ] ; then
 328         keyParameters="${keyParameters}"$(cat <<EOF
 329 Revoker: 1:$revoker sensitive
 330 EOF
 331 )
 332     fi
 333
 334     echo "The following key parameters will be used for the host private key:"
 335     echo "$keyParameters"
 336
 337     read -p "Generate key? (Y/n) " OK; OK=${OK:=Y}
 338     if [ ${OK/y/Y} != 'Y' ] ; then
 339         failure "aborting."
 340     fi
 341
 342     # add commit command
 343     keyParameters="${keyParameters}"$(cat <<EOF
 344
 345 %commit
 346 %echo done
 347 EOF
 348 )
 349
 350     log "generating server key..."
 351     echo "$keyParameters" | gpg_host --batch --gen-key
 352
 353     # output the server fingerprint
 354     fingerprint_server_key "=${userID}"
 355
 356     # find the key fingerprint of the newly generated key
 357     fingerprint=$(fingerprint_server_key)
 358
 359     # export host ownertrust to authentication keyring
 360     log "setting ultimate owner trust for server key..."
 361     echo "${fingerprint}:6:" | gpg_authentication "--import-ownertrust"
 362
 363     # translate the private key to ssh format, and export to a file
 364     # for sshs usage.
 365     # NOTE: assumes that the primary key is the proper key to use
 366     (umask 077 && \
 367         gpg_host --export-secret-key "$fingerprint" | \
 368         openpgp2ssh "$fingerprint" > "${VARLIB}/ssh_host_rsa_key")
 369     log "Private SSH host key output to file: ${VARLIB}/ssh_host_rsa_key"
 370 }
 371
 372 # add hostname user ID to server key
 373 add_hostname() {
 374     if [ -z "$1" ] ; then
 375         failure "You must specify a hostname to add."
 376     fi
 377
 378     userID="ssh://${1}"
 379
 380     if [ "$(gpg_host --list-key "=${userID}")" ] ; then
 381         failure "Host userID '$userID' already exists."
 382     fi
 383
 384     fingerprint=$(fingerprint_server_key)
 385
 386     adduidCommand=$(cat <<EOF
 387 adduid
 388 $userID
 389
 390
 391 O
 392 save
 393 EOF
 394         )
 395
 396     # add uid
 397     echo "$adduidCommand" | gpg_host --quiet --command-fd 0 --edit-key "$fingerprint"
 398
 399     echo "NOTE: new host userID has not been published."
 400     echo "Use '$PGRM publish-key' to publish these changes."
 401 }
 402
 403 # revoke hostname user ID to server key
 404 revoke_hostname() {
 405     if [ -z "$1" ] ; then
 406         failure "You must specify a hostname to revoke."
 407     fi
 408
 409     failure "Sorry, not yet implemented."
 410
 411     echo "NOTE: host userID revokation has not been published."
 412     echo "Use '$PGRM publish-key' to publish these changes."
 413 }
 414
 415 # publish server key to keyserver
 416 publish_server_key() {
 417     read -p "Really publish host key to $KEYSERVER? (y/N) " OK; OK=${OK:=N}
 418     if [ ${OK/y/Y} != 'Y' ] ; then
 419         failure "aborting."
 420     fi
 421
 422     # find the key fingerprint
 423     fingerprint=$(fingerprint_server_key)
 424
 425     # publish host key
 426     # FIXME: need to figure out better way to identify host key
 427     # dummy command so as not to publish fakes keys during testing
 428     # eventually:
 429     gpg_authentication "--keyserver $KEYSERVER --send-keys $fingerprint"
 430 }
 431
 432 diagnostics() {
 433 #  * check on the status and validity of the key and public certificates
 434     local seckey
 435     local keysfound
 436     local curdate
 437     local warnwindow
 438     local warndate
 439     local create
 440     local expire
 441     local uid
 442     local fingerprint
 443     local badhostkeys
 444
 445     seckey=$(fingerprint_server_key)
 446     keysfound=$(echo "$seckey" | grep -c ^sec:)
 447     curdate=$(date +%s)
 448     # warn when anything is 2 months away from expiration
 449     warnwindow='2 months'
 450     warndate=$(date +%s -d "$warnwindow")
 451
 452     echo "Checking host GPG key..."
 453     if (( "$keysfound" < 1 )); then
 454         echo "! No host key found."
 455         echo " - Recommendation: run 'monkeysphere-server gen-key'"
 456     elif (( "$keysfound" > 1 )); then
 457         echo "! More than one host key found?"
 458         # FIXME: recommend a way to resolve this
 459     else
 460         create=$(echo "$seckey" | grep ^sec: | cut -f6 -d:)
 461         expire=$(echo "$seckey" | grep ^sec: | cut -f7 -d:)
 462         fingerprint=$(echo "$seckey" | grep ^fpr: | head -n1 | cut -f10 -d:)
 463         # check for key expiration:
 464         if [ "$expire" ]; then
 465             if (( "$expire"  < "$curdate" )); then
 466                 echo "! Host key is expired."
 467                 # FIXME: recommend a way to resolve this other than re-keying?
 468             elif (( "$expire" < "$warndate" )); then
 469                 echo "! Host key expires in less than $warnwindow:" $(date -d "$(( $expire - $curdate )) seconds" +%F)
 470                 # FIXME: recommend a way to resolve this?
 471             fi
 472         fi
 473
 474         # and weirdnesses:
 475         if [ "$create" ] && (( "$create" > "$curdate" )); then
 476             echo "! Host key was created in the future(?!). Is your clock correct?"
 477             echo " - Recommendation: Check clock ($(date +%F_%T)); use NTP?"
 478         fi
 479
 480         # check for UserID expiration:
 481         echo "$seckey" | grep ^uid: | cut -d: -f6,7,10 | \
 482         while IFS=: read create expire uid ; do
 483             # FIXME: should we be doing any checking on the form
 484             # of the User ID?  Should we be unmangling it somehow?
 485
 486             if [ "$create" ] && (( "$create" > "$curdate" )); then
 487                 echo "! User ID '$uid' was created in the future(?!).  Is your clock correct?"
 488                 echo " - Recommendation: Check clock ($(date +%F_%T)); use NTP?"
 489             fi
 490             if [ "$expire" ] ; then
 491                 if (( "$expire" < "$curdate" )); then
 492                     echo "! User ID '$uid' is expired."
 493                         # FIXME: recommend a way to resolve this
 494                 elif (( "$expire" < "$warndate" )); then
 495                     echo "! User ID '$uid' expires in less than $warnwindow:" $(date -d "$(( $expire - $curdate )) seconds" +%F)
 496                     # FIXME: recommend a way to resolve this
 497                 fi
 498             fi
 499         done
 500
 501 # FIXME: verify that the host key is properly published to the
 502 #   keyservers (do this with the non-privileged user)
 503
 504 # FIXME: check that there are valid, non-expired certifying signatures
 505 #   attached to the host key after fetching from the public keyserver
 506 #   (do this with the non-privileged user as well)
 507
 508 # FIXME: propose adding a revoker to the host key if none exist (do we
 509 #   have a way to do that after key generation?)
 510
 511         # Ensure that the ssh_host_rsa_key file is present and non-empty:
 512         echo "Checking host SSH key..."
 513         if [ ! -s "${VARLIB}/ssh_host_rsa_key" ] ; then
 514             echo "! The host key as prepared for SSH (${VARLIB}/ssh_host_rsa_key) is missing or empty."
 515         else
 516             if [ $(stat -c '%a' "${VARLIB}/ssh_host_rsa_key") != 600 ] ; then
 517                 echo "! Permissions seem wrong for ${VARLIB}/ssh_host_rsa_key -- should be 0600."
 518             fi
 519
 520             # propose changes needed for sshd_config (if any)
 521             if ! grep -q "^HostKey[[:space:]]\+${VARLIB}/ssh_host_rsa_key$" /etc/ssh/sshd_config; then
 522                 echo "! /etc/ssh/sshd_config does not point to the monkeysphere host key (${VARLIB}/ssh_host_rsa_key)."
 523                 echo " - Recommendation: add a line to /etc/ssh/sshd_config: 'HostKey ${VARLIB}/ssh_host_rsa_key'"
 524             fi
 525             if badhostkeys=$(grep -i '^HostKey' | grep -q -v "^HostKey[[:space:]]\+${VARLIB}/ssh_host_rsa_key$") ; then
 526                 echo "! /etc/sshd_config refers to some non-monkeysphere host keys:"
 527                 echo "$badhostkeys"
 528                 echo " - Recommendation: remove the above HostKey lines from /etc/ssh/sshd_config"
 529             fi
 530         fi
 531     fi
 532
 533 # FIXME: look at the ownership/privileges of the various keyrings,
 534 #    directories housing them, etc (what should those values be?  can
 535 #    we make them as minimal as possible?)
 536
 537 # FIXME: look to see that the ownertrust rules are set properly on the
 538 #    authentication keyring
 539
 540 # FIXME:  make sure that at least one identity certifier exists
 541
 542     echo "Checking for MonkeySphere-enabled public-key authentication for users ..."
 543     # Ensure that User ID authentication is enabled:
 544     if ! grep -q "^AuthorizedKeysFile[[:space:]]\+${VARLIB}/authorized_keys/%u$" /etc/ssh/sshd_config; then
 545         echo "! /etc/ssh/sshd_config does not point to monkeysphere authorized keys."
 546         echo " - Recommendation: add a line to /etc/ssh/sshd_config: 'AuthorizedKeysFile ${VARLIB}/authorized_keys/%u'"
 547     fi
 548     if badauthorizedkeys=$(grep -i '^AuthorizedKeysFile' | grep -q -v "^AuthorizedKeysFile[[:space:]]\+${VARLIB}/authorized_keys/%u$") ; then
 549         echo "! /etc/sshd_config refers to non-monkeysphere authorized_keys files:"
 550         echo "$badauthorizedkeys"
 551         echo " - Recommendation: remove the above AuthorizedKeysFile lines from /etc/ssh/sshd_config"
 552     fi
 553 }
 554
 555 # retrieve key from web of trust, import it into the host keyring, and
 556 # ltsign the key in the host keyring so that it may certify other keys
 557 add_certifier() {
 558     local domain
 559     local trust
 560     local depth
 561     local keyID
 562     local fingerprint
 563     local ltsignCommand
 564     local trustval
 565
 566     # set default values for trust depth and domain
 567     domain=
 568     trust=full
 569     depth=1
 570
 571     # get options
 572     TEMP=$(getopt -o n:t:d: -l domain:,trust:,depth: -n "$PGRM" -- "$@")
 573
 574     if [ $? != 0 ] ; then
 575         exit 1
 576     fi
 577
 578     # Note the quotes around `$TEMP': they are essential!
 579     eval set -- "$TEMP"
 580
 581     while true ; do
 582         case "$1" in
 583             -n|--domain)
 584                 domain="$2"
 585                 shift 2
 586                 ;;
 587             -t|--trust)
 588                 trust="$2"
 589                 shift 2
 590                 ;;
 591             -d|--depth)
 592                 depth="$2"
 593                 shift 2
 594                 ;;
 595             --)
 596                 shift
 597                 ;;
 598             *)
 599                 break
 600                 ;;
 601         esac
 602     done
 603
 604     keyID="$1"
 605     if [ -z "$keyID" ] ; then
 606         failure "You must specify the key ID of a key to add."
 607     fi
 608     export keyID
 609
 610     # get the key from the key server
 611     gpg_authentication "--keyserver $KEYSERVER --recv-key '$keyID'"
 612
 613     # get the full fingerprint of a key ID
 614     fingerprint=$(gpg_authentication "--list-key --with-colons --with-fingerprint $keyID" | \
 615         grep '^fpr:' | grep "$keyID" | cut -d: -f10)
 616
 617     echo "key found:"
 618     gpg_authentication "--fingerprint $fingerprint"
 619
 620     echo "Are you sure you want to add this key as a certifier of"
 621     read -p "users on this system? (y/N) " OK; OK=${OK:-N}
 622     if [ "${OK/y/Y}" != 'Y' ] ; then
 623         failure "aborting."
 624     fi
 625
 626     # export the key to the host keyring
 627     gpg_authentication "--export $keyID" | gpg_host --import
 628
 629     if [ "$trust" == marginal ]; then
 630         trustval=1
 631     elif [ "$trust" == full ]; then
 632         trustval=2
 633     else
 634         failure "trust value requested ('$trust') was unclear (only 'marginal' or 'full' are supported)"
 635     fi
 636
 637     # ltsign command
 638     # NOTE: *all* user IDs will be ltsigned
 639     ltsignCommand=$(cat <<EOF
 640 ltsign
 641 y
 642 $trustval
 643 $depth
 644 $domain
 645 y
 646 save
 647 EOF
 648         )
 649
 650     # ltsign the key
 651     echo "$ltsignCommand" | gpg_host --quiet --command-fd 0 --edit-key "$fingerprint"
 652
 653     # update the trustdb for the authentication keyring
 654     gpg_authentication "--check-trustdb"
 655 }
 656
 657 # delete a certifiers key from the host keyring
 658 remove_certifier() {
 659     local keyID
 660     local fingerprint
 661
 662     keyID="$1"
 663     if [ -z "$keyID" ] ; then
 664         failure "You must specify the key ID of a key to remove."
 665     fi
 666
 667     # delete the requested key (with prompting)
 668     gpg_host --delete-key "$keyID"
 669
 670     # update the trustdb for the authentication keyring
 671     gpg_authentication "--check-trustdb"
 672 }
 673
 674 # list the host certifiers
 675 list_certifiers() {
 676     gpg_host --list-keys
 677 }
 678
 679 # issue command to gpg-authentication keyring
 680 gpg_authentication_cmd() {
 681     gpg_authentication "$@"
 682 }
 683
 684 ########################################################################
 685 # MAIN
 686 ########################################################################
 687
 688 # unset variables that should be defined only in config file
 689 unset KEYSERVER
 690 unset AUTHORIZED_USER_IDS
 691 unset RAW_AUTHORIZED_KEYS
 692 unset MONKEYSPHERE_USER
 693
 694 # load configuration file
 695 [ -e ${MONKEYSPHERE_SERVER_CONFIG:="${ETC}/monkeysphere-server.conf"} ] && . "$MONKEYSPHERE_SERVER_CONFIG"
 696
 697 # set empty config variable with ones from the environment, or with
 698 # defaults
 699 KEYSERVER=${MONKEYSPHERE_KEYSERVER:=${KEYSERVER:="subkeys.pgp.net"}}
 700 AUTHORIZED_USER_IDS=${MONKEYSPHERE_AUTHORIZED_USER_IDS:=${AUTHORIZED_USER_IDS:="%h/.config/monkeysphere/authorized_user_ids"}}
 701 RAW_AUTHORIZED_KEYS=${MONKEYSPHERE_RAW_AUTHORIZED_KEYS:=${RAW_AUTHORIZED_KEYS:="%h/.ssh/authorized_keys"}}
 702 MONKEYSPHERE_USER=${MONKEYSPHERE_MONKEYSPHERE_USER:=${MONKEYSPHERE_USER:="monkeysphere"}}
 703
 704 # other variables
 705 CHECK_KEYSERVER=${MONKEYSPHERE_CHECK_KEYSERVER:="true"}
 706 REQUIRED_USER_KEY_CAPABILITY=${MONKEYSPHERE_REQUIRED_USER_KEY_CAPABILITY:="a"}
 707 GNUPGHOME_HOST=${MONKEYSPHERE_GNUPGHOME_HOST:="${VARLIB}/gnupg-host"}
 708 GNUPGHOME_AUTHENTICATION=${MONKEYSPHERE_GNUPGHOME_AUTHENTICATION:="${VARLIB}/gnupg-authentication"}
 709
 710 # export variables needed in su invocation
 711 export DATE
 712 export MODE
 713 export MONKEYSPHERE_USER
 714 export KEYSERVER
 715 export CHECK_KEYSERVER
 716 export REQUIRED_USER_KEY_CAPABILITY
 717 export GNUPGHOME_HOST
 718 export GNUPGHOME_AUTHENTICATION
 719 export GNUPGHOME
 720
 721 # get subcommand
 722 COMMAND="$1"
 723 [ "$COMMAND" ] || failure "Type '$PGRM help' for usage."
 724 shift
 725
 726 case $COMMAND in
 727     'update-users'|'update-user'|'u')
 728         update_users "$@"
 729         ;;
 730
 731     'gen-key'|'g')
 732         gen_key "$@"
 733         ;;
 734
 735     'add-hostname'|'add-name'|'n+')
 736         add_hostname "$@"
 737         ;;
 738
 739     'revoke-hostname'|'revoke-name'|'n-')
 740         revoke_hostname "$@"
 741         ;;
 742
 743     'show-key'|'show'|'s')
 744         show_server_key
 745         ;;
 746
 747     'show-fingerprint'|'fingerprint'|'f')
 748         fingerprint_server_key
 749         ;;
 750
 751     'publish-key'|'publish'|'p')
 752         publish_server_key
 753         ;;
 754
 755     'diagnostics'|'d')
 756         diagnostics
 757         ;;
 758
 759     'add-identity-certifier'|'add-id-certifier'|'add-certifier'|'c+')
 760         add_certifier "$@"
 761         ;;
 762
 763     'remove-identity-certifier'|'remove-id-certifier'|'remove-certifier'|'c-')
 764         remove_certifier "$@"
 765         ;;
 766
 767     'list-identity-certifiers'|'list-id-certifiers'|'list-certifiers'|'list-certifier'|'c')
 768         list_certifiers "$@"
 769         ;;
 770
 771     'gpg-authentication-cmd')
 772         gpg_authentication_cmd "$@"
 773         ;;
 774
 775     '--help'|'help'|'-h'|'h'|'?')
 776         usage
 777         ;;
 778
 779     *)
 780         failure "Unknown command: '$COMMAND'
 781 Type '$PGRM help' for usage."
 782         ;;
 783 esac
 784
 785 exit "$RETURN"