yubikey/init.lua

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
local _M = {};

local aeslua = require "aeslua";
local ciphermode = require "aeslua.ciphermode";
local crc16 = require "crc16";

local modhex2hex;
do
	local modhex_map = {};
	local modhex_chars = "cbdefghijklnrtuv";
	for i=1,16 do
		modhex_map[modhex_chars:sub(i,i)] = ("%x"):format(i-1);
	end
	function modhex2hex(modhex)
		if modhex then
			return (modhex:gsub(".", modhex_map));
		end
	end
end
_M.modhex2hex = modhex2hex;

local function hex2bin(hex)
	if hex then
		return (hex:gsub("..", function (c) return string.char(tonumber(c, 16)); end));
	end
end
_M.hex2bin = hex2bin;

local function bin2hex(bin)
	if bin then
		return (bin:gsub(".", function (b) return ("%02x"):format(b:byte()); end));
	end
end
_M.bin2hex = bin2hex;

local otp_parser = {};
local otp_parser_mt = { __index = otp_parser };

function _M.new_fetch_key_hex(fetchkeyhex)
	return function (...) return hex2bin(fetchkeyhex(...)); end
end

function _M.new_otp_parser(config)
	return setmetatable({
		config = config,
	}, otp_parser_mt);
end

function otp_parser:parse(otp, key)
	-- Password is any extra data before the real OTP
	local password;
	if #otp > 32 + self.config.prefix_length then
		password = otp:sub(1, #otp - (32 + self.config.prefix_length));
		otp = otp:sub(#password+1);
	end
	local prefix = otp:sub(1, self.config.prefix_length);
	local token = otp:sub(#prefix+1);
	if not key then
		key = self.config.fetch_key(prefix);
	else
		key = hex2bin(key);
	end
	if not key then return false, "no-key"; end
	key = {key:byte(1,#key)}
	local decrypted = ciphermode.decryptString(key, hex2bin(modhex2hex(token)), ciphermode.decryptCBC);
	if not decrypted then return false, "decrypt-failed"; end
	-- Extract private UID
	local uid = decrypted:sub(1,6);
	-- Build insertion counter (2 bytes)
	local use1, use2 = decrypted:sub(7,8):byte(1,2);
	local use_ctr = use1 + math.pow(2, 8)*use2;
	-- Build timestamp (3 bytes)
	local time1, time2, time3 = decrypted:sub(9,11):byte(1,3);
	local timestamp = time1 + math.pow(2,8)*time2 + math.pow(2, 16)*time3;
	-- Extract session counter (1 byte)
	local session_ctr = decrypted:sub(12, 12):byte();
	
	if crc16.hash(decrypted) ~= 0xf0b8 then
		return false, "invalid-checksum";
	end
	
	-- Return parsed fields
	return true, {
		password = password;
		public_id = prefix;
		token = token;
		private_id = bin2hex(uid);
		session_counter = session_ctr;
		use_counter = use_ctr;
		timestamp = timestamp;
	};
end

function _M.new_authenticator(config)
	local parser = _M.new_otp_parser(config);
	local function authenticate(self, otp, key, device_info, userdata)
		-- Parse OTP, get device data (from config callback)
		local ok, ret = parser:parse(otp, key);
		if not ok then return ok, ret; end
		
		if not device_info then
			device_info = config.fetch_device_info(ret);
		end
		
		if ret.use_counter < (device_info.use_counter or 0)
		or ((ret.use_counter == (device_info.use_counter or 0))
		  and (ret.session_counter <= (device_info.session_counter or 0))) then
			return false, "otp-already-used";
		end
		
		local authed, err = config.check_credentials(ret, device_info, userdata);
		if not authed then return authed, err; end
		
		device_info.use_counter = ret.use_counter;
		device_info.session_counter = ret.session_counter;
		
		config.store_device_info(device_info, userdata);
		
		return true, ret;
	end
	return { authenticate = authenticate };
end

return _M;