ssh指定用户开启google authenticator

最近貌似很流行给ssh加google authenticator，看到好几篇有关的博文了。于是，我也折腾了下。挺简单的，而且arch的aur里直接有google-authenticator-libpam-git这个包，yaourt一下就好了。

但是我并不想所有user都用到google authenticator，因为有几个用来「打洞」的帐号就没必要。这些帐号的shell是无法执行任何命令的，所以不需要再用google authenticator加强安全了，而且对于一些人来说，在手机上安装个软件，然后登录的时候还要看下手机实在是太复杂了。所以设置成选择性的开启google authenticator二次验证。参考

在 /etc/pam.d/sshd 中，在最下面加上

auth		sufficient	pam_listfile.so item=user sense=allow file=/etc/authuser
auth		required	pam_google_authenticator.so

然后新建一个 /etc/authuser 文件，里面写上不需要通过google authenticator验证的用户名。

当用户登录时，会读取 /etc/authuser，如果用户名在里面，就会跳过后面的google authenticator验证，因为auth已经sufficient了。而如果用户名不在那个文件中，就继续下一个auth判断，也就是google authenticator验证。这也就是为什么上面这两句必须写在 /etc/pam.d/sshd 的最下面，如果写在最前面，那么连密码验证都会跳过了。

其他的就简单了，在 /etc/ssh/sshd_config 中修改

ChallengeResponseAuthentication yes

然后以各个账户登录，执行google-authenticator，然后拿着手机对着屏幕拍张照就好了。

其实google authenticator的本质是一个16位的字母加数字随机字符串作为密码，但是这个密码只有服务器和手机上用于生成验证码的程序知道，而用户拿到的是把这个密码通过特定算法加上当时的时间计算出来的数字，同一时间手机和服务器所算出来的应该是一样的，然后验证这个数字就行了，这就避免了密码的泄漏，同时密码可以足够复杂而不需要考虑人类可怜的记忆问题。因为这个项目是开源的，所以也有php版本的。看这里。

顺便搬一个copy过来

<?
/**
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * PHP Google two-factor authentication module.
 *
 * See http://www.idontplaydarts.com/2011/07/google-totp-two-factor-authentication-for-php/
 * for more details
 *
 * @author Phil
 **/
class Google2FA {
        const keyRegeneration   = 30;   // Interval between key regeneration
        const otpLength         = 6;    // Length of the Token generated
        private static $lut = array(    // Lookup needed for Base32 encoding
                "A" => 0,       "B" => 1,
                "C" => 2,       "D" => 3,
                "E" => 4,       "F" => 5,
                "G" => 6,       "H" => 7,
                "I" => 8,       "J" => 9,
                "K" => 10,      "L" => 11,
                "M" => 12,      "N" => 13,
                "O" => 14,      "P" => 15,
                "Q" => 16,      "R" => 17,
                "S" => 18,      "T" => 19,
                "U" => 20,      "V" => 21,
                "W" => 22,      "X" => 23,
                "Y" => 24,      "Z" => 25,
                "2" => 26,      "3" => 27,
                "4" => 28,      "5" => 29,
                "6" => 30,      "7" => 31
        );
        /**
         * Generates a 16 digit secret key in base32 format
         * @return string
         **/
        public static function generate_secret_key($length = 16) {
                $b32    = "234567QWERTYUIOPASDFGHJKLZXCVBNM";
                $s      = "";
                for ($i = 0; $i < $length; $i++)
                        $s .= $b32[rand(0,31)];
                return $s;
        }
        /**
         * Returns the current Unix Timestamp devided by the keyRegeneration
         * period.
         * @return integer
         **/
        public static function get_timestamp() {
                return floor(microtime(true)/self::keyRegeneration);
        }
        /**
         * Decodes a base32 string into a binary string.
         **/
        public static function base32_decode($b32) {
                $b32    = strtoupper($b32);
                if (!preg_match('/^[ABCDEFGHIJKLMNOPQRSTUVWXYZ234567]+$/', $b32, $match))
                        throw new Exception('Invalid characters in the base32 string.');
                $l      = strlen($b32);
                $n      = 0;
                $j      = 0;
                $binary = "";
                for ($i = 0; $i < $l; $i++) {
                        $n = $n << 5;                           // Move buffer left by 5 to make room
                        $n = $n + self::$lut[$b32[$i]];         // Add value into buffer
                        $j = $j + 5;                            // Keep track of number of bits in buffer
                        if ($j >= 8) {
                                $j = $j - 8;
                                $binary .= chr(($n & (0xFF << $j)) >> $j);
                        }
                }
                return $binary;
        }
        /**
         * Takes the secret key and the timestamp and returns the one time
         * password.
         *
         * @param binary $key - Secret key in binary form.
         * @param integer $counter - Timestamp as returned by get_timestamp.
         * @return string
         **/
        public static function oath_hotp($key, $counter)
        {
            if (strlen($key) < 8)
                throw new Exception('Secret key is too short. Must be at least 16 base 32 characters');
            $bin_counter = pack('N*', 0) . pack('N*', $counter);                // Counter must be 64-bit int
            $hash        = hash_hmac ('sha1', $bin_counter, $key, true);
            return str_pad(self::oath_truncate($hash), self::otpLength, '0', STR_PAD_LEFT);
        }
        /**
         * Verifys a user inputted key against the current timestamp. Checks $window
         * keys either side of the timestamp.
         *
         * @param string $b32seed
         * @param string $key - User specified key
         * @param integer $window
         * @param boolean $useTimeStamp
         * @return boolean
         **/
        public static function verify_key($b32seed, $key, $window = 4, $useTimeStamp = true) {
                $timeStamp = self::get_timestamp();
                if ($useTimeStamp !== true) $timeStamp = (int)$useTimeStamp;
                $binarySeed = self::base32_decode($b32seed);
                for ($ts = $timeStamp - $window; $ts <= $timeStamp + $window; $ts++)
                        if (self::oath_hotp($binarySeed, $ts) == $key)
                                return true;
                return false;
        }
        /**
         * Extracts the OTP from the SHA1 hash.
         * @param binary $hash
         * @return integer
         **/
        public static function oath_truncate($hash)
        {
            $offset = ord($hash[19]) & 0xf;
            return (
                ((ord($hash[$offset+0]) & 0x7f) << 24 ) |
                ((ord($hash[$offset+1]) & 0xff) << 16 ) |
                ((ord($hash[$offset+2]) & 0xff) << 8 ) |
                (ord($hash[$offset+3]) & 0xff)
            ) % pow(10, self::otpLength);
        }
}
$InitalizationKey = "PEHMPSDNLXIOG65U";                                 // Set the inital key
$TimeStamp        = Google2FA::get_timestamp();
$secretkey        = Google2FA::base32_decode($InitalizationKey);        // Decode it into binary
$otp              = Google2FA::oath_hotp($secretkey, $TimeStamp);       // Get current token
echo("Init key: $InitalizationKey\n");
echo("Timestamp: $TimeStamp\n");
echo("One time password: $otp\n");
// Use this to verify a key as it allows for some time drift.
$result = Google2FA::verify_key($InitalizationKey, "123456");
var_dump($result);

用的时候先

</dev/urandom tr -dc A-Z2-7 | head -c 16

产生随机密码，替换掉 Set the inital key 那边的那一坨。二维码的生成就用google的api：https://www.google.com/chart?chs=200x200&chld=M|0&cht=qr&chl=otpauth://totp/name?secret=secretkey，把最后的secretkey换成刚才那个密码。然后验证就是拿 $otp 和用户输入的相比较。