File tpm-fido-20230621.5f8828b.obscpio of Package tpm-fido

Overview Repositories Revisions Requests Users Attributes Meta

File tpm-fido-20230621.5f8828b.obscpio of Package tpm-fido

07070100000000000041ED0000000000000000000000016493935C00000000000000000000000000000000000000000000002200000000tpm-fido-20230621.5f8828b/.github07070100000001000041ED0000000000000000000000016493935C00000000000000000000000000000000000000000000002C00000000tpm-fido-20230621.5f8828b/.github/workflows07070100000002000081A40000000000000000000000016493935C000002F4000000000000000000000000000000000000003300000000tpm-fido-20230621.5f8828b/.github/workflows/go.ymlname: Go
on: [push, pull_request]
jobs:

build:
    name: Build/Test
    runs-on: ${{ matrix.os }}
    timeout-minutes: 3
    strategy:
      matrix:
        go-version: [1.19.10, 1.20.5]
        os: [ubuntu-latest]

steps:
    - name: Set up Go
      uses: actions/setup-go@v4
      with:
        go-version: ${{ matrix.go-version }}
      id: go

- name: Check out code into the Go module directory
      uses: actions/checkout@v3

- name: Build
      run: go build -v ./...

- name: Test
      run: go test -v ./... --timeout 60s

- name: Cross test for i386
      run: env GOOS=linux GOARCH=386 go test -v ./... --timeout 60s

- name: Cross compile for arm (RPI)
      run: env GOOS=linux GOARCH=arm GOARM=5 go build -v ./...
07070100000003000081A40000000000000000000000016493935C00000438000000000000000000000000000000000000002200000000tpm-fido-20230621.5f8828b/LICENSEThe MIT License (MIT)

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
07070100000004000081A40000000000000000000000016493935C000008B3000000000000000000000000000000000000002400000000tpm-fido-20230621.5f8828b/Readme.md# tpm-fido

tpm-fido is FIDO token implementation for Linux that protects the token keys by using your system's TPM. tpm-fido uses Linux's [uhid](https://github.com/psanford/uhid) facility to emulate a USB HID device so that it is properly detected by browsers.

##  Implementation details

tpm-fido uses the TPM 2.0 API. The overall design is as follows:

On registration tpm-fido generates a new P256 primary key under the Owner hierarchy on the TPM. To ensure that the key is unique per site and registration, tpm-fido generates a random 20 byte seed for each registration. The primary key template is populated with unique values from a sha256 hkdf of the 20 byte random seed and the application parameter provided by the browser.

A signing child key is then generated from that primary key. The key handle returned to the caller is a concatenation of the child key's public and private key handles and the 20 byte seed.

On an authentication request, tpm-fido will attempt to load the primary key by initializing the hkdf in the same manner as above. It will then attempt to load the child key from the provided key handle. Any incorrect values or values created by a different TPM will fail to load.

## Status

tpm-fido has been tested to work with Chrome and Firefox on Linux.

## Building

```
# in the root directory of tpm-fido run:
go build
```

## Running

In order to run `tpm-fido` you will need permission to access `/dev/tpmrm0`. On Ubuntu and Arch, you can add your user to the `tss` group.

Your user also needs permission to access `/dev/uhid` so that `tpm-fido` can appear to be a USB device.
I use the following udev rule to set the appropriate `uhid` permissions:

```
KERNEL=="uhid", SUBSYSTEM=="misc", GROUP="SOME_UHID_GROUP_MY_USER_BELONGS_TO", MODE="0660"
```

To ensure the above udev rule gets triggered, I also add the `uhid` module to `/etc/modules-load.d/uhid.conf` so that it loads at boot.

To run:

```
# as a user that has permission to read and write to /dev/tpmrm0:
./tpm-fido
```
Note: do not run with `sudo` or as root, as it will not work.

## Dependencies

tpm-fido requires `pinentry` to be available on the system. If you have gpg installed you most likely already have `pinentry`.
07070100000005000041ED0000000000000000000000016493935C00000000000000000000000000000000000000000000002600000000tpm-fido-20230621.5f8828b/attestation07070100000006000081A40000000000000000000000016493935C000005E0000000000000000000000000000000000000003500000000tpm-fido-20230621.5f8828b/attestation/attestation.gopackage attestation

import (
	"crypto/ecdsa"
	"crypto/x509"
	"encoding/pem"
)

// this is the same cert used by github/SoftU2F
// https://github.com/github/SoftU2F/blob/master/SelfSignedCertificate/SelfSignedCertificate.m
// We resuse that cert to help reduce the ability to track
// an individual using this cert

var attestationPrivateKeyPem = `-----BEGIN PRIVATE KEY-----
MHcCAQEEIAOEKsf0zeNn3qBWxk9/OxXqfUvEg8rGl58qMZOtVzEJoAoGCCqGSM49
AwEHoUQDQgAE9pyrJBRLtO+H9w8jHFzU9XgErPjgxrKz41IYPYA5H2vSedJqTINk
dObC2iOT/6wdUDRsXCOQZVeTPsuT/27e0Q==
-----END PRIVATE KEY-----`

var attestationCertPem = `-----BEGIN CERTIFICATE-----
MIIBfjCCASSgAwIBAgIBATAKBggqhkjOPQQDAjA8MREwDwYDVQQDDAhTb2Z0IFUy
RjEUMBIGA1UECgwLR2l0SHViIEluYy4xETAPBgNVBAsMCFNlY3VyaXR5MB4XDTE3
MDcyNjIwMDkwOFoXDTI3MDcyNDIwMDkwOFowPDERMA8GA1UEAwwIU29mdCBVMkYx
FDASBgNVBAoMC0dpdEh1YiBJbmMuMREwDwYDVQQLDAhTZWN1cml0eTBZMBMGByqG
SM49AgEGCCqGSM49AwEHA0IABPacqyQUS7Tvh/cPIxxc1PV4BKz44Mays+NSGD2A
OR9r0nnSakyDZHTmwtojk/+sHVA0bFwjkGVXkz7Lk/9u3tGjFzAVMBMGCysGAQQB
guUcAgEBBAQDAgMIMAoGCCqGSM49BAMCA0gAMEUCIQD+Ih2XuOrqErufQhSFD0gX
ZbXglZNeoaPWbQ+xbzn3IgIgZNfcL1xsOCr3ZfV4ajmwsUqXRSjvfd8hAhUbiErU
QXo=
-----END CERTIFICATE-----`

var (
	CertDer    []byte
	PrivateKey *ecdsa.PrivateKey
)

func init() {
	certDer, _ := pem.Decode([]byte(attestationCertPem))
	CertDer = certDer.Bytes

privKeyDer, _ := pem.Decode([]byte(attestationPrivateKeyPem))

var err error
	PrivateKey, err = x509.ParseECPrivateKey(privKeyDer.Bytes)
	if err != nil {
		panic(err)
	}
}
07070100000007000081A40000000000000000000000016493935C000009FE000000000000000000000000000000000000003A00000000tpm-fido-20230621.5f8828b/attestation/attestation_test.gopackage attestation

import (
	"bytes"
	"testing"
)

func TestAttestationCert(t *testing.T) {
	rawCert := []byte{
		0x30, 0x82, 0x01, 0x7e, 0x30, 0x82, 0x01, 0x24, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x01, 0x01,
		0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, 0x30, 0x3c, 0x31, 0x11,
		0x30, 0x0f, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, 0x08, 0x53, 0x6f, 0x66, 0x74, 0x20, 0x55, 0x32,
		0x46, 0x31, 0x14, 0x30, 0x12, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x0c, 0x0b, 0x47, 0x69, 0x74, 0x48,
		0x75, 0x62, 0x20, 0x49, 0x6e, 0x63, 0x2e, 0x31, 0x11, 0x30, 0x0f, 0x06, 0x03, 0x55, 0x04, 0x0b,
		0x0c, 0x08, 0x53, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x30, 0x1e, 0x17, 0x0d, 0x31, 0x37,
		0x30, 0x37, 0x32, 0x36, 0x32, 0x30, 0x30, 0x39, 0x30, 0x38, 0x5a, 0x17, 0x0d, 0x32, 0x37, 0x30,
		0x37, 0x32, 0x34, 0x32, 0x30, 0x30, 0x39, 0x30, 0x38, 0x5a, 0x30, 0x3c, 0x31, 0x11, 0x30, 0x0f,
		0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, 0x08, 0x53, 0x6f, 0x66, 0x74, 0x20, 0x55, 0x32, 0x46, 0x31,
		0x14, 0x30, 0x12, 0x06, 0x03, 0x55, 0x04, 0x0a, 0x0c, 0x0b, 0x47, 0x69, 0x74, 0x48, 0x75, 0x62,
		0x20, 0x49, 0x6e, 0x63, 0x2e, 0x31, 0x11, 0x30, 0x0f, 0x06, 0x03, 0x55, 0x04, 0x0b, 0x0c, 0x08,
		0x53, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2a, 0x86,
		0x48, 0xce, 0x3d, 0x02, 0x01, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03,
		0x42, 0x00, 0x04, 0xf6, 0x9c, 0xab, 0x24, 0x14, 0x4b, 0xb4, 0xef, 0x87, 0xf7, 0x0f, 0x23, 0x1c,
		0x5c, 0xd4, 0xf5, 0x78, 0x04, 0xac, 0xf8, 0xe0, 0xc6, 0xb2, 0xb3, 0xe3, 0x52, 0x18, 0x3d, 0x80,
		0x39, 0x1f, 0x6b, 0xd2, 0x79, 0xd2, 0x6a, 0x4c, 0x83, 0x64, 0x74, 0xe6, 0xc2, 0xda, 0x23, 0x93,
		0xff, 0xac, 0x1d, 0x50, 0x34, 0x6c, 0x5c, 0x23, 0x90, 0x65, 0x57, 0x93, 0x3e, 0xcb, 0x93, 0xff,
		0x6e, 0xde, 0xd1, 0xa3, 0x17, 0x30, 0x15, 0x30, 0x13, 0x06, 0x0b, 0x2b, 0x06, 0x01, 0x04, 0x01,
		0x82, 0xe5, 0x1c, 0x02, 0x01, 0x01, 0x04, 0x04, 0x03, 0x02, 0x03, 0x08, 0x30, 0x0a, 0x06, 0x08,
		0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, 0x03, 0x48, 0x00, 0x30, 0x45, 0x02, 0x21, 0x00,
		0xfe, 0x22, 0x1d, 0x97, 0xb8, 0xea, 0xea, 0x12, 0xbb, 0x9f, 0x42, 0x14, 0x85, 0x0f, 0x48, 0x17,
		0x65, 0xb5, 0xe0, 0x95, 0x93, 0x5e, 0xa1, 0xa3, 0xd6, 0x6d, 0x0f, 0xb1, 0x6f, 0x39, 0xf7, 0x22,
		0x02, 0x20, 0x64, 0xd7, 0xdc, 0x2f, 0x5c, 0x6c, 0x38, 0x2a, 0xf7, 0x65, 0xf5, 0x78, 0x6a, 0x39,
		0xb0, 0xb1, 0x4a, 0x97, 0x45, 0x28, 0xef, 0x7d, 0xdf, 0x21, 0x02, 0x15, 0x1b, 0x88, 0x4a, 0xd4,
		0x41, 0x7a,
	}

if !bytes.Equal(CertDer, rawCert) {
		t.Fatalf("cert der mismatch")
	}
}
07070100000008000041ED0000000000000000000000016493935C00000000000000000000000000000000000000000000002300000000tpm-fido-20230621.5f8828b/fidoauth07070100000009000081A40000000000000000000000016493935C000009AA000000000000000000000000000000000000002F00000000tpm-fido-20230621.5f8828b/fidoauth/fidoauth.go// fidoauth implements the fido1 authentication API
package fidoauth

import (
	"fmt"
)

const (
	CmdRegister     = 0x01
	CmdAuthenticate = 0x02
	CmdVersion      = 0x03

CtrlCheckOnly                     AuthCtrl = 0x07 // Check if the provided key is valid
	CtrlEnforeUserPresenceAndSign     AuthCtrl = 0x03 // confirm with user then sign
	CtrlDontEnforeUserPresenceAndSign AuthCtrl = 0x08 // just sign without confirming
)

type AuthenticatorRequest struct {
	Command uint8
	Param1  uint8
	Param2  uint8
	Size    int
	Data    []byte

type AuthenticatorRegisterReq struct {
	ChallengeParam   [32]byte
	ApplicationParam [32]byte
}

type AuthenticatorResponse struct {
	Data   []byte
	Status uint16
}

type AuthCtrl uint8

type AuthenticatorAuthReq struct {
	Ctrl             AuthCtrl
	ChallengeParam   [32]byte
	ApplicationParam [32]byte
	KeyHandle        []byte
}

func DecodeAuthenticatorRequest(raw []byte) (*AuthenticatorRequest, error) {
	if len(raw) < 7 {
		return nil, fmt.Errorf("authenticator request too short")
	}

req := AuthenticatorRequest{
		Command: raw[1],
		Param1:  raw[2],
		Param2:  raw[3],
		Size:    (int(raw[4]) << 16) | (int(raw[5]) << 8) | int(raw[6]),
		Data:    raw[7:],
	}

if req.Command == CmdRegister {
		var reg AuthenticatorRegisterReq
		if len(req.Data) < len(reg.ChallengeParam)+len(reg.ApplicationParam) {
			return nil, fmt.Errorf("register request incorrect size: %d", len(req.Data))
		}

copy(reg.ChallengeParam[:], req.Data[:32])
		copy(reg.ApplicationParam[:], req.Data[32:])
		req.Register = &reg
	} else if req.Command == CmdAuthenticate {
		var auth AuthenticatorAuthReq

if len(req.Data) < len(auth.ChallengeParam)+len(auth.ApplicationParam)+2 {
			return nil, fmt.Errorf("authenticate request too small: %d", len(req.Data))
		}

auth.Ctrl = AuthCtrl(req.Param1)

switch auth.Ctrl {
		case CtrlCheckOnly, CtrlEnforeUserPresenceAndSign, CtrlDontEnforeUserPresenceAndSign:
		default:
			return nil, fmt.Errorf("unknown ctrl type: %02x", auth.Ctrl)
		}

data := req.Data
		copy(auth.ChallengeParam[:], data[:32])
		data = data[32:]

copy(auth.ApplicationParam[:], data[:32])
		data = data[32:]

khLen := data[0]
		data = data[1:]

if len(data) < int(khLen) {
			return nil, fmt.Errorf("key handle len too short %d vs %d", len(data), int(khLen))
		}

auth.KeyHandle = data[:khLen]
		req.Authenticate = &auth
	}

return &req, nil
}
0707010000000A000041ED0000000000000000000000016493935C00000000000000000000000000000000000000000000002200000000tpm-fido-20230621.5f8828b/fidohid0707010000000B000081A40000000000000000000000016493935C000029B2000000000000000000000000000000000000002D00000000tpm-fido-20230621.5f8828b/fidohid/fidohid.gopackage fidohid

import (
	"bytes"
	"context"
	"crypto/rand"
	"encoding/binary"
	"fmt"
	"io"
	"log"

"github.com/psanford/tpm-fido/fidoauth"
	"github.com/psanford/uhid"
)

func New(ctx context.Context, name string) (*SoftToken, error) {
	d, err := uhid.NewDevice(name, rdesc)
	if err != nil {
		return nil, err
	}

d.Data.Bus = busUSB
	d.Data.VendorID = vendorID
	d.Data.ProductID = productID

evtChan, err := d.Open(ctx)
	if err != nil {
		return nil, err
	}

t := SoftToken{
		device:    d,
		evtChan:   evtChan,
		authEvent: make(chan AuthEvent),
	}

return &t, nil
}

type SoftToken struct {
	device    *uhid.Device
	evtChan   chan uhid.Event
	authEvent chan AuthEvent

authFunc func()
}

type AuthEvent struct {
	chanID uint32
	cmd    CmdType

Req   *fidoauth.AuthenticatorRequest
	Error error
}

func (t *SoftToken) Events() chan AuthEvent {
	return t.authEvent
}

func (t *SoftToken) Run(ctx context.Context) {
	channels := make(map[uint32]bool)
	allocateChan := func() (uint32, bool) {
		for k := uint32(1); k < (1<<32)-1; k++ {
			inUse := channels[k]
			if !inUse {
				channels[k] = true
				return k, true
			}
		}
		return 0, false
	}

pktChan := make(chan Packet)
	go parsePackets(ctx, t.evtChan, pktChan)

for {
		var (
			innerMsg  []byte
			needSize  uint16
			reqChanID uint32
			cmd       CmdType
		)

for pkt := range pktChan {
			if pkt.IsInitial {
				if len(innerMsg) > 0 {
					log.Print("new initial packet while pending packets still exist")
					innerMsg = make([]byte, 0)
					needSize = 0
				}
				needSize = pkt.TotalSize
				reqChanID = pkt.ChannelID
				cmd = pkt.Command
			}
			innerMsg = append(innerMsg, pkt.Data...)
			if len(innerMsg) >= int(needSize) {
				break
			}
		}

innerMsg = innerMsg[:int(needSize)]

switch cmd {
		case CmdInit:
			chanID, ok := allocateChan()
			if !ok {
				log.Fatalf("Channel id exhaustion")
			}

var nonce [8]byte
			copy(nonce[:], innerMsg)

resp := newInitResponse(chanID, nonce)

err := writeRespose(t.device, reqChanID, CmdInit, resp.Marshal(), 0)
			if err != nil {
				log.Printf("Write Init resp err: %s", err)
				continue
			}
		case CmdMsg:
			req, err := fidoauth.DecodeAuthenticatorRequest(innerMsg)

evt := AuthEvent{
				chanID: reqChanID,
				cmd:    cmd,
				Req:    req,
				Error:  err,
			}

select {
			case t.authEvent <- evt:
			case <-ctx.Done():
				return
			}
		default:
			log.Printf("unsuppoted cmd: %s %d", cmd, cmd)
			writeRespose(t.device, reqChanID, cmd, nil, swInsNotSupported)
		}
	}
}

const (
	busUSB = 0x03

vendorID  = 0x15d9
	productID = 0x0a37

frameTypeInit = 0x80
	frameTypeCont = 0x00

CmdPing  CmdType = 0x01 // Echo data through local processor only
	CmdMsg   CmdType = 0x03 // Send U2F message frame
	CmdLock  CmdType = 0x04 // Send lock channel command
	CmdInit  CmdType = 0x06 // Channel initialization
	CmdWink  CmdType = 0x08 // Send device identification wink
	CmdCbor  CmdType = 0x10 // Send encapsulated CTAP CBOR
	CmdSync  CmdType = 0x3c // Protocol resync command
	CmdError CmdType = 0x3f // Error response

vendorSpecificFirstCmd = 0x40
	vendorSpecificLastCmd  = 0x7f

reportLen            = 64
	initialPacketDataLen = reportLen - 7
	contPacketDataLen    = reportLen - 5

u2fProtocolVersion = 2
	deviceMajor        = 1
	deviceMinor        = 0
	deviceBuild        = 0
	winkCapability     = 0x01
	lockCapability     = 0x02
	cborCapability     = 0x04
	nmsgCapability     = 0x08

swInsNotSupported = 0x6D00 // The Instruction of the request is not supported
)

type CmdType uint8

func (c CmdType) IsVendorSpecific() bool {
	return c >= vendorSpecificFirstCmd && c <= vendorSpecificLastCmd
}

func (c CmdType) String() string {
	switch c {
	case CmdPing:
		return "CmdPing"
	case CmdMsg:
		return "CmdMsg"
	case CmdLock:
		return "CmdLock"
	case CmdInit:
		return "CmdInit"
	case CmdWink:
		return "CmdWink"
	case CmdSync:
		return "CmdSync"
	case CmdError:
		return "CmdError"
	case CmdCbor:
		return "CmdCbor"
	}

if c >= vendorSpecificFirstCmd && c <= vendorSpecificLastCmd {
		return fmt.Sprintf("CmdVendor<%d>", c)
	}
	return fmt.Sprintf("CmdUnknown<%d>", c)
}

// src: http://www.usb.org/developers/hidpage/HUTRR48.pdf
var rdesc = []byte{
	0x06, 0xd0, 0xf1, //	USAGE_PAGE (FIDO Alliance)
	0x09, 0x01, //				USAGE (U2F HID Authenticator Device)
	0xa1, 0x01, //				COLLECTION (Application)
	0x09, 0x20, //					USAGE (Input Report Data)
	0x15, 0x00, //					LOGICAL_MINIMUM (0)
	0x26, 0xff, 0x00, //		LOGICAL_MAXIMUM (255)
	0x75, 0x08, //					REPORT_SIZE (8)
	0x95, 0x40, //					REPORT_COUNT (64)
	0x81, 0x02, //					INPUT (Data,Var,Abs)
	0x09, 0x21, //					USAGE (Output Report Data)
	0x15, 0x00, //					LOGICAL_MINIMUM (0)
	0x26, 0xff, 0x00, //		LOGICAL_MAXIMUM (255)
	0x75, 0x08, //					REPORT_SIZE (8)
	0x95, 0x40, //					REPORT_COUNT (64)
	0x91, 0x02, //					OUTPUT (Data,Var,Abs)
	0xc0, //							END_COLLECTION
}

func parsePackets(ctx context.Context, evtChan chan uhid.Event, pktChan chan Packet) {
	for {
		var (
			evt uhid.Event
			ok  bool
		)

select {
		case evt, ok = <-evtChan:
			if !ok {
				return
			}
		case <-ctx.Done():
			return
		}

if evt.Err != nil {
			log.Fatalf("got evt err: %s", evt.Err)
		}

// Output means the kernel has sent us data
		if evt.Type == uhid.Output {

r := newPacketReader(bytes.NewReader(evt.Data))
			b1 := make([]byte, 1)
			r.ReadFull(b1) // ignore first byte

var channelID uint32
			r.Read(binary.BigEndian, &channelID)

_, err := r.ReadFull(b1)
			if err != nil {
				log.Printf("U2F protocol read error")
				continue
			}
			typeOrSeqNo := b1[0]

if typeOrSeqNo&frameTypeInit == frameTypeInit {
				typ := typeOrSeqNo
				cmd := typ ^ frameTypeInit

var totalSize uint16
				r.Read(binary.BigEndian, &totalSize)

data := make([]byte, initialPacketDataLen)
				_, err := r.ReadFull(data)
				if err != nil {
					log.Printf("U2F protocol read error")
					continue
				}

p := Packet{
					ChannelID: channelID,
					IsInitial: true,
					Command:   CmdType(cmd),
					TotalSize: totalSize,
					Data:      data,
				}

select {
				case pktChan <- p:
				case <-ctx.Done():
					return
				}
			} else {
				seqNo := typeOrSeqNo

data := make([]byte, contPacketDataLen)
				_, err := r.ReadFull(data)
				if err != nil {
					log.Printf("U2F protocol read error")
					continue
				}

p := Packet{
					ChannelID: channelID,
					SeqNo:     seqNo,
					Data:      data,
				}

select {
				case pktChan <- p:
				case <-ctx.Done():
					return
				}
			}
		}
	}
}

type Packet struct {
	ChannelID uint32
	IsInitial bool
	Command   CmdType
	SeqNo     byte
	TotalSize uint16
	Data      []byte
}

func newPacketReader(r io.Reader) *packetReader {
	return &packetReader{
		r: r,
	}
}

type packetReader struct {
	r   io.Reader
	err error
}

func (r *packetReader) Error() error {
	return r.err
}

func (pr *packetReader) Read(order binary.ByteOrder, data interface{}) error {
	if pr.err != nil {
		return pr.err
	}

err := binary.Read(pr.r, order, data)
	if err != nil {
		pr.err = err
	}
	return err
}

func (pr *packetReader) ReadFull(b []byte) (int, error) {
	if pr.err != nil {
		return 0, pr.err
	}

n, err := io.ReadFull(pr.r, b)
	if err != nil {
		pr.err = err
		return n, err
	}
	return n, nil
}

func mustRand(size int) []byte {
	b := make([]byte, size)
	if _, err := rand.Read(b); err != nil {
		panic(err)
	}

return b
}

type frameInit struct {
	ChannelID       uint32
	Command         uint8
	Data            []byte
	TotalPayloadLen uint16
}

func (fi *frameInit) Marshal() []byte {
	buf := new(bytes.Buffer)
	binary.Write(buf, binary.BigEndian, fi.ChannelID)
	buf.WriteByte(fi.Command)
	binary.Write(buf, binary.BigEndian, fi.TotalPayloadLen)
	buf.Write(fi.Data)
	if len(fi.Data) < initialPacketDataLen {
		pad := make([]byte, initialPacketDataLen-len(fi.Data))
		buf.Write(pad)
	}

return buf.Bytes()
}

type frameCont struct {
	ChannelID uint32
	SeqNo     uint8
	Data      []byte
}

func (fi *frameCont) Marshal() []byte {
	buf := new(bytes.Buffer)
	binary.Write(buf, binary.BigEndian, fi.ChannelID)
	buf.WriteByte(fi.SeqNo)
	buf.Write(fi.Data)
	if len(fi.Data) < contPacketDataLen {
		pad := make([]byte, contPacketDataLen-len(fi.Data))

buf.Write(pad)
	}
	return buf.Bytes()
}

type initResponse struct {
	Nonce              [8]byte
	Channel            uint32
	ProtocolVersion    byte
	MajorDeviceVersion byte
	MinorDeviceVersion byte
	BuildDeviceVersion byte
	RawCapabilities    byte
}

func newInitResponse(channelID uint32, nonce [8]byte) *initResponse {
	return &initResponse{
		Nonce:              nonce,
		Channel:            channelID,
		ProtocolVersion:    u2fProtocolVersion,
		MajorDeviceVersion: deviceMajor,
		MinorDeviceVersion: deviceMinor,
		BuildDeviceVersion: deviceBuild,
		// RawCapabilities:    winkCapability,
	}
}

func (resp *initResponse) Marshal() []byte {
	buf := new(bytes.Buffer)
	buf.Write(resp.Nonce[:])
	binary.Write(buf, binary.BigEndian, resp.Channel)
	buf.Write([]byte{
		resp.ProtocolVersion,
		resp.MajorDeviceVersion,
		resp.MinorDeviceVersion,
		resp.BuildDeviceVersion,
		resp.RawCapabilities,
	})

return buf.Bytes()
}

func (t *SoftToken) WriteResponse(ctx context.Context, evt AuthEvent, data []byte, status uint16) error {
	return writeRespose(t.device, evt.chanID, evt.cmd, data, status)
}

func writeRespose(d *uhid.Device, chanID uint32, cmd CmdType, data []byte, status uint16) error {

initial := true
	pktSize := initialPacketDataLen

if status > 0 {
		statusBytes := make([]byte, 2)
		binary.BigEndian.PutUint16(statusBytes, status)
		data = append(data, statusBytes...)
	}

totalSize := uint16(len(data))
	var seqNo uint8
	for len(data) > 0 {
		sliceSize := pktSize
		if len(data) < sliceSize {
			sliceSize = len(data)
		}

pktData := data[:sliceSize]
		data = data[sliceSize:]

if initial {
			initial = false
			pktSize = contPacketDataLen
			frame := frameInit{
				ChannelID:       chanID,
				Command:         uint8(cmd) | frameTypeInit,
				Data:            pktData,
				TotalPayloadLen: totalSize,
			}

payload := frame.Marshal()

resp := uhid.Input2Request{
				RequestType: uhid.Input2,
				DataSize:    uint16(len(payload)),
			}
			copy(resp.Data[:], payload)

err := d.WriteEvent(resp)
			if err != nil {
				return err
			}
		} else {
			frame := frameCont{
				ChannelID: chanID,
				SeqNo:     seqNo,
				Data:      pktData,
			}

payload := frame.Marshal()

resp := uhid.Input2Request{
				RequestType: uhid.Input2,
				DataSize:    uint16(len(payload)),
			}
			copy(resp.Data[:], payload)

err := d.WriteEvent(resp)
			if err != nil {
				return err
			}
			seqNo++
		}
	}

return nil
}
0707010000000C000081A40000000000000000000000016493935C000000F4000000000000000000000000000000000000002100000000tpm-fido-20230621.5f8828b/go.modmodule github.com/psanford/tpm-fido

go 1.16

require (
	github.com/foxcpp/go-assuan v1.0.0
	github.com/google/go-tpm v0.3.2
	github.com/psanford/uhid v0.0.0-20210426002309-4864eff247db
	golang.org/x/crypto v0.0.0-20210513164829-c07d793c2f9a
)
0707010000000D000081A40000000000000000000000016493935C00004AD6000000000000000000000000000000000000002100000000tpm-fido-20230621.5f8828b/go.sumcloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8=
github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
github.com/coreos/bbolt v1.3.2/go.mod h1:iRUV2dpdMOn7Bo10OQBFzIJO9kkE559Wcmn+qkEiiKk=
github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE=
github.com/coreos/go-etcd v2.0.0+incompatible/go.mod h1:Jez6KQU2B/sWsbdaef3ED8NzMklzPG4d5KIOhIy30Tk=
github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
github.com/coreos/go-systemd v0.0.0-20190321100706-95778dfbb74e/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
github.com/coreos/pkg v0.0.0-20180928190104-399ea9e2e55f/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA=
github.com/cpuguy83/go-md2man v1.0.10/go.mod h1:SmD6nW6nTyfqj6ABTjUi3V3JVMnlJmwcJI5acqYI6dE=
github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
github.com/foxcpp/go-assuan v1.0.0 h1:KDSEmEGdHOzOjKmFUoaX/FGk1NxG/mHNAIdyksM8e4A=
github.com/foxcpp/go-assuan v1.0.0/go.mod h1:dQEJ9EaSSrUjd/g2PVaVEuV0TaoMDGwoh9XIDH1Q/Sc=
github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4=
github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
github.com/golang/groupcache v0.0.0-20190129154638-5b532d6fd5ef/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.4 h1:L8R9j+yAqZuZjsqh/z+F1NCffTKKLShY6zXTItVIZ8M=
github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-tpm v0.1.2-0.20190725015402-ae6dd98980d4/go.mod h1:H9HbmUG2YgV/PHITkO7p6wxEEj/v5nlsVWIwumwH2NI=
github.com/google/go-tpm v0.3.0/go.mod h1:iVLWvrPp/bHeEkxTFi9WG6K9w0iy2yIszHwZGHPbzAw=
github.com/google/go-tpm v0.3.2 h1:3iQQ2dlEf+1no7CLlfLPYzxhQy7j2G/emBqU5okydaw=
github.com/google/go-tpm v0.3.2/go.mod h1:j71sMBTfp3X5jPHz852ZOfQMUOf65Gb/Th8pRmp7fvg=
github.com/google/go-tpm-tools v0.0.0-20190906225433-1614c142f845/go.mod h1:AVfHadzbdzHo54inR2x1v640jdi1YSi3NauM2DUsxk0=
github.com/google/go-tpm-tools v0.2.0/go.mod h1:npUd03rQ60lxN7tzeBJreG38RvWwme2N1reF/eeiBk4=
github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
github.com/grpc-ecosystem/go-grpc-middleware v1.0.0/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs=
github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk=
github.com/grpc-ecosystem/grpc-gateway v1.9.0/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q=
github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U=
github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pkg/term v1.1.0/go.mod h1:E25nymQcrSllhX42Ok8MRm1+hyBdHY0dCeiKZ9jpNGw=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
github.com/prometheus/client_golang v0.9.3/go.mod h1:/TN21ttK/J9q6uSwhBd54HahCDft0ttaMvbicHlPoso=
github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
github.com/prometheus/common v0.0.0-20181113130724-41aa239b4cce/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
github.com/prometheus/common v0.4.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
github.com/prometheus/procfs v0.0.0-20190507164030-5867b95ac084/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU=
github.com/psanford/uhid v0.0.0-20210426002309-4864eff247db h1:V67//QISkDEEV+VrYgIzmtG+UCjDX8gQiMuf7f50i8A=
github.com/psanford/uhid v0.0.0-20210426002309-4864eff247db/go.mod h1:l7AmGL56H606RdpAQZ3qizn5ur7SoO9uQA2ZT7ZJ4RI=
github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg=
github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g=
github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
github.com/soheilhy/cmux v0.1.4/go.mod h1:IM3LyeVVIOuxMH7sFAkER9+bJ4dT7Ms6E4xg4kGIyLM=
github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
github.com/spf13/cobra v0.0.5/go.mod h1:3K3wKZymM7VvHMDS9+Akkh4K60UwM26emMESw8tLCHU=
github.com/spf13/cobra v1.0.0/go.mod h1:/6GTrnGXV9HjY+aR4k0oJ5tcvakLuG6EuKReYlHNrgE=
github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
github.com/spf13/viper v1.3.2/go.mod h1:ZiWeW+zYFKm7srdB9IoDzzZXaJaI5eL9QjNiN/DMA2s=
github.com/spf13/viper v1.4.0/go.mod h1:PTJ7Z/lr49W6bUbkmS1V3by4uWynFiR9p7+dSq/yZzE=
github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
github.com/ugorji/go v1.1.4/go.mod h1:uQMGLiO92mf5W77hV/PUCpI3pbzQx3CRekS0kk+RGrc=
github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0=
github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU=
github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q=
go.etcd.io/bbolt v1.3.2/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU=
go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
golang.org/x/crypto v0.0.0-20210513164829-c07d793c2f9a h1:kr2P4QFmQr29mSLA43kwrOcgcReGTfbE9N577tCTuBc=
golang.org/x/crypto v0.0.0-20210513164829-c07d793c2f9a/go.mod h1:P+XmwS30IXTQdn5tA2iutPOUgjI07+tq3H3K9MVA1s8=
golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20181220203305-927f97764cc3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.0.0-20190522155817-f3200d17e092/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20181107165924-66b7b1311ac8/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20181205085412-a5c9d58dba9a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20200909081042-eff7692f9009/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20201207223542-d4d67f95c62d h1:MiWWjyhUzZ+jvhZvloX6ZrUsdEghn8a64Upd8EMHglE=
golang.org/x/sys v0.0.0-20201207223542-d4d67f95c62d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
google.golang.org/grpc v1.21.0/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo=
gopkg.in/yaml.v2 v2.0.0-20170812160011-eb3733d160e7/go.mod h1:JAlM8MvJe8wmxCU4Bli9HhUf9+ttbYbLASfIpnQbh74=
gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
0707010000000E000041ED0000000000000000000000016493935C00000000000000000000000000000000000000000000002300000000tpm-fido-20230621.5f8828b/internal0707010000000F000041ED0000000000000000000000016493935C00000000000000000000000000000000000000000000002B00000000tpm-fido-20230621.5f8828b/internal/lencode07070100000010000081A40000000000000000000000016493935C00000D58000000000000000000000000000000000000003600000000tpm-fido-20230621.5f8828b/internal/lencode/lencode.go// This is a fork of github.com/psanford/lencode
// with the len prefix changed to a single byte

package lencode

import (
	"bytes"
	"errors"
	"io"
)

type Encoder struct {
	w         io.Writer
	separator []byte
	err       error
}

type Option struct {
	encoderOpt func(e *Encoder)
	decoderOpt func(e *Decoder)
}

// Specify a record separator to use as an integrity
// check when decoding. This defaults to \x6c\x65\x6e\x63 ("lenc").
// Set to nil to disable.
func SeparatorOpt(s []byte) Option {
	return Option{
		encoderOpt: func(e *Encoder) {
			e.separator = s
		},
		decoderOpt: func(e *Decoder) {
			e.separator = s
		},
	}
}

var defaultSeparator = []byte{'l', 'e', 'n', 'c'}
var separatorMismatchErr = errors.New("Separator mismatch")

func NewEncoder(w io.Writer, opts ...Option) *Encoder {
	e := &Encoder{
		w:         w,
		separator: defaultSeparator,
	}

for _, opt := range opts {
		opt.encoderOpt(e)
	}
	return e
}

// Encode a message to the underlying writer. It is not safe
// to call this method concurrently.
func (e *Encoder) Encode(msg []byte) error {
	if e.err != nil {
		return e.err
	}

msgLen := int64(len(msg))
	if msgLen > 0xff {
		e.err = errors.New("Message too long to encode length in 1 byte")
		return e.err
	}

if e.separator != nil {
		e.write(e.separator)
	}

e.write([]byte{byte(msgLen)})
	e.write(msg)

return e.err
}

func (e *Encoder) write(b []byte) error {
	if e.err != nil {
		return e.err
	}

_, err := e.w.Write(b)
	if err != nil {
		e.err = err
	}

return err
}

type Decoder struct {
	r         io.Reader
	separator []byte
	prefixBuf []byte
	err       error

pendingPrefix bool
	pendingLen    int
}

func NewDecoder(r io.Reader, opts ...Option) *Decoder {
	d := &Decoder{
		r:         r,
		separator: defaultSeparator,
	}

for _, opt := range opts {
		opt.decoderOpt(d)
	}

d.prefixBuf = make([]byte, len(d.separator)+1)

return d
}

// Decode the next message from the io.Reader.
func (d *Decoder) Decode() ([]byte, error) {
	if err := d.readPrefix(); err != nil {
		return nil, err
	}

buf := make([]byte, d.pendingLen)

if err := d.DecodeInto(buf); err != nil {
		return nil, err
	}

return buf, nil
}

// Decode the next message into a provided byte slice.
// Use NextLen() to ensure the slice is large enough
// for the message.
func (d *Decoder) DecodeInto(b []byte) error {
	if err := d.readPrefix(); err != nil {
		return err
	}

if d.pendingLen < len(b) {
		d.err = errors.New("Buffer not large enough for next message")
		return d.err
	}

if _, err := io.ReadFull(d.r, b[:d.pendingLen]); err != nil {
		if err == io.EOF {
			err = io.ErrUnexpectedEOF
		}
		d.err = err
		return d.err
	}

d.pendingPrefix = false
	d.pendingLen = 0

return nil
}

// Return the length of the next message
func (d *Decoder) NextLen() (int, error) {
	if d.err != nil {
		return 0, d.err
	}
	if !d.pendingPrefix {
		if err := d.readPrefix(); err != nil {
			return 0, err
		}
	}

return d.pendingLen, nil
}

func (d *Decoder) readPrefix() error {
	if d.err != nil {
		return d.err
	}

if d.pendingPrefix {
		return nil
	}

if _, err := io.ReadFull(d.r, d.prefixBuf); err != nil {
		d.err = err
		return err
	}

if len(d.separator) > 0 {
		if !bytes.Equal(d.prefixBuf[:len(d.separator)], d.separator) {
			d.err = separatorMismatchErr
			return d.err
		}
	}

l := d.prefixBuf[len(d.separator)]

d.pendingPrefix = true
	d.pendingLen = int(l)
	return d.err
}
07070100000011000081A40000000000000000000000016493935C00000905000000000000000000000000000000000000003B00000000tpm-fido-20230621.5f8828b/internal/lencode/lencode_test.gopackage lencode

import (
	"bytes"
	"io"
	"testing"
)

func TestEncodeDecode(t *testing.T) {
	var buf bytes.Buffer
	enc := NewEncoder(&buf)

payload0 := make([]byte, 16)
	for i := 0; i < len(payload0); i++ {
		payload0[i] = 'a'
	}
	if err := enc.Encode(payload0); err != nil {
		t.Fatal(err)
	}

payload1 := make([]byte, 255)
	for i := 0; i < len(payload1); i++ {
		payload1[i] = 'b'
	}
	if err := enc.Encode(payload1); err != nil {
		t.Fatal(err)
	}

dec := NewDecoder(&buf)

n, err := dec.NextLen()
	if err != nil {
		t.Fatal(err)
	}
	if n != len(payload0) {
		t.Fatalf("payload0 len mismatch %d vs %d", n, len(payload0))
	}

got0, err := dec.Decode()
	if err != nil {
		t.Fatal(err)
	}
	if !bytes.Equal(got0, payload0) {
		t.Fatalf("Payload0 mismatch %v vs %v", got0, payload0)
	}

got1, err := dec.Decode()
	if err != nil {
		t.Fatal(err)
	}
	if !bytes.Equal(got1, payload1) {
		t.Fatalf("Payload1 mismatch %v vs %v", got1, payload1)
	}

got2, err := dec.Decode()
	if err != io.EOF {
		t.Fatalf("Expected EOF, got %s %v", err, got2)
	}
}

func TestSeparatorMismatch(t *testing.T) {
	var buf bytes.Buffer

enc := NewEncoder(&buf, SeparatorOpt(nil))

payload0 := make([]byte, 16)
	for i := 0; i < len(payload0); i++ {
		payload0[i] = 'a'
	}
	if err := enc.Encode(payload0); err != nil {
		t.Fatal(err)
	}

r := bytes.NewReader(buf.Bytes())
	dec := NewDecoder(r)

_, err := dec.Decode()
	if err != separatorMismatchErr {
		t.Fatalf("Expected %s got %s", separatorMismatchErr, err)
	}

r = bytes.NewReader(buf.Bytes())
	dec = NewDecoder(r, SeparatorOpt(nil))

got0, err := dec.Decode()
	if err != nil {
		t.Fatal(err)
	}
	if !bytes.Equal(got0, payload0) {
		t.Fatalf("Payload0 mismatch %v vs %v", got0, payload0)
	}
}

func TestDecodeUnexpectedEOF(t *testing.T) {
	payload := []byte{0x01}
	r := bytes.NewReader(payload)
	dec := NewDecoder(r, SeparatorOpt(nil))

_, err := dec.Decode()
	if err != io.ErrUnexpectedEOF {
		t.Fatalf("Short read should trigger UnexpectedEOF error but was %s", err)
	}
}

func TestTooLong(t *testing.T) {
	var buf bytes.Buffer
	enc := NewEncoder(&buf)

payload := bytes.Repeat([]byte{'a'}, 256)

err := enc.Encode(payload)
	expect := "Message too long to encode length in 1 byte"
	if err.Error() != expect {
		t.Fatalf("Expected too long error, got: %s", err)
	}
}
07070100000012000041ED0000000000000000000000016493935C00000000000000000000000000000000000000000000002100000000tpm-fido-20230621.5f8828b/memory07070100000013000081A40000000000000000000000016493935C000009D1000000000000000000000000000000000000002B00000000tpm-fido-20230621.5f8828b/memory/memory.gopackage memory

import (
	"crypto/ecdsa"
	"crypto/elliptic"
	"crypto/rand"
	"crypto/sha256"
	"fmt"
	"math/big"

"golang.org/x/crypto/chacha20poly1305"
)

type Mem struct {
	masterPrivateKey []byte
	signCounter      uint32
}

func New() (*Mem, error) {
	return &Mem{
		masterPrivateKey: mustRand(chacha20poly1305.KeySize),
	}, nil
}

func (m *Mem) Counter() uint32 {
	m.signCounter++
	return m.signCounter
}

func (m *Mem) RegisterKey(applicationParam []byte) ([]byte, *big.Int, *big.Int, error) {
	curve := elliptic.P256()

childPrivateKey, x, y, err := elliptic.GenerateKey(curve, rand.Reader)
	if err != nil {
		return nil, nil, nil, fmt.Errorf("gen key err: %w", err)
	}

metadata := []byte("fido_wrapping_key")
	metadata = append(metadata, applicationParam...)
	h := sha256.New()
	h.Write(metadata)
	sum := h.Sum(nil)

aead, err := chacha20poly1305.NewX(m.masterPrivateKey)
	if err != nil {
		return nil, nil, nil, fmt.Errorf("chacha NewX err: %w", err)
	}

nonce := mustRand(chacha20poly1305.NonceSizeX)
	encryptedChildPrivateKey := aead.Seal(nil, nonce, childPrivateKey, sum)

keyHandle := make([]byte, 0, len(nonce)+len(encryptedChildPrivateKey))
	keyHandle = append(keyHandle, nonce...)
	keyHandle = append(keyHandle, encryptedChildPrivateKey...)

if len(keyHandle) > 255 {
		panic("keyHandle is too big")
	}

return keyHandle, x, y, nil
}

func (m *Mem) SignASN1(keyHandle, applicationParam, digest []byte) ([]byte, error) {
	aead, err := chacha20poly1305.NewX(m.masterPrivateKey)
	if err != nil {
		panic(err)
	}

if len(keyHandle) < chacha20poly1305.NonceSizeX {
		return nil, fmt.Errorf("incorrect size for key handle: %d smaller than nonce)", len(keyHandle))
	}
	nonce := keyHandle[:chacha20poly1305.NonceSizeX]
	cipherText := keyHandle[chacha20poly1305.NonceSizeX:]

metadata := []byte("fido_wrapping_key")
	metadata = append(metadata, applicationParam[:]...)
	h := sha256.New()
	h.Write(metadata)
	sum := h.Sum(nil)

childPrivateKey, err := aead.Open(nil, nonce, cipherText, sum)
	if err != nil {
		return nil, fmt.Errorf("open child private key err: %w", err)
	}

var ecdsaKey ecdsa.PrivateKey

ecdsaKey.D = new(big.Int).SetBytes(childPrivateKey)
	ecdsaKey.PublicKey.Curve = elliptic.P256()
	ecdsaKey.PublicKey.X, ecdsaKey.PublicKey.Y = ecdsaKey.PublicKey.Curve.ScalarBaseMult(ecdsaKey.D.Bytes())

return ecdsa.SignASN1(rand.Reader, &ecdsaKey, digest)
}

func mustRand(size int) []byte {
	b := make([]byte, size)
	if _, err := rand.Read(b); err != nil {
		panic(err)
	}

return b
}
07070100000014000041ED0000000000000000000000016493935C00000000000000000000000000000000000000000000002300000000tpm-fido-20230621.5f8828b/pinentry07070100000015000081A40000000000000000000000016493935C00000E55000000000000000000000000000000000000002F00000000tpm-fido-20230621.5f8828b/pinentry/pinentry.gopackage pinentry

import (
	"context"
	"errors"
	"fmt"
	"log"
	"os/exec"
	"sync"
	"time"

assuan "github.com/foxcpp/go-assuan/client"
	"github.com/foxcpp/go-assuan/pinentry"
)

func New() *Pinentry {
	return &Pinentry{}
}

type Pinentry struct {
	mu            sync.Mutex
	activeRequest *request
}

type request struct {
	timeout       time.Duration
	pendingResult chan Result
	extendTimeout chan time.Duration

challengeParam   [32]byte
	applicationParam [32]byte
}

type Result struct {
	OK    bool
	Error error
}

func (pe *Pinentry) ConfirmPresence(prompt string, challengeParam, applicationParam [32]byte) (chan Result, error) {
	pe.mu.Lock()
	defer pe.mu.Unlock()

timeout := 2 * time.Second

if pe.activeRequest != nil {
		if challengeParam != pe.activeRequest.challengeParam || applicationParam != pe.activeRequest.applicationParam {
			return nil, errors.New("other request already in progress")
		}

extendTimeoutChan := pe.activeRequest.extendTimeout

go func() {
			select {
			case extendTimeoutChan <- timeout:
			case <-time.After(timeout):
			}
		}()

return pe.activeRequest.pendingResult, nil
	}

pe.activeRequest = &request{
		timeout:          timeout,
		challengeParam:   challengeParam,
		applicationParam: applicationParam,
		pendingResult:    make(chan Result),
		extendTimeout:    make(chan time.Duration),
	}

go pe.prompt(pe.activeRequest, prompt)

return pe.activeRequest.pendingResult, nil
}

func (pe *Pinentry) prompt(req *request, prompt string) {
	sendResult := func(r Result) {
		select {
		case req.pendingResult <- r:
		case <-time.After(req.timeout):
			// we expect requests to come in every ~750ms.
			// If we've been waiting for 2 seconds the client
			// is likely gone.
		}

pe.mu.Lock()
		pe.activeRequest = nil
		pe.mu.Unlock()
	}

childCtx, cancel := context.WithCancel(context.Background())
	defer cancel()
	p, cmd, err := launchPinEntry(childCtx)
	if err != nil {
		sendResult(Result{
			OK:    false,
			Error: fmt.Errorf("failed to start pinentry: %w", err),
		})
		return
	}
	defer func() {
		cancel()
		cmd.Wait()
	}()

defer p.Shutdown()
	p.SetTitle("TPM-FIDO")
	p.SetPrompt("TPM-FIDO")
	p.SetDesc(prompt)

promptResult := make(chan bool)

go func() {
		err := p.Confirm()
		promptResult <- err == nil
	}()

timer := time.NewTimer(req.timeout)

for {
		select {
		case ok := <-promptResult:
			sendResult(Result{
				OK: ok,
			})
			return
		case <-timer.C:
			sendResult(Result{
				OK:    false,
				Error: errors.New("request timed out"),
			})
			return
		case d := <-req.extendTimeout:
			if !timer.Stop() {
				<-timer.C
			}
			timer.Reset(d)
		}
	}
}

func FindPinentryGUIPath() string {
	candidates := []string{
		"pinentry-gnome3",
		"pinentry-qt5",
		"pinentry-qt4",
		"pinentry-qt",
		"pinentry-gtk-2",
		"pinentry-x11",
		"pinentry-fltk",
	}
	for _, candidate := range candidates {
		p, _ := exec.LookPath(candidate)
		if p != "" {
			return p
		}
	}
	return ""
}

func launchPinEntry(ctx context.Context) (*pinentry.Client, *exec.Cmd, error) {
	pinEntryCmd := FindPinentryGUIPath()
	if pinEntryCmd == "" {
		log.Printf("Failed to detect gui pinentry binary. Falling back to default `pinentry`")
		pinEntryCmd = "pinentry"
	}
	cmd := exec.CommandContext(ctx, pinEntryCmd)

stdout, err := cmd.StdoutPipe()
	if err != nil {
		return nil, nil, err
	}
	stdin, err := cmd.StdinPipe()
	if err != nil {
		return nil, nil, err
	}

if err := cmd.Start(); err != nil {
		return nil, nil, err
	}

var c pinentry.Client
	c.Session, err = assuan.Init(assuan.ReadWriteCloser{
		ReadCloser:  stdout,
		WriteCloser: stdin,
	})

if err != nil {
		return nil, nil, err
	}
	return &c, cmd, nil
}
07070100000016000041ED0000000000000000000000016493935C00000000000000000000000000000000000000000000002900000000tpm-fido-20230621.5f8828b/sitesignatures07070100000017000081A40000000000000000000000016493935C00000828000000000000000000000000000000000000003B00000000tpm-fido-20230621.5f8828b/sitesignatures/sitesignatures.gopackage sitesignatures

import (
	"crypto/sha256"
	"fmt"
)

// from https://github.com/danstiner/rust-u2f/blob/master/u2f-core/src/known_app_ids.rs
// and https://github.com/github/SoftU2F/blob/master/SoftU2FTool/KnownFacets.swift
var reverseSignatures = map[[32]byte]string{
	hashURL("https://api-9dcf9b83.duosecurity.com"):             "duosecurity.com",
	hashURL("https://dashboard.stripe.com"):                     "dashboard.stripe.com",
	hashURL("https://demo.yubico.com"):                          "demo.yubico.com",
	hashURL("https://github.com/u2f/trusted_facets"):            "github.com",
	hashURL("https://gitlab.com"):                               "gitlab.com",
	hashURL("https://id.fedoraproject.org/u2f-origins.json"):    "id.fedoraproject.org",
	hashURL("https://keepersecurity.com"):                       "keepersecurity.com",
	hashURL("https://lastpass.com"):                             "lastpass.com",
	hashURL("https://mdp.github.io"):                            "mdp.github.io",
	hashURL("https://personal.vanguard.com"):                    "vanguard.com",
	hashURL("https://u2f.aws.amazon.com/app-id.json"):           "aws.amazon.com",
	hashURL("https://u2f.bin.coffee"):                           "u2f.bin.coffee",
	hashURL("https://vault.bitwarden.com/app-id.json"):          "vault.bitwarden.com",
	hashURL("https://www.dropbox.com/u2f-app-id.json"):          "dropbox.com",
	hashURL("https://www.fastmail.com"):                         "www.fastmail.com",
	hashURL("https://www.gstatic.com/securitykey/origins.json"): "google.com",

hashURL("bin.coffee"):          "bin.coffee",
	hashURL("coinbase.com"):        "coinbase.com",
	hashURL("demo.yubico.com"):     "demo.yubico.com",
	hashURL("github.com"):          "github.com",
	hashURL("webauthn.bin.coffee"): "webauthn.bin.coffee",
	hashURL("webauthn.io"):         "webauthn.io",
}

func hashURL(url string) [32]byte {
	return sha256.Sum256([]byte(url))
}

func FromAppParam(sig [32]byte) string {
	site := reverseSignatures[sig]
	if site == "" {
		site = fmt.Sprintf("<unknown %x>", sig)
	}
	return site
}
07070100000018000041ED0000000000000000000000016493935C00000000000000000000000000000000000000000000002500000000tpm-fido-20230621.5f8828b/statuscode07070100000019000081A40000000000000000000000016493935C000002BE000000000000000000000000000000000000003300000000tpm-fido-20230621.5f8828b/statuscode/statuscode.gopackage statuscode

// status codes from section 3.3 of
// https://fidoalliance.org/specs/fido-u2f-v1.2-ps-20170411/fido-u2f-raw-message-formats-v1.2-ps-20170411.html

const (
	NoError                = 0x9000 // The command completed successfully without error.
	ConditionsNotSatisfied = 0x6985 // The request was rejected due to test-of-user-presence being required.
	WrongData              = 0x6A80 // The request was rejected due to an invalid key handle.
	WrongLength            = 0x6700 // The length of the request was invalid
	ClaNotSupported        = 0x6E00 // The Class byte of the request is not supported
	InsNotSupported        = 0x6D00 // The Instruction of the request is not supported
)
0707010000001A000041ED0000000000000000000000016493935C00000000000000000000000000000000000000000000001E00000000tpm-fido-20230621.5f8828b/tpm0707010000001B000081A40000000000000000000000016493935C000014F0000000000000000000000000000000000000002500000000tpm-fido-20230621.5f8828b/tpm/tpm.gopackage tpm

import (
	"bytes"
	"crypto/rand"
	"crypto/sha256"
	"fmt"
	"io"
	"math/big"
	"sync"
	"time"

"github.com/google/go-tpm/tpm2"
	"github.com/psanford/tpm-fido/internal/lencode"
	"golang.org/x/crypto/cryptobyte"
	"golang.org/x/crypto/cryptobyte/asn1"
	"golang.org/x/crypto/hkdf"
)

var (
	separator     = []byte("TPM")
	seedSizeBytes = 20
)

type TPM struct {
	devicePath string
	mu         sync.Mutex
}

func (t *TPM) open() (io.ReadWriteCloser, error) {
	return tpm2.OpenTPM(t.devicePath)
}

func New(devicePath string) (*TPM, error) {
	t := &TPM{
		devicePath: devicePath,
	}

tpm, err := t.open()
	if err != nil {
		return nil, err
	}
	tpm.Close()

return t, nil
}

func primaryKeyTmpl(seed, applicationParam []byte) tpm2.Public {
	info := append([]byte("tpm-fido-application-key"), applicationParam...)

r := hkdf.New(sha256.New, seed, []byte{}, info)
	unique := tpm2.ECPoint{
		XRaw: make([]byte, 32),
		YRaw: make([]byte, 32),
	}
	if _, err := io.ReadFull(r, unique.XRaw); err != nil {
		panic(err)
	}
	if _, err := io.ReadFull(r, unique.YRaw); err != nil {
		panic(err)
	}

return tpm2.Public{
		Type:    tpm2.AlgECC,
		NameAlg: tpm2.AlgSHA256,
		Attributes: tpm2.FlagRestricted | tpm2.FlagDecrypt |
			tpm2.FlagFixedTPM | tpm2.FlagFixedParent |
			tpm2.FlagSensitiveDataOrigin | tpm2.FlagUserWithAuth,
		ECCParameters: &tpm2.ECCParams{
			Symmetric: &tpm2.SymScheme{
				Alg:     tpm2.AlgAES,
				KeyBits: 128,
				Mode:    tpm2.AlgCFB,
			},
			CurveID: tpm2.CurveNISTP256,
			Point:   unique,
		},
	}
}

var baseTime = time.Date(2021, time.January, 1, 0, 0, 0, 0, time.UTC)

func (t *TPM) Counter() uint32 {
	unix := time.Now().Unix()
	return uint32(unix - baseTime.Unix())
}

// Register a new key with the TPM for the given applicationParam.
// RegisterKey returns the KeyHandle or an error.
func (t *TPM) RegisterKey(applicationParam []byte) ([]byte, *big.Int, *big.Int, error) {
	t.mu.Lock()
	defer t.mu.Unlock()

tpm, err := t.open()
	if err != nil {
		return nil, nil, nil, fmt.Errorf("open tpm err: %w", err)
	}
	defer tpm.Close()

randSeed := mustRand(seedSizeBytes)

primaryTmpl := primaryKeyTmpl(randSeed, applicationParam)

childTmpl := tpm2.Public{
		Type:    tpm2.AlgECC,
		NameAlg: tpm2.AlgSHA256,
		Attributes: tpm2.FlagFixedTPM | tpm2.FlagFixedParent |
			tpm2.FlagSensitiveDataOrigin | tpm2.FlagUserWithAuth |
			tpm2.FlagSign,
		ECCParameters: &tpm2.ECCParams{

Sign: &tpm2.SigScheme{
				Alg:  tpm2.AlgECDSA,
				Hash: tpm2.AlgSHA256,
			},
			CurveID: tpm2.CurveNISTP256,
			Point: tpm2.ECPoint{
				XRaw: make([]byte, 32),
				YRaw: make([]byte, 32),
			},
		},
	}

parentHandle, _, err := tpm2.CreatePrimary(tpm, tpm2.HandleOwner, tpm2.PCRSelection{}, "", "", primaryTmpl)
	if err != nil {
		return nil, nil, nil, fmt.Errorf("CreatePrimary key err: %w", err)
	}

defer tpm2.FlushContext(tpm, parentHandle)

private, public, _, _, _, err := tpm2.CreateKey(tpm, parentHandle, tpm2.PCRSelection{}, "", "", childTmpl)
	if err != nil {
		return nil, nil, nil, fmt.Errorf("CreateKey (child) err: %w", err)
	}

var out bytes.Buffer
	enc := lencode.NewEncoder(&out, lencode.SeparatorOpt(separator))

enc.Encode(private)
	enc.Encode(public)
	enc.Encode(randSeed)

keyHandle, _, err := tpm2.Load(tpm, parentHandle, "", public, private)
	if err != nil {
		return nil, nil, nil, fmt.Errorf("load child key err: %w", err)
	}

defer tpm2.FlushContext(tpm, keyHandle)

pub, _, _, err := tpm2.ReadPublic(tpm, keyHandle)
	if err != nil {
		return nil, nil, nil, fmt.Errorf("read public key err: %w", err)
	}

x := new(big.Int).SetBytes(pub.ECCParameters.Point.XRaw)
	y := new(big.Int).SetBytes(pub.ECCParameters.Point.YRaw)

return out.Bytes(), x, y, nil
}

func (t *TPM) SignASN1(keyHandle, applicationParam, digest []byte) ([]byte, error) {
	t.mu.Lock()
	defer t.mu.Unlock()

tpm, err := t.open()
	if err != nil {
		return nil, fmt.Errorf("open tpm err: %w", err)
	}
	defer tpm.Close()

dec := lencode.NewDecoder(bytes.NewReader(keyHandle), lencode.SeparatorOpt(separator))

invalidHandleErr := fmt.Errorf("invalid key handle")

private, err := dec.Decode()
	if err != nil {
		return nil, invalidHandleErr
	}

public, err := dec.Decode()
	if err != nil {
		return nil, invalidHandleErr
	}

seed, err := dec.Decode()
	if err != nil {
		return nil, invalidHandleErr
	}

_, err = dec.Decode()
	if err != io.EOF {
		return nil, invalidHandleErr
	}

srkTemplate := primaryKeyTmpl(seed, applicationParam)

parentHandle, _, err := tpm2.CreatePrimary(tpm, tpm2.HandleOwner, tpm2.PCRSelection{}, "", "", srkTemplate)
	if err != nil {
		return nil, fmt.Errorf("CreatePrimary key err: %w", err)
	}

defer tpm2.FlushContext(tpm, parentHandle)

key, _, err := tpm2.Load(tpm, parentHandle, "", public, private)
	if err != nil {
		return nil, fmt.Errorf("Load err: %w", err)
	}

defer tpm2.FlushContext(tpm, key)

scheme := &tpm2.SigScheme{
		Alg:  tpm2.AlgECDSA,
		Hash: tpm2.AlgSHA256,
	}

sig, err := tpm2.Sign(tpm, key, "", digest[:], nil, scheme)
	if err != nil {
		return nil, fmt.Errorf("sign err: %w", err)
	}

var b cryptobyte.Builder
	b.AddASN1(asn1.SEQUENCE, func(b *cryptobyte.Builder) {
		b.AddASN1BigInt(sig.ECC.R)
		b.AddASN1BigInt(sig.ECC.S)
	})

return b.Bytes()
}

func mustRand(size int) []byte {
	b := make([]byte, size)
	if _, err := rand.Read(b); err != nil {
		panic(err)
	}

return b
}
0707010000001C000081A40000000000000000000000016493935C00002268000000000000000000000000000000000000002500000000tpm-fido-20230621.5f8828b/tpmfido.gopackage main

import (
	"bytes"
	"context"
	"crypto/ecdsa"
	"crypto/elliptic"
	"crypto/rand"
	"crypto/sha256"
	"encoding/binary"
	"flag"
	"log"
	"math/big"
	"time"

"github.com/psanford/tpm-fido/attestation"
	"github.com/psanford/tpm-fido/fidoauth"
	"github.com/psanford/tpm-fido/fidohid"
	"github.com/psanford/tpm-fido/memory"
	"github.com/psanford/tpm-fido/pinentry"
	"github.com/psanford/tpm-fido/sitesignatures"
	"github.com/psanford/tpm-fido/statuscode"
	"github.com/psanford/tpm-fido/tpm"
)

var backend = flag.String("backend", "tpm", "tpm|memory")
var device = flag.String("device", "/dev/tpmrm0", "TPM device path")

func main() {
	flag.Parse()
	s := newServer()
	s.run()
}

type server struct {
	pe     *pinentry.Pinentry
	signer Signer
}

type Signer interface {
	RegisterKey(applicationParam []byte) ([]byte, *big.Int, *big.Int, error)
	SignASN1(keyHandle, applicationParam, digest []byte) ([]byte, error)
	Counter() uint32
}

func newServer() *server {
	s := server{
		pe: pinentry.New(),
	}
	if *backend == "tpm" {
		signer, err := tpm.New(*device)
		if err != nil {
			panic(err)
		}
		s.signer = signer
	} else if *backend == "memory" {
		signer, err := memory.New()
		if err != nil {
			panic(err)
		}
		s.signer = signer
	}
	return &s
}

func (s *server) run() {
	ctx := context.Background()

if pinentry.FindPinentryGUIPath() == "" {
		log.Printf("warning: no gui pinentry binary detected in PATH. tpm-fido may not work correctly without a gui based pinentry")
	}

token, err := fidohid.New(ctx, "tpm-fido")
	if err != nil {
		log.Fatalf("create fido hid error: %s", err)
	}

go token.Run(ctx)

for evt := range token.Events() {
		if evt.Error != nil {
			log.Printf("got token error: %s", err)
			continue
		}

req := evt.Req

if req.Command == fidoauth.CmdAuthenticate {
			log.Printf("got AuthenticateCmd site=%s", sitesignatures.FromAppParam(req.Authenticate.ApplicationParam))

s.handleAuthenticate(ctx, token, evt)
		} else if req.Command == fidoauth.CmdRegister {
			log.Printf("got RegisterCmd site=%s", sitesignatures.FromAppParam(req.Register.ApplicationParam))
			s.handleRegister(ctx, token, evt)
		} else if req.Command == fidoauth.CmdVersion {
			log.Print("got VersionCmd")
			s.handleVersion(ctx, token, evt)
		} else {
			log.Printf("unsupported request type: 0x%02x\n", req.Command)
			// send a not supported error for any commands that we don't understand.
			// Browsers depend on this to detect what features the token supports
			// (i.e. the u2f backwards compatibility)
			token.WriteResponse(ctx, evt, nil, statuscode.ClaNotSupported)
		}
	}
}

func (s *server) handleVersion(parentCtx context.Context, token *fidohid.SoftToken, evt fidohid.AuthEvent) {
	token.WriteResponse(parentCtx, evt, []byte("U2F_V2"), statuscode.NoError)
}

func (s *server) handleAuthenticate(parentCtx context.Context, token *fidohid.SoftToken, evt fidohid.AuthEvent) {
	req := evt.Req

keyHandle := req.Authenticate.KeyHandle
	appParam := req.Authenticate.ApplicationParam[:]

dummySig := sha256.Sum256([]byte("meticulously-Bacardi"))

_, err := s.signer.SignASN1(keyHandle, appParam, dummySig[:])
	if err != nil {
		log.Printf("invalid key: %s (key handle size: %d)", err, len(keyHandle))

err := token.WriteResponse(parentCtx, evt, nil, statuscode.WrongData)
		if err != nil {
			log.Printf("send bad key handle msg err: %s", err)
		}

return
	}

switch req.Authenticate.Ctrl {
	case fidoauth.CtrlCheckOnly,
		fidoauth.CtrlDontEnforeUserPresenceAndSign,
		fidoauth.CtrlEnforeUserPresenceAndSign:
	default:
		log.Printf("unknown authenticate control value: %d", req.Authenticate.Ctrl)

err := token.WriteResponse(parentCtx, evt, nil, statuscode.WrongData)
		if err != nil {
			log.Printf("send wrong-data msg err: %s", err)
		}
		return
	}

if req.Authenticate.Ctrl == fidoauth.CtrlCheckOnly {
		// check if the provided key is known by the token
		log.Printf("check-only success")
		// test-of-user-presence-required: note that despite the name this signals a success condition
		err := token.WriteResponse(parentCtx, evt, nil, statuscode.ConditionsNotSatisfied)
		if err != nil {
			log.Printf("send bad key handle msg err: %s", err)
		}
		return
	}

var userPresent uint8

if req.Authenticate.Ctrl == fidoauth.CtrlEnforeUserPresenceAndSign {

pinResultCh, err := s.pe.ConfirmPresence("FIDO Confirm Auth", req.Authenticate.ChallengeParam, req.Authenticate.ApplicationParam)

if err != nil {
			log.Printf("pinentry err: %s", err)
			token.WriteResponse(parentCtx, evt, nil, statuscode.ConditionsNotSatisfied)

return
		}

childCtx, cancel := context.WithTimeout(parentCtx, 750*time.Millisecond)
		defer cancel()

select {
		case result := <-pinResultCh:
			if result.OK {
				userPresent = 0x01
			} else {
				if result.Error != nil {
					log.Printf("Got pinentry result err: %s", result.Error)
				}

// Got user cancelation, we want to propagate that so the browser gives up.
				// This isn't normally supported by a key so there's no status code for this.
				// WrongData seems like the least incorrect status code ¯\_(ツ)_/¯
				err := token.WriteResponse(parentCtx, evt, nil, statuscode.WrongData)
				if err != nil {
					log.Printf("Write WrongData resp err: %s", err)
				}
				return
			}
		case <-childCtx.Done():
			err := token.WriteResponse(parentCtx, evt, nil, statuscode.ConditionsNotSatisfied)
			if err != nil {
				log.Printf("Write swConditionsNotSatisfied resp err: %s", err)
			}
			return
		}
	}

signCounter := s.signer.Counter()

var toSign bytes.Buffer
	toSign.Write(req.Authenticate.ApplicationParam[:])
	toSign.WriteByte(userPresent)
	binary.Write(&toSign, binary.BigEndian, signCounter)
	toSign.Write(req.Authenticate.ChallengeParam[:])

sigHash := sha256.New()
	sigHash.Write(toSign.Bytes())

sig, err := s.signer.SignASN1(keyHandle, appParam, sigHash.Sum(nil))
	if err != nil {
		log.Fatalf("auth sign err: %s", err)
	}

var out bytes.Buffer
	out.WriteByte(userPresent)
	binary.Write(&out, binary.BigEndian, signCounter)
	out.Write(sig)

err = token.WriteResponse(parentCtx, evt, out.Bytes(), statuscode.NoError)
	if err != nil {
		log.Printf("write auth response err: %s", err)
		return
	}
}

func (s *server) handleRegister(parentCtx context.Context, token *fidohid.SoftToken, evt fidohid.AuthEvent) {
	ctx, cancel := context.WithTimeout(parentCtx, 750*time.Millisecond)
	defer cancel()
	req := evt.Req

pinResultCh, err := s.pe.ConfirmPresence("FIDO Confirm Register", req.Register.ChallengeParam, req.Register.ApplicationParam)

if err != nil {
		log.Printf("pinentry err: %s", err)
		token.WriteResponse(ctx, evt, nil, statuscode.ConditionsNotSatisfied)

return
	}

select {
	case result := <-pinResultCh:
		if !result.OK {
			if result.Error != nil {
				log.Printf("Got pinentry result err: %s", result.Error)
			}

s.registerSite(parentCtx, token, evt)
	case <-ctx.Done():
		err := token.WriteResponse(ctx, evt, nil, statuscode.ConditionsNotSatisfied)
		if err != nil {
			log.Printf("Write swConditionsNotSatisfied resp err: %s", err)
			return
		}
	}
}

func (s *server) registerSite(ctx context.Context, token *fidohid.SoftToken, evt fidohid.AuthEvent) {
	req := evt.Req

keyHandle, x, y, err := s.signer.RegisterKey(req.Register.ApplicationParam[:])
	if err != nil {
		log.Printf("RegisteKey err: %s", err)
		return
	}

if len(keyHandle) > 255 {
		log.Printf("Error: keyHandle too large: %d, max=255", len(keyHandle))
		return
	}

childPubKey := elliptic.Marshal(elliptic.P256(), x, y)

var toSign bytes.Buffer
	toSign.WriteByte(0)
	toSign.Write(req.Register.ApplicationParam[:])
	toSign.Write(req.Register.ChallengeParam[:])
	toSign.Write(keyHandle)
	toSign.Write(childPubKey)

sigHash := sha256.New()
	sigHash.Write(toSign.Bytes())

sum := sigHash.Sum(nil)

sig, err := ecdsa.SignASN1(rand.Reader, attestation.PrivateKey, sum)
	if err != nil {
		log.Fatalf("attestation sign err: %s", err)
	}

var out bytes.Buffer
	out.WriteByte(0x05) // reserved value
	out.Write(childPubKey)
	out.WriteByte(byte(len(keyHandle)))
	out.Write(keyHandle)
	out.Write(attestation.CertDer)
	out.Write(sig)

err = token.WriteResponse(ctx, evt, out.Bytes(), statuscode.NoError)
	if err != nil {
		log.Printf("write register response err: %s", err)
		return
	}
}

func mustRand(size int) []byte {
	b := make([]byte, size)
	if _, err := rand.Read(b); err != nil {
		panic(err)
	}

return b
}
07070100000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000B00000000TRAILER!!!145 blocks

Places

File tpm-fido-20230621.5f8828b.obscpio of Package tpm-fido

Places