yktoken.go

// Copyright (c) 2013 Conformal Systems LLC.
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.

package yubikey

import (
	"crypto/aes"
	"encoding/binary"
	"errors"
	"strings"
)

const (
	BlockSize    = 16
	KeySize      = 16
	OTPSize      = 32 // BlockSize * 2
	UidSize      = 6
	MaxPubIdSize = 32 // BlockSize * 2
	CrcOkResidue = 0xf0b8
)

// Key represents the symmetric 128-bit AES Key
type Key [KeySize]byte

// OTP represents the One Time Password
type OTP [OTPSize]byte

// Uid represents the Private (secret) id.
type Uid [UidSize]byte

// Pub represents the Public id.
type PubID []byte

// Token represents the YubiKey token structure.
type Token struct {
	Uid   Uid
	Ctr   uint16
	Tstpl uint16
	Tstph uint8
	Use   uint8
	Rnd   uint16
	Crc   uint16
}

var (
	ErrCrcFailure       = errors.New("yubikey: CRC failure")
	ErrInvalidOTPString = errors.New("yubikey: invalid OTP string")
	ErrInvalidPubIdLen  = errors.New("yubikey: invalid public id length")
)

// NewToken is a helper function to create a new Token.
// The CRC is calculated for the caller.
func NewToken(uid Uid, ctr, tstpl uint16, tstph, use uint8, rnd uint16) *Token {
	token := Token{
		Uid:   uid,
		Ctr:   ctr,
		Tstpl: tstpl,
		Tstph: tstph,
		Use:   use,
		Rnd:   rnd,
	}

	// Calculate CRC
	buf := token.Bytes()

	token.Crc = ^crc16(buf[:14])

	return &token
}

// NewTokenFromBytes converts a byte stream into a Token.
// An error will be returned on a CRC failure.
func NewTokenFromBytes(buf []byte) (*Token, error) {
	var token Token

	// This goes first to avoid buf->token->buf dance that would happen if it was at the end
	if len(buf) != 16 || !Crc16BufOkP(buf) {
		return nil, ErrCrcFailure
	}

	copy(token.Uid[:], buf[:6])

	token.Ctr = binary.LittleEndian.Uint16(buf[6:])
	token.Tstpl = binary.LittleEndian.Uint16(buf[8:])

	token.Tstph = buf[10]
	token.Use = buf[11]

	token.Rnd = binary.LittleEndian.Uint16(buf[12:])
	token.Crc = binary.LittleEndian.Uint16(buf[14:])

	return &token, nil
}

// Generate encrypts a Token with the specified Key
// and returns a OTP.
func (t *Token) Generate(key Key) *OTP {
	buf := t.Bytes()

	cipher, _ /* ignored */ := aes.NewCipher(key[:])
	cipher.Encrypt(buf, buf)

	buf = ModHexEncode(buf)

	var o OTP
	copy(o[:], buf)

	return &o
}

// Capslock returns true if the token was generated by the users pressing the capslock key
func (t *Token) Capslock() bool {
	return t.Ctr&0x8000 == 0x8000
}

func (t *Token) Counter() uint16 {
	return t.Ctr & 0x7fff
}

func (t *Token) CrcOkP() bool {
	return t.Crc16() == CrcOkResidue
}

// Crc16 returns the CRC associated with the Token.
func (t *Token) Crc16() uint16 {
	buf := t.Bytes()

	return crc16(buf)
}

func Crc16BufOkP(buf []byte) bool {
	return crc16(buf) == CrcOkResidue
}

func crc16(buf []byte) uint16 {
	m_crc := uint16(0xffff)
	for _, val := range buf {
		m_crc ^= uint16(val & 0xff)
		for i := 0; i < 8; i++ {
			j := m_crc & 1
			m_crc >>= 1
			if j > 0 {
				m_crc ^= 0x8408
			}
		}
	}

	return m_crc
}

// Bytes returns the byte stream associated with
// the Token.
func (t *Token) Bytes() []byte {
	buf := make([]byte, 16)

	copy(buf[:6], t.Uid[:])
	binary.LittleEndian.PutUint16(buf[6:], t.Ctr)
	binary.LittleEndian.PutUint16(buf[8:], t.Tstpl)
	buf[10] = t.Tstph
	buf[11] = t.Use
	binary.LittleEndian.PutUint16(buf[12:], t.Rnd)
	binary.LittleEndian.PutUint16(buf[14:], t.Crc)

	return buf
}

// NewKey the specified string to a Key structure.
func NewKey(buf []byte) Key {
	var key Key
	copy(key[:], buf)

	return key
}

// NewOTP converts a string into an OTP structure.
func NewOTP(buf string) OTP {
	var otp OTP
	copy(otp[:], buf)

	return otp
}

// ParseOTPString returns an OTP and public id from an OTP string.
func ParseOTPString(str string) (PubID, OTP, error) {
	var pubid PubID
	var otp OTP
	var err error

	// Remove any newlines from the OTP string.
	str = strings.TrimSpace(str)
	strLen := len(str)

	if strLen <= OTPSize {
		return pubid, otp, ErrInvalidOTPString
	}

	otpStart := strLen - OTPSize

	pubid, err = NewPubID(str[:otpStart])
	if err != nil {
		return pubid, otp, err
	}
	otp = NewOTP(str[otpStart:])
	return pubid, otp, nil
}

// Parse decodes and decrypts the OTP with the specified Key
// returning a Token.
func (o OTP) Parse(key Key) (*Token, error) {
	buf := o.Bytes()

	buf = ModHexDecode(buf)

	cipher, _ /* ignored */ := aes.NewCipher(key[:])
	cipher.Decrypt(buf, buf)

	token, err := NewTokenFromBytes(buf)
	if err != nil {
		return nil, err
	}

	return token, nil
}

// Bytes returns the byte stream associated with
// the OTP.
func (o OTP) Bytes() []byte {
	buf := make([]byte, len(o))
	copy(buf, o[:])

	return buf
}

func NewPubID(str string) (PubID, error) {
	if len(str) < 1 || len(str) > MaxPubIdSize {
		return nil, ErrInvalidPubIdLen
	}
	pubid := make(PubID, len(str))
	copy(pubid, []byte(str))

	return pubid, nil
}

// NewUid returns a UID structure.
func NewUid(buf []byte) Uid {
	var uid Uid
	copy(uid[:], buf)

	return uid
}