src/share/common

   1 # -*-shell-script-*-
   2 # This should be sourced by bash (though we welcome changes to make it POSIX sh compliant)
   3
   4 # Shared sh functions for the monkeysphere
   5 #
   6 # Written by
   7 # Jameson Rollins <jrollins@finestructure.net>
   8 # Jamie McClelland <jm@mayfirst.org>
   9 # Daniel Kahn Gillmor <dkg@fifthhorseman.net>
  10 #
  11 # Copyright 2008-2009, released under the GPL, version 3 or later
  12
  13 # all-caps variables are meant to be user supplied (ie. from config
  14 # file) and are considered global
  15
  16 ########################################################################
  17 ### COMMON VARIABLES
  18
  19 # managed directories
  20 SYSCONFIGDIR=${MONKEYSPHERE_SYSCONFIGDIR:-"/etc/monkeysphere"}
  21 export SYSCONFIGDIR
  22
  23 # monkeysphere version
  24 VERSION=0.23~pre
  25
  26 # default log level
  27 LOG_LEVEL="INFO"
  28
  29 # default keyserver
  30 KEYSERVER="pool.sks-keyservers.net"
  31
  32 # whether or not to check keyservers by defaul
  33 CHECK_KEYSERVER="true"
  34
  35 # default monkeysphere user
  36 MONKEYSPHERE_USER="monkeysphere"
  37
  38 # default about whether or not to prompt
  39 PROMPT="true"
  40
  41 ########################################################################
  42 ### UTILITY FUNCTIONS
  43
  44 # failure function.  exits with code 255, unless specified otherwise.
  45 failure() {
  46     [ "$1" ] && echo "$1" >&2
  47     exit ${2:-'255'}
  48 }
  49
  50 # write output to stderr based on specified LOG_LEVEL the first
  51 # parameter is the priority of the output, and everything else is what
  52 # is echoed to stderr.  If there is nothing else, then output comes
  53 # from stdin, and is not prefaced by log prefix.
  54 log() {
  55     local priority
  56     local level
  57     local output
  58     local alllevels
  59     local found=
  60
  61     # don't include SILENT in alllevels: it's handled separately
  62     # list in decreasing verbosity (all caps).
  63     # separate with $IFS explicitly, since we do some fancy footwork
  64     # elsewhere.
  65     alllevels="DEBUG${IFS}VERBOSE${IFS}INFO${IFS}ERROR"
  66
  67     # translate lowers to uppers in global log level
  68     LOG_LEVEL=$(echo "$LOG_LEVEL" | tr "[:lower:]" "[:upper:]")
  69
  70     # just go ahead and return if the log level is silent
  71     if [ "$LOG_LEVEL" = 'SILENT' ] ; then
  72         return
  73     fi
  74
  75     for level in $alllevels ; do
  76         if [ "$LOG_LEVEL" = "$level" ] ; then
  77             found=true
  78         fi
  79     done
  80     if [ -z "$found" ] ; then
  81         # default to INFO:
  82         LOG_LEVEL=INFO
  83     fi
  84
  85     # get priority from first parameter, translating all lower to
  86     # uppers
  87     priority=$(echo "$1" | tr "[:lower:]" "[:upper:]")
  88     shift
  89
  90     # scan over available levels
  91     for level in $alllevels ; do
  92         # output if the log level matches, set output to true
  93         # this will output for all subsequent loops as well.
  94         if [ "$LOG_LEVEL" = "$level" ] ; then
  95             output=true
  96         fi
  97         if [ "$priority" = "$level" -a "$output" = 'true' ] ; then
  98             if [ "$1" ] ; then
  99                 echo -n "ms: " >&2
 100                 echo "$@" >&2
 101             else
 102                 cat >&2
 103             fi
 104         fi
 105     done
 106 }
 107
 108 # run command as monkeysphere user
 109 su_monkeysphere_user() {
 110     # our main goal here is to run the given command as the the
 111     # monkeysphere user, but without prompting for any sort of
 112     # authentication.  If this is not possible, we should just fail.
 113
 114     # FIXME: our current implementation is overly restrictive, because
 115     # there may be some su PAM configurations that would allow su
 116     # "$MONKEYSPHERE_USER" -c "$@" to Just Work without prompting,
 117     # allowing specific users to invoke commands which make use of
 118     # this user.
 119
 120     # chpst (from runit) would be nice to use, but we don't want to
 121     # introduce an extra dependency just for this.  This may be a
 122     # candidate for re-factoring if we switch implementation languages.
 123
 124     case $(id -un) in
 125         # if monkeysphere user, run the command under bash
 126         "$MONKEYSPHERE_USER")
 127             bash -c "$@"
 128             ;;
 129
 130          # if root, su command as monkeysphere user
 131         'root')
 132             su "$MONKEYSPHERE_USER" -c "$@"
 133             ;;
 134
 135         # otherwise, fail
 136         *)
 137             log error "non-privileged user."
 138             ;;
 139     esac
 140 }
 141
 142 # cut out all comments(#) and blank lines from standard input
 143 meat() {
 144     grep -v -e "^[[:space:]]*#" -e '^$' "$1"
 145 }
 146
 147 # cut a specified line from standard input
 148 cutline() {
 149     head --line="$1" "$2" | tail -1
 150 }
 151
 152 # make a temporary directory
 153 msmktempdir() {
 154     mktemp -d ${TMPDIR:-/tmp}/monkeysphere.XXXXXXXXXX
 155 }
 156
 157 # make a temporary file
 158 msmktempfile() {
 159     mktemp ${TMPDIR:-/tmp}/monkeysphere.XXXXXXXXXX
 160 }
 161
 162 # this is a wrapper for doing lock functions.
 163 #
 164 # it lets us depend on either lockfile-progs (preferred) or procmail's
 165 # lockfile, and should
 166 lock() {
 167     local use_lockfileprogs=true
 168     local action="$1"
 169     local file="$2"
 170
 171     if ! ( which lockfile-create >/dev/null 2>/dev/null ) ; then
 172         if ! ( which lockfile >/dev/null ); then
 173             failure "Neither lockfile-create nor lockfile are in the path!"
 174         fi
 175         use_lockfileprogs=
 176     fi
 177
 178     case "$action" in
 179         create)
 180             if [ -n "$use_lockfileprogs" ] ; then
 181                 lockfile-create "$file" || failure "unable to lock '$file'"
 182             else
 183                 lockfile -r 20 "${file}.lock" || failure "unable to lock '$file'"
 184             fi
 185             log debug "lock created on '$file'."
 186             ;;
 187         touch)
 188             if [ -n "$use_lockfileprogs" ] ; then
 189                 lockfile-touch --oneshot "$file"
 190             else
 191                 : Nothing to do here
 192             fi
 193             log debug "lock touched on '$file'."
 194             ;;
 195         remove)
 196             if [ -n "$use_lockfileprogs" ] ; then
 197                 lockfile-remove "$file"
 198             else
 199                 rm -f "${file}.lock"
 200             fi
 201             log debug "lock removed on '$file'."
 202             ;;
 203         *)
 204             failure "bad argument for lock subfunction '$action'"
 205     esac
 206 }
 207
 208
 209 # for portability, between gnu date and BSD date.
 210 # arguments should be:  number longunits format
 211
 212 # e.g. advance_date 20 seconds +%F
 213 advance_date() {
 214     local gnutry
 215     local number="$1"
 216     local longunits="$2"
 217     local format="$3"
 218     local shortunits
 219
 220     # try things the GNU way first
 221     if date -d "$number $longunits" "$format" >/dev/null 2>&1; then
 222         date -d "$number $longunits" "$format"
 223     else
 224         # otherwise, convert to (a limited version of) BSD date syntax:
 225         case "$longunits" in
 226             years)
 227                 shortunits=y
 228                 ;;
 229             months)
 230                 shortunits=m
 231                 ;;
 232             weeks)
 233                 shortunits=w
 234                 ;;
 235             days)
 236                 shortunits=d
 237                 ;;
 238             hours)
 239                 shortunits=H
 240                 ;;
 241             minutes)
 242                 shortunits=M
 243                 ;;
 244             seconds)
 245                 shortunits=S
 246                 ;;
 247             *)
 248                 # this is a longshot, and will likely fail; oh well.
 249                 shortunits="$longunits"
 250         esac
 251         date "-v+${number}${shortunits}" "$format"
 252     fi
 253 }
 254
 255
 256 # check that characters are in a string (in an AND fashion).
 257 # used for checking key capability
 258 # check_capability capability a [b...]
 259 check_capability() {
 260     local usage
 261     local capcheck
 262
 263     usage="$1"
 264     shift 1
 265
 266     for capcheck ; do
 267         if echo "$usage" | grep -q -v "$capcheck" ; then
 268             return 1
 269         fi
 270     done
 271     return 0
 272 }
 273
 274 # hash of a file
 275 file_hash() {
 276     md5sum "$1" 2> /dev/null
 277 }
 278
 279 # convert escaped characters in pipeline from gpg output back into
 280 # original character
 281 # FIXME: undo all escape character translation in with-colons gpg
 282 # output
 283 gpg_unescape() {
 284     sed 's/\\x3a/:/g'
 285 }
 286
 287 # convert nasty chars into gpg-friendly form in pipeline
 288 # FIXME: escape everything, not just colons!
 289 gpg_escape() {
 290     sed 's/:/\\x3a/g'
 291 }
 292
 293 # prompt for GPG-formatted expiration, and emit result on stdout
 294 get_gpg_expiration() {
 295     local keyExpire
 296
 297     keyExpire="$1"
 298
 299     if [ -z "$keyExpire" -a "$PROMPT" = 'true' ]; then
 300         cat >&2 <<EOF
 301 Please specify how long the key should be valid.
 302          0 = key does not expire
 303       <n>  = key expires in n days
 304       <n>w = key expires in n weeks
 305       <n>m = key expires in n months
 306       <n>y = key expires in n years
 307 EOF
 308         while [ -z "$keyExpire" ] ; do
 309             read -p "Key is valid for? (0) " keyExpire
 310             if ! test_gpg_expire ${keyExpire:=0} ; then
 311                 echo "invalid value" >&2
 312                 unset keyExpire
 313             fi
 314         done
 315     elif ! test_gpg_expire "$keyExpire" ; then
 316         failure "invalid key expiration value '$keyExpire'."
 317     fi
 318
 319     echo "$keyExpire"
 320 }
 321
 322 passphrase_prompt() {
 323     local prompt="$1"
 324     local fifo="$2"
 325     local PASS
 326
 327     if [ "$DISPLAY" ] && which "${SSH_ASKPASS:-ssh-askpass}" >/dev/null; then
 328         "${SSH_ASKPASS:-ssh-askpass}" "$prompt" > "$fifo"
 329     else
 330         read -s -p "$prompt" PASS
 331         # Uses the builtin echo, so should not put the passphrase into
 332         # the process table.  I think. --dkg
 333         echo "$PASS" > "$fifo"
 334     fi
 335 }
 336
 337 test_gnu_dummy_s2k_extension() {
 338
 339 # this block contains a demonstration private key that has had the
 340 # primary key stripped out using the GNU S2K extension known as
 341 # "gnu-dummy" (see /usr/share/doc/gnupg/DETAILS.gz).  The subkey is
 342 # present in cleartext, however.
 343
 344 # openpgp2ssh will be able to deal with this based on whether the
 345 # local copy of GnuTLS contains read_s2k support that can handle it.
 346
 347 # read up on that here:
 348
 349 # http://lists.gnu.org/archive/html/gnutls-devel/2008-08/msg00005.html
 350
 351 echo "
 352 -----BEGIN PGP PRIVATE KEY BLOCK-----
 353 Version: GnuPG v1.4.9 (GNU/Linux)
 354
 355 lQCVBEO3YdABBACRqqEnucag4+vyZny2M67Pai5+5suIRRvY+Ly8Ms5MvgCi3EVV
 356 xT05O/+0ShiRaf+QicCOFrhbU9PZzzU+seEvkeW2UCu4dQfILkmj+HBEIltGnHr3
 357 G0yegHj5pnqrcezERURf2e17gGFWX91cXB9Cm721FPXczuKraphKwCA9PwARAQAB
 358 /gNlAkdOVQG0OURlbW9uc3RyYXRpb24gS2V5IGZvciBTMksgR05VIGV4dGVuc2lv
 359 biAxMDAxIC0tIGdudS1kdW1teYi8BBMBAgAmBQJDt2HQAhsDBQkB4TOABgsJCAcD
 360 AgQVAggDBBYCAwECHgECF4AACgkQQZUwSa4UDezTOQP/TMQXUVrWzHYZGopoPZ2+
 361 ZS3qddiznBHsgb7MGYg1KlTiVJSroDUBCHIUJvdQKZV9zrzrFl47D07x6hGyUPHV
 362 aZXvuITW8t1o5MMHkCy3pmJ2KgfDvdUxrBvLfgPMICA4c6zA0mWquee43syEW9NY
 363 g3q61iPlQwD1J1kX1wlimLCdAdgEQ7dh0AEEANAwa63zlQbuy1Meliy8otwiOa+a
 364 mH6pxxUgUNggjyjO5qx+rl25mMjvGIRX4/L1QwIBXJBVi3SgvJW1COZxZqBYqj9U
 365 8HVT07mWKFEDf0rZLeUE2jTm16cF9fcW4DQhW+sfYm+hi2sY3HeMuwlUBK9KHfW2
 366 +bGeDzVZ4pqfUEudABEBAAEAA/0bemib+wxub9IyVFUp7nPobjQC83qxLSNzrGI/
 367 RHzgu/5CQi4tfLOnwbcQsLELfker2hYnjsLrT9PURqK4F7udrWEoZ1I1LymOtLG/
 368 4tNZ7Mnul3wRC2tCn7FKx8sGJwGh/3li8vZ6ALVJAyOia5TZ/buX0+QZzt6+hPKk
 369 7MU1WQIA4bUBjtrsqDwro94DvPj3/jBnMZbXr6WZIItLNeVDUcM8oHL807Am97K1
 370 ueO/f6v1sGAHG6lVPTmtekqPSTWBfwIA7CGFvEyvSALfB8NUa6jtk27NCiw0csql
 371 kuhCmwXGMVOiryKEfegkIahf2bAd/gnWHPrpWp7bUE20v8YoW22I4wIAhnm5Wr5Q
 372 Sy7EHDUxmJm5TzadFp9gq08qNzHBpXSYXXJ3JuWcL1/awUqp3tE1I6zZ0hZ38Ia6
 373 SdBMN88idnhDPqPoiKUEGAECAA8FAkO3YdACGyAFCQHhM4AACgkQQZUwSa4UDezm
 374 vQP/ZhK+2ly9oI2z7ZcNC/BJRch0/ybQ3haahII8pXXmOThpZohr/LUgoWgCZdXg
 375 vP6yiszNk2tIs8KphCAw7Lw/qzDC2hEORjWO4f46qk73RAgSqG/GyzI4ltWiDhqn
 376 vnQCFl3+QFSe4zinqykHnLwGPMXv428d/ZjkIc2ju8dRsn4=
 377 =CR5w
 378 -----END PGP PRIVATE KEY BLOCK-----
 379 " | openpgp2ssh 4129E89D17C1D591 >/dev/null 2>/dev/null
 380
 381 }
 382
 383 # remove all lines with specified string from specified file
 384 remove_line() {
 385     local file
 386     local string
 387     local tempfile
 388
 389     file="$1"
 390     string="$2"
 391
 392     if [ -z "$file" -o -z "$string" ] ; then
 393         return 1
 394     fi
 395
 396     if [ ! -e "$file" ] ; then
 397         return 1
 398     fi
 399
 400     # if the string is in the file...
 401     if grep -q -F "$string" "$file" 2> /dev/null ; then
 402         tempfile=$(mktemp "${file}.XXXXXXX") || \
 403             failure "Unable to make temp file '${file}.XXXXXXX'"
 404
 405         # remove the line with the string, and return 0
 406         grep -v -F "$string" "$file" >"$tempfile"
 407         cat "$tempfile" > "$file"
 408         rm "$tempfile"
 409         return 0
 410     # otherwise return 1
 411     else
 412         return 1
 413     fi
 414 }
 415
 416 # remove all lines with MonkeySphere strings in file
 417 remove_monkeysphere_lines() {
 418     local file
 419     local tempfile
 420
 421     file="$1"
 422
 423     if [ -z "$file" ] ; then
 424         return 1
 425     fi
 426
 427     if [ ! -e "$file" ] ; then
 428         return 1
 429     fi
 430
 431     tempfile=$(mktemp "${file}.XXXXXXX") || \
 432         failure "Could not make temporary file '${file}.XXXXXXX'."
 433
 434     egrep -v '^MonkeySphere[[:digit:]]{4}(-[[:digit:]]{2}){2}T[[:digit:]]{2}(:[[:digit:]]{2}){2}$' \
 435         "$file" >"$tempfile"
 436     cat "$tempfile" > "$file"
 437     rm "$tempfile"
 438 }
 439
 440 # translate ssh-style path variables %h and %u
 441 translate_ssh_variables() {
 442     local uname
 443     local home
 444
 445     uname="$1"
 446     path="$2"
 447
 448     # get the user's home directory
 449     userHome=$(getent passwd "$uname" | cut -d: -f6)
 450
 451     # translate '%u' to user name
 452     path=${path/\%u/"$uname"}
 453     # translate '%h' to user home directory
 454     path=${path/\%h/"$userHome"}
 455
 456     echo "$path"
 457 }
 458
 459 # test that a string to conforms to GPG's expiration format
 460 test_gpg_expire() {
 461     echo "$1" | egrep -q "^[0-9]+[mwy]?$"
 462 }
 463
 464 # check that a file is properly owned, and that all it's parent
 465 # directories are not group/other writable
 466 check_key_file_permissions() {
 467     local uname
 468     local path
 469     local stat
 470     local access
 471     local gAccess
 472     local oAccess
 473
 474     # function to check that the given permission corresponds to writability
 475     is_write() {
 476         [ "$1" = "w" ]
 477     }
 478
 479     uname="$1"
 480     path="$2"
 481
 482     log debug "checking path permission '$path'..."
 483
 484     # return 255 if cannot stat file
 485     if ! stat=$(ls -ld "$path" 2>/dev/null) ; then
 486         log error "could not stat path '$path'."
 487         return 255
 488     fi
 489
 490     owner=$(echo "$stat" | awk '{ print $3 }')
 491     gAccess=$(echo "$stat" | cut -c6)
 492     oAccess=$(echo "$stat" | cut -c9)
 493
 494     # return 1 if path has invalid owner
 495     if [ "$owner" != "$uname" -a "$owner" != 'root' ] ; then
 496         log error "improper ownership on path '$path'."
 497         return 1
 498     fi
 499
 500     # return 2 if path has group or other writability
 501     if is_write "$gAccess" || is_write "$oAccess" ; then
 502         log error "improper group or other writability on path '$path'."
 503         return 2
 504     fi
 505
 506     # return zero if all clear, or go to next path
 507     if [ "$path" = '/' ] ; then
 508         return 0
 509     else
 510         check_key_file_permissions "$uname" $(dirname "$path")
 511     fi
 512 }
 513
 514 ### CONVERSION UTILITIES
 515
 516 # output the ssh key for a given key ID
 517 gpg2ssh() {
 518     local keyID
 519
 520     keyID="$1"
 521
 522     gpg --export "$keyID" | openpgp2ssh "$keyID" 2> /dev/null
 523 }
 524
 525 # output known_hosts line from ssh key
 526 ssh2known_hosts() {
 527     local host
 528     local key
 529
 530     host="$1"
 531     key="$2"
 532
 533     echo -n "$host "
 534     echo -n "$key" | tr -d '\n'
 535     echo " MonkeySphere${DATE}"
 536 }
 537
 538 # output authorized_keys line from ssh key
 539 ssh2authorized_keys() {
 540     local userID
 541     local key
 542
 543     userID="$1"
 544     key="$2"
 545
 546     echo -n "$key" | tr -d '\n'
 547     echo " MonkeySphere${DATE} ${userID}"
 548 }
 549
 550 # convert key from gpg to ssh known_hosts format
 551 gpg2known_hosts() {
 552     local host
 553     local keyID
 554
 555     host="$1"
 556     keyID="$2"
 557
 558     # NOTE: it seems that ssh-keygen -R removes all comment fields from
 559     # all lines in the known_hosts file.  why?
 560     # NOTE: just in case, the COMMENT can be matched with the
 561     # following regexp:
 562     # '^MonkeySphere[[:digit:]]{4}(-[[:digit:]]{2}){2}T[[:digit:]]{2}(:[[:digit:]]{2}){2}$'
 563     echo -n "$host "
 564     gpg2ssh "$keyID" | tr -d '\n'
 565     echo " MonkeySphere${DATE}"
 566 }
 567
 568 # convert key from gpg to ssh authorized_keys format
 569 gpg2authorized_keys() {
 570     local userID
 571     local keyID
 572
 573     userID="$1"
 574     keyID="$2"
 575
 576     # NOTE: just in case, the COMMENT can be matched with the
 577     # following regexp:
 578     # '^MonkeySphere[[:digit:]]{4}(-[[:digit:]]{2}){2}T[[:digit:]]{2}(:[[:digit:]]{2}){2}$'
 579     gpg2ssh "$keyID" | tr -d '\n'
 580     echo " MonkeySphere${DATE} ${userID}"
 581 }
 582
 583 ### GPG UTILITIES
 584
 585 # retrieve all keys with given user id from keyserver
 586 # FIXME: need to figure out how to retrieve all matching keys
 587 # (not just first N (5 in this case))
 588 gpg_fetch_userid() {
 589     local userID
 590     local returnCode
 591
 592     if [ "$CHECK_KEYSERVER" != 'true' ] ; then
 593         return 0
 594     fi
 595
 596     userID="$1"
 597
 598     log verbose " checking keyserver $KEYSERVER... "
 599     echo 1,2,3,4,5 | \
 600         gpg --quiet --batch --with-colons \
 601         --command-fd 0 --keyserver "$KEYSERVER" \
 602         --search ="$userID" > /dev/null 2>&1
 603     returnCode="$?"
 604
 605     return "$returnCode"
 606 }
 607
 608 ########################################################################
 609 ### PROCESSING FUNCTIONS
 610
 611 # userid and key policy checking
 612 # the following checks policy on the returned keys
 613 # - checks that full key has appropriate valididy (u|f)
 614 # - checks key has specified capability (REQUIRED_*_KEY_CAPABILITY)
 615 # - checks that requested user ID has appropriate validity
 616 # (see /usr/share/doc/gnupg/DETAILS.gz)
 617 # output is one line for every found key, in the following format:
 618 #
 619 # flag:sshKey
 620 #
 621 # "flag" is an acceptability flag, 0 = ok, 1 = bad
 622 # "sshKey" is the translated gpg key
 623 #
 624 # all log output must go to stderr, as stdout is used to pass the
 625 # flag:sshKey to the calling function.
 626 #
 627 # expects global variable: "MODE"
 628 process_user_id() {
 629     local userID
 630     local requiredCapability
 631     local requiredPubCapability
 632     local gpgOut
 633     local type
 634     local validity
 635     local keyid
 636     local uidfpr
 637     local usage
 638     local keyOK
 639     local uidOK
 640     local lastKey
 641     local lastKeyOK
 642     local fingerprint
 643
 644     userID="$1"
 645
 646     # set the required key capability based on the mode
 647     if [ "$MODE" = 'known_hosts' ] ; then
 648         requiredCapability="$REQUIRED_HOST_KEY_CAPABILITY"
 649     elif [ "$MODE" = 'authorized_keys' ] ; then
 650         requiredCapability="$REQUIRED_USER_KEY_CAPABILITY"
 651     fi
 652     requiredPubCapability=$(echo "$requiredCapability" | tr "[:lower:]" "[:upper:]")
 653
 654     # fetch the user ID if necessary/requested
 655     gpg_fetch_userid "$userID"
 656
 657     # output gpg info for (exact) userid and store
 658     gpgOut=$(gpg --list-key --fixed-list-mode --with-colon \
 659         --with-fingerprint --with-fingerprint \
 660         ="$userID" 2>/dev/null)
 661
 662     # if the gpg query return code is not 0, return 1
 663     if [ "$?" -ne 0 ] ; then
 664         log verbose " no primary keys found."
 665         return 1
 666     fi
 667
 668     # loop over all lines in the gpg output and process.
 669     echo "$gpgOut" | cut -d: -f1,2,5,10,12 | \
 670     while IFS=: read -r type validity keyid uidfpr usage ; do
 671         # process based on record type
 672         case $type in
 673             'pub') # primary keys
 674                 # new key, wipe the slate
 675                 keyOK=
 676                 uidOK=
 677                 lastKey=pub
 678                 lastKeyOK=
 679                 fingerprint=
 680
 681                 log verbose " primary key found: $keyid"
 682
 683                 # if overall key is not valid, skip
 684                 if [ "$validity" != 'u' -a "$validity" != 'f' ] ; then
 685                     log debug "  - unacceptable primary key validity ($validity)."
 686                     continue
 687                 fi
 688                 # if overall key is disabled, skip
 689                 if check_capability "$usage" 'D' ; then
 690                     log debug "  - key disabled."
 691                     continue
 692                 fi
 693                 # if overall key capability is not ok, skip
 694                 if ! check_capability "$usage" $requiredPubCapability ; then
 695                     log debug "  - unacceptable primary key capability ($usage)."
 696                     continue
 697                 fi
 698
 699                 # mark overall key as ok
 700                 keyOK=true
 701
 702                 # mark primary key as ok if capability is ok
 703                 if check_capability "$usage" $requiredCapability ; then
 704                     lastKeyOK=true
 705                 fi
 706                 ;;
 707             'uid') # user ids
 708                 if [ "$lastKey" != pub ] ; then
 709                     log verbose " ! got a user ID after a sub key?!  user IDs should only follow primary keys!"
 710                     continue
 711                 fi
 712                 # if an acceptable user ID was already found, skip
 713                 if [ "$uidOK" = 'true' ] ; then
 714                     continue
 715                 fi
 716                 # if the user ID does matches...
 717                 if [ "$(echo "$uidfpr" | gpg_unescape)" = "$userID" ] ; then
 718                     # and the user ID validity is ok
 719                     if [ "$validity" = 'u' -o "$validity" = 'f' ] ; then
 720                         # mark user ID acceptable
 721                         uidOK=true
 722                     else
 723                         log debug "  - unacceptable user ID validity ($validity)."
 724                     fi
 725                 else
 726                     continue
 727                 fi
 728
 729                 # output a line for the primary key
 730                 # 0 = ok, 1 = bad
 731                 if [ "$keyOK" -a "$uidOK" -a "$lastKeyOK" ] ; then
 732                     log verbose "  * acceptable primary key."
 733                     if [ -z "$sshKey" ] ; then
 734                         log error "    ! primary key could not be translated (not RSA or DSA?)."
 735                     else
 736                         echo "0:${sshKey}"
 737                     fi
 738                 else
 739                     log debug "  - unacceptable primary key."
 740                     if [ -z "$sshKey" ] ; then
 741                         log debug "    ! primary key could not be translated (not RSA or DSA?)."
 742                     else
 743                         echo "1:${sshKey}"
 744                     fi
 745                 fi
 746                 ;;
 747             'sub') # sub keys
 748                 # unset acceptability of last key
 749                 lastKey=sub
 750                 lastKeyOK=
 751                 fingerprint=
 752
 753                 # don't bother with sub keys if the primary key is not valid
 754                 if [ "$keyOK" != true ] ; then
 755                     continue
 756                 fi
 757
 758                 # don't bother with sub keys if no user ID is acceptable:
 759                 if [ "$uidOK" != true ] ; then
 760                     continue
 761                 fi
 762
 763                 # if sub key validity is not ok, skip
 764                 if [ "$validity" != 'u' -a "$validity" != 'f' ] ; then
 765                     log debug "  - unacceptable sub key validity ($validity)."
 766                     continue
 767                 fi
 768                 # if sub key capability is not ok, skip
 769                 if ! check_capability "$usage" $requiredCapability ; then
 770                     log debug "  - unacceptable sub key capability ($usage)."
 771                     continue
 772                 fi
 773
 774                 # mark sub key as ok
 775                 lastKeyOK=true
 776                 ;;
 777             'fpr') # key fingerprint
 778                 fingerprint="$uidfpr"
 779
 780                 sshKey=$(gpg2ssh "$fingerprint")
 781
 782                 # if the last key was the pub key, skip
 783                 if [ "$lastKey" = pub ] ; then
 784                     continue
 785                 fi
 786
 787                 # output a line for the sub key
 788                 # 0 = ok, 1 = bad
 789                 if [ "$keyOK" -a "$uidOK" -a "$lastKeyOK" ] ; then
 790                     log verbose "  * acceptable sub key."
 791                     if [ -z "$sshKey" ] ; then
 792                         log error "    ! sub key could not be translated (not RSA or DSA?)."
 793                     else
 794                         echo "0:${sshKey}"
 795                     fi
 796                 else
 797                     log debug "  - unacceptable sub key."
 798                     if [ -z "$sshKey" ] ; then
 799                         log debug "    ! sub key could not be translated (not RSA or DSA?)."
 800                     else
 801                         echo "1:${sshKey}"
 802                     fi
 803                 fi
 804                 ;;
 805         esac
 806     done | sort -t: -k1 -n -r
 807     # NOTE: this last sort is important so that the "good" keys (key
 808     # flag '0') come last.  This is so that they take precedence when
 809     # being processed in the key files over "bad" keys (key flag '1')
 810 }
 811
 812 # process a single host in the known_host file
 813 process_host_known_hosts() {
 814     local host
 815     local userID
 816     local noKey=
 817     local nKeys
 818     local nKeysOK
 819     local ok
 820     local sshKey
 821     local tmpfile
 822
 823     # set the key processing mode
 824     export MODE='known_hosts'
 825
 826     host="$1"
 827     userID="ssh://${host}"
 828
 829     log verbose "processing: $host"
 830
 831     nKeys=0
 832     nKeysOK=0
 833
 834     IFS=$'\n'
 835     for line in $(process_user_id "${userID}") ; do
 836         # note that key was found
 837         nKeys=$((nKeys+1))
 838
 839         ok=$(echo "$line" | cut -d: -f1)
 840         sshKey=$(echo "$line" | cut -d: -f2)
 841
 842         if [ -z "$sshKey" ] ; then
 843             continue
 844         fi
 845
 846         # remove any old host key line, and note if removed nothing is
 847         # removed
 848         remove_line "$KNOWN_HOSTS" "$sshKey" || noKey=true
 849
 850         # if key OK, add new host line
 851         if [ "$ok" -eq '0' ] ; then
 852             # note that key was found ok
 853             nKeysOK=$((nKeysOK+1))
 854
 855             # hash if specified
 856             if [ "$HASH_KNOWN_HOSTS" = 'true' ] ; then
 857                 # FIXME: this is really hackish cause ssh-keygen won't
 858                 # hash from stdin to stdout
 859                 tmpfile=$(mktemp ${TMPDIR:-/tmp}/tmp.XXXXXXXXXX)
 860                 ssh2known_hosts "$host" "$sshKey" > "$tmpfile"
 861                 ssh-keygen -H -f "$tmpfile" 2> /dev/null
 862                 cat "$tmpfile" >> "$KNOWN_HOSTS"
 863                 rm -f "$tmpfile" "${tmpfile}.old"
 864             else
 865                 ssh2known_hosts "$host" "$sshKey" >> "$KNOWN_HOSTS"
 866             fi
 867
 868             # log if this is a new key to the known_hosts file
 869             if [ "$noKey" ] ; then
 870                 log info "* new key for $host added to known_hosts file."
 871             fi
 872         fi
 873     done
 874
 875     # if at least one key was found...
 876     if [ "$nKeys" -gt 0 ] ; then
 877         # if ok keys were found, return 0
 878         if [ "$nKeysOK" -gt 0 ] ; then
 879             return 0
 880         # else return 2
 881         else
 882             return 2
 883         fi
 884     # if no keys were found, return 1
 885     else
 886         return 1
 887     fi
 888 }
 889
 890 # update the known_hosts file for a set of hosts listed on command
 891 # line
 892 update_known_hosts() {
 893     local nHosts
 894     local nHostsOK
 895     local nHostsBAD
 896     local fileCheck
 897     local host
 898
 899     # the number of hosts specified on command line
 900     nHosts="$#"
 901
 902     nHostsOK=0
 903     nHostsBAD=0
 904
 905     # touch the known_hosts file so that the file permission check
 906     # below won't fail upon not finding the file
 907     (umask 0022 && touch "$KNOWN_HOSTS")
 908
 909     # check permissions on the known_hosts file path
 910     check_key_file_permissions "$USER" "$KNOWN_HOSTS" || failure
 911
 912     # create a lockfile on known_hosts:
 913     lock create "$KNOWN_HOSTS"
 914     # FIXME: we're discarding any pre-existing EXIT trap; is this bad?
 915     trap "lock remove $KNOWN_HOSTS" EXIT
 916
 917     # note pre update file checksum
 918     fileCheck="$(file_hash "$KNOWN_HOSTS")"
 919
 920     for host ; do
 921         # process the host
 922         process_host_known_hosts "$host"
 923         # note the result
 924         case "$?" in
 925             0)
 926                 nHostsOK=$((nHostsOK+1))
 927                 ;;
 928             2)
 929                 nHostsBAD=$((nHostsBAD+1))
 930                 ;;
 931         esac
 932
 933         # touch the lockfile, for good measure.
 934         lock touch "$KNOWN_HOSTS"
 935     done
 936
 937     # remove the lockfile and the trap
 938     lock remove "$KNOWN_HOSTS"
 939     trap - EXIT
 940
 941     # note if the known_hosts file was updated
 942     if [ "$(file_hash "$KNOWN_HOSTS")" != "$fileCheck" ] ; then
 943         log debug "known_hosts file updated."
 944     fi
 945
 946     # if an acceptable host was found, return 0
 947     if [ "$nHostsOK" -gt 0 ] ; then
 948         return 0
 949     # else if no ok hosts were found...
 950     else
 951         # if no bad host were found then no hosts were found at all,
 952         # and return 1
 953         if [ "$nHostsBAD" -eq 0 ] ; then
 954             return 1
 955         # else if at least one bad host was found, return 2
 956         else
 957             return 2
 958         fi
 959     fi
 960 }
 961
 962 # process hosts from a known_hosts file
 963 process_known_hosts() {
 964     local hosts
 965
 966     # exit if the known_hosts file does not exist
 967     if [ ! -e "$KNOWN_HOSTS" ] ; then
 968         failure "known_hosts file '$KNOWN_HOSTS' does not exist."
 969     fi
 970
 971     log debug "processing known_hosts file..."
 972
 973     hosts=$(meat "$KNOWN_HOSTS" | cut -d ' ' -f 1 | grep -v '^|.*$' | tr , ' ' | tr '\n' ' ')
 974
 975     if [ -z "$hosts" ] ; then
 976         log debug "no hosts to process."
 977         return
 978     fi
 979
 980     # take all the hosts from the known_hosts file (first
 981     # field), grep out all the hashed hosts (lines starting
 982     # with '|')...
 983     update_known_hosts $hosts
 984 }
 985
 986 # process uids for the authorized_keys file
 987 process_uid_authorized_keys() {
 988     local userID
 989     local nKeys
 990     local nKeysOK
 991     local ok
 992     local sshKey
 993
 994     # set the key processing mode
 995     export MODE='authorized_keys'
 996
 997     userID="$1"
 998
 999     log verbose "processing: $userID"
1000
1001     nKeys=0
1002     nKeysOK=0
1003
1004     IFS=$'\n'
1005     for line in $(process_user_id "$userID") ; do
1006         # note that key was found
1007         nKeys=$((nKeys+1))
1008
1009         ok=$(echo "$line" | cut -d: -f1)
1010         sshKey=$(echo "$line" | cut -d: -f2)
1011
1012         if [ -z "$sshKey" ] ; then
1013             continue
1014         fi
1015
1016         # remove the old host key line
1017         remove_line "$AUTHORIZED_KEYS" "$sshKey"
1018
1019         # if key OK, add new host line
1020         if [ "$ok" -eq '0' ] ; then
1021             # note that key was found ok
1022             nKeysOK=$((nKeysOK+1))
1023
1024             ssh2authorized_keys "$userID" "$sshKey" >> "$AUTHORIZED_KEYS"
1025         fi
1026     done
1027
1028     # if at least one key was found...
1029     if [ "$nKeys" -gt 0 ] ; then
1030         # if ok keys were found, return 0
1031         if [ "$nKeysOK" -gt 0 ] ; then
1032             return 0
1033         # else return 2
1034         else
1035             return 2
1036         fi
1037     # if no keys were found, return 1
1038     else
1039         return 1
1040     fi
1041 }
1042
1043 # update the authorized_keys files from a list of user IDs on command
1044 # line
1045 update_authorized_keys() {
1046     local userID
1047     local nIDs
1048     local nIDsOK
1049     local nIDsBAD
1050     local fileCheck
1051
1052     # the number of ids specified on command line
1053     nIDs="$#"
1054
1055     nIDsOK=0
1056     nIDsBAD=0
1057
1058     # check permissions on the authorized_keys file path
1059     check_key_file_permissions "$USER" "$AUTHORIZED_KEYS" || failure
1060
1061     # create a lockfile on authorized_keys
1062     lock create "$AUTHORIZED_KEYS"
1063     # FIXME: we're discarding any pre-existing EXIT trap; is this bad?
1064     trap "lock remove $AUTHORIZED_KEYS" EXIT
1065
1066     # note pre update file checksum
1067     fileCheck="$(file_hash "$AUTHORIZED_KEYS")"
1068
1069     # remove any monkeysphere lines from authorized_keys file
1070     remove_monkeysphere_lines "$AUTHORIZED_KEYS"
1071
1072     for userID ; do
1073         # process the user ID, change return code if key not found for
1074         # user ID
1075         process_uid_authorized_keys "$userID"
1076
1077         # note the result
1078         case "$?" in
1079             0)
1080                 nIDsOK=$((nIDsOK+1))
1081                 ;;
1082             2)
1083                 nIDsBAD=$((nIDsBAD+1))
1084                 ;;
1085         esac
1086
1087         # touch the lockfile, for good measure.
1088         lock touch "$AUTHORIZED_KEYS"
1089     done
1090
1091     # remove the lockfile and the trap
1092     lock remove "$AUTHORIZED_KEYS"
1093
1094     # remove the trap
1095     trap - EXIT
1096
1097     # note if the authorized_keys file was updated
1098     if [ "$(file_hash "$AUTHORIZED_KEYS")" != "$fileCheck" ] ; then
1099         log debug "authorized_keys file updated."
1100     fi
1101
1102     # if an acceptable id was found, return 0
1103     if [ "$nIDsOK" -gt 0 ] ; then
1104         return 0
1105     # else if no ok ids were found...
1106     else
1107         # if no bad ids were found then no ids were found at all, and
1108         # return 1
1109         if [ "$nIDsBAD" -eq 0 ] ; then
1110             return 1
1111         # else if at least one bad id was found, return 2
1112         else
1113             return 2
1114         fi
1115     fi
1116 }
1117
1118 # process an authorized_user_ids file for authorized_keys
1119 process_authorized_user_ids() {
1120     local line
1121     local nline
1122     local userIDs
1123
1124     authorizedUserIDs="$1"
1125
1126     # exit if the authorized_user_ids file is empty
1127     if [ ! -e "$authorizedUserIDs" ] ; then
1128         failure "authorized_user_ids file '$authorizedUserIDs' does not exist."
1129     fi
1130
1131     # check permissions on the authorized_user_ids file path
1132     check_key_file_permissions "$USER" "$authorizedUserIDs" || failure
1133
1134     log debug "processing authorized_user_ids file..."
1135
1136     if ! meat "$authorizedUserIDs" > /dev/null ; then
1137         log debug " no user IDs to process."
1138         return
1139     fi
1140
1141     nline=0
1142
1143     # extract user IDs from authorized_user_ids file
1144     IFS=$'\n'
1145     for line in $(meat "$authorizedUserIDs") ; do
1146         userIDs["$nline"]="$line"
1147         nline=$((nline+1))
1148     done
1149
1150     update_authorized_keys "${userIDs[@]}"
1151 }
1152
1153 # takes a gpg key or keys on stdin, and outputs a list of
1154 # fingerprints, one per line:
1155 list_primary_fingerprints() {
1156     local fake=$(msmktempdir)
1157     GNUPGHOME="$fake" gpg --no-tty --quiet --import
1158     GNUPGHOME="$fake" gpg --with-colons --fingerprint --list-keys | \
1159         awk -F: '/^fpr:/{ print $10 }'
1160     rm -rf "$fake"
1161 }
1162
1163
1164 check_cruft_file() {
1165     local loc="$1"
1166     local version="$2"
1167
1168     if [ -e "$loc" ] ; then
1169         printf "! The file '%s' is no longer used by\n  monkeysphere (as of version %s), and can be removed.\n\n" "$loc" "$version" | log info
1170     fi
1171 }
1172
1173 check_upgrade_dir() {
1174     local loc="$1"
1175     local version="$2"
1176
1177     if [ -d "$loc" ] ; then
1178         printf "The presence of directory '%s' indicates that you have\nnot yet completed a monkeysphere upgrade.\nYou should probably run the following script:\n  %s/transitions/%s\n\n" "$loc" "$SYSSHAREDIR" "$version" | log info
1179     fi
1180 }
1181
1182 ## look for cruft from old versions of the monkeysphere, and notice if
1183 ## upgrades have not been run:
1184 report_cruft() {
1185     check_upgrade_dir "${SYSCONFIGDIR}/gnupg-host" 0.23
1186     check_upgrade_dir "${SYSCONFIGDIR}/gnupg-authentication" 0.23
1187
1188     check_cruft_file "${SYSCONFIGDIR}/gnupg-authentication.conf" 0.23
1189     check_cruft_file "${SYSCONFIGDIR}/gnupg-host.conf" 0.23
1190
1191     local found=
1192     for foo in "${SYSDATADIR}/backup-from-"*"-transition"  ; do
1193         if [ -d "$foo" ] ; then
1194             printf "! %s\n" "$foo" | log info
1195             found=true
1196         fi
1197     done
1198     if [ "$found" ] ; then
1199         printf "The directories above are backups left over from a monkeysphere transition.\nThey may contain copies of sensitive data (host keys, certifier lists), but\nthey are no longer needed by monkeysphere.\nYou may remove them at any time.\n\n" | log info
1200     fi
1201 }