gmrtd

type ActiveAuthenticationInfo struct {
	Protocol           asn1.ObjectIdentifier
	Version            int
	SignatureAlgorithm asn1.ObjectIdentifier
}

type AlgorithmIdentifier struct {
	Algorithm  asn1.ObjectIdentifier
	Parameters int `asn1:"optional"` // TODO - spec technically says ANY type
}

type Attribute struct {
	Type   asn1.ObjectIdentifier
	Values asn1.RawValue
}

type AttributeList []Attribute

type BAC struct {
	// contains filtered or unexported fields
}

type BiometricDataBlock struct {
	Facial Facial
}

type BiometricHeaderTemplate struct {
	IcaoHeaderVersion []byte // optional
	BiometricType     []byte // optional
	BiometricSubType  []byte // optional (for DG2)
	CreationDateTime  []byte // optional
	ValidityPeriod    []byte // optional
	PID               []byte // optional
	FormatOwner       []byte // required
	FormatType        []byte // required
}

type BiometricInfoTemplate struct {
	BHT BiometricHeaderTemplate
	BDB BiometricDataBlock
}

type BlockCipherAlg int

type CApdu struct {
	// contains filtered or unexported fields
}

type COM struct {
	RawData        []byte
	LdsVersion     string
	UnicodeVersion string
	TagList        []TlvTag
}

type CardAccess struct {
	RawData       []byte
	SecurityInfos *SecurityInfos
}

type CardSecurity struct {
	RawData       []byte
	SecurityInfos *SecurityInfos
}

type ChipAuthStatus int

type ChipAuthenticationInfo struct {
	Protocol asn1.ObjectIdentifier
	Version  int
	KeyId    int `asn1:"optional"`
}

type ChipAuthenticationPublicKeyInfo struct {
	Protocol                    asn1.ObjectIdentifier
	ChipAuthenticationPublicKey SubjectPublicKeyInfo
	KeyId                       int `asn1:"optional"`
}

type DG1 struct {
	RawData []byte
	Mrz     *MRZ
}

type DG11 struct {
	RawData []byte
}

type DG12 struct {
	RawData []byte
}

type DG13 struct {
	RawData []byte
}

type DG14 struct {
	RawData  []byte // TODO - add to test cases (for all other DGs also)
	SecInfos *SecurityInfos
}

type DG15 struct {
	RawData []byte
}

type DG16 struct {
	RawData []byte
}

type DG2 struct {
	RawData []byte
	BITs    []BiometricInfoTemplate
}

type DG7 struct {
	RawData []byte
	Images  []DG7Image
}

type DG7Image struct {
	Image []byte
}

type DataGroupHash struct {
	DataGroupNumber    int    ``
	DataGroupHashValue []byte ``
}

type Document struct {
	CardAccess     *CardAccess
	CardSecurity   *CardSecurity // NB only read for PACE-CAM - read during PACE flow
	Dir            *EFDIR        // indicates which applications are present - generally not acvailable
	Com            *COM          // largely deprecated by SOD, but used to determine Lds/Unicode Version if older SOD formatis present
	Sod            *SOD          // Document Security Object EF.SOD (MANDATORY)
	Dg1            *DG1          // DATA GROUP 1 — Machine Readable Zone Information (MANDATORY)
	Dg2            *DG2          // DATA GROUP 2 — Encoded Identification Features — Face (MANDATORY)
	Dg7            *DG7          // DATA GROUP 7 — Displayed Signature or Usual Mark (OPTIONAL)
	Dg11           *DG11         // DATA GROUP 11 — Additional Personal Detail(s) (OPTIONAL)
	Dg12           *DG12         // DATA GROUP 12 — Additional Document Detail(s) (OPTIONAL)
	Dg13           *DG13         // DATA GROUP 13 — Optional Details(s) (OPTIONAL)
	Dg14           *DG14         // DATA GROUP 14 — Security Options (CONDITIONAL)
	Dg15           *DG15         // DATA GROUP 15 — Active Authentication Public Key Info (CONDITIONAL)
	Dg16           *DG16         // DATA GROUP 16 — Person(s) to Notify (OPTIONAL)
	ChipAuthStatus ChipAuthStatus
}

type EC_POINT struct {
	// contains filtered or unexported fields
}

type EFDIR struct {
	RawData     []byte
	Application []EfDirApplication
}

type EFDirInfo struct {
	Protocol asn1.ObjectIdentifier
	EFDir    []byte
}

type EfDirApplication struct {
	// contains filtered or unexported fields
}

type EncapContentInfo struct {
	EContentType asn1.ObjectIdentifier ``
	EContent     []byte                `asn1:"explicit,tag:0"` // contains LDSSecurityObject
}

type Facial struct {
	Header FacialHeader
	Images []Image
}

type FacialFeature struct {
	Type       uint8
	MajorPoint uint8
	MinorPoint uint8
	X          uint16
	Y          uint16
	Reserved   uint8
}

type FacialHeader struct {
	FormatID      [4]byte
	VersionID     [4]byte
	RecordLength  uint32
	NumberOfFaces uint16
}

type FacialInfo struct {
	Length          uint32
	NumberOfPoints  uint16
	Gender          uint8
	EyeColor        uint8
	HairColor       uint8
	Properties      [3]byte
	Expression      [2]byte
	Pose            [3]byte
	PoseUncertainty [3]byte
}

type Image struct {
	FacialInformation FacialInfo
	Features          []FacialFeature
	ImageInformation  ImageInfo
	Data              []byte
}

type ImageInfo struct {
	Type       uint8
	DataType   uint8
	Width      uint16
	Height     uint16
	ColorSpace uint8
	SourceType uint8
	DeviceType uint16
	Quality    uint16
}

type IssuerAndSerial struct {
	IssuerName   asn1.RawValue
	SerialNumber *big.Int
}

type KDFCounterType int

type KeyGeneratorEcFn func(ec elliptic.Curve) (pri []byte, pub *EC_POINT)

type LDSSecurityObject struct {
	Version             int                      ``
	HashAlgorithm       pkix.AlgorithmIdentifier ``
	DataGroupHashValues []DataGroupHash          ``
	LdsVersionInfo      LDSVersionInfo           `asn1:"optional"`
}

type LDSVersionInfo struct {
	LdsVersion     string ``
	UnicodeVersion string ``
}

type MRZ struct {
	DocumentCode   string
	IssuingState   string
	NameOfHolder   string
	DocumentNumber string
	Nationality    string
	DateOfBirth    string
	Sex            string
	DateOfExpiry   string
	OptionalData   string
	OptionalData2  string // TODO - just required for TD1?.. should this be considered as a single logical field?
}

type MockTransceiver struct {
	// contains filtered or unexported fields
}

type MockTransceiverReqRsp struct {
	// contains filtered or unexported fields
}

type NfcSession struct {
	// contains filtered or unexported fields
}

type PACEAuthToken int

type PACEDomainParams struct {
	// contains filtered or unexported fields
}

type PACEMapping int

type PACESeccureMessaging int

type Pace struct {
	// contains filtered or unexported fields
}

type PaceConfig struct {
	// contains filtered or unexported fields
}

type PaceDomainParameterInfo struct {
	Protocol        asn1.ObjectIdentifier
	DomainParameter AlgorithmIdentifier
	ParameterId     int `asn1:"optional"`
}

type PaceInfo struct {
	Protocol    asn1.ObjectIdentifier
	Version     int
	ParameterId int `asn1:"optional"`
}

type Password struct {
	// contains filtered or unexported fields
}

type PasswordType int

type RApdu struct {
	Data   []byte
	Status uint16
}

type RandomBytesFn func(length int) []byte

type SOD struct {
	RawData []byte
	// nodes   *TlvNodes
	LdsSecurityObject *LDSSecurityObject
}

type SecureMessaging struct {
	KSenc []byte
	KSmac []byte
	SSC   []byte
	// contains filtered or unexported fields
}

type SecurityInfoOid struct {
	Raw      asn1.RawContent
	Protocol asn1.ObjectIdentifier `asn1:""`
}

type SecurityInfoOidSET []SecurityInfoOid

type SecurityInfos struct {
	PaceInfos            []PaceInfo
	PaceDomainParamInfos []PaceDomainParameterInfo
	ActiveAuthInfos      []ActiveAuthenticationInfo
	ChipAuthInfos        []ChipAuthenticationInfo
	ChipAuthPubKeyInfos  []ChipAuthenticationPublicKeyInfo
	TermAuthInfos        []TerminalAuthenticationInfo
	EfDirInfos           []EFDirInfo
	UnhandledInfos       []UnhandledInfo
	TotalCnt             int
}

type SignedData struct {
	Oid asn1.ObjectIdentifier ``
	SD2 SignedData2           `asn1:"explicit,tag:0"` // TODO - naming?
}

type SignedData2 struct {
	Version          int
	DigestAlgorithms []pkix.AlgorithmIdentifier `asn1:"set"`
	Content          EncapContentInfo           ``
	Certificates     []asn1.RawValue            `asn1:"optional,set,tag:0"`
	CRLs             []asn1.RawValue            `asn1:"optional,set,tag:1"`
	SignerInfos      []SignerInfo               `asn1:"set"`
}

type SignerInfo struct {
	Version                   int                      `asn1:"default:1"`
	IssuerAndSerialNumber     IssuerAndSerial          ``
	DigestAlgorithm           pkix.AlgorithmIdentifier ``
	AuthenticatedAttributes   AttributeList            `asn1:"optional,tag:0"`
	DigestEncryptionAlgorithm pkix.AlgorithmIdentifier ``
	EncryptedDigest           []byte                   ``
	UnauthenticatedAttributes AttributeList            `asn1:"optional,tag:1"`
}

type StaticTransceiver struct {
	// contains filtered or unexported fields
}

type SubjectPublicKeyInfo struct {
	Algorithm        AlgorithmIdentifier
	SubjectPublicKey asn1.BitString
}

type TerminalAuthenticationInfo struct {
	Protocol asn1.ObjectIdentifier
	Version  int
}

type TlvConstructedNode struct {
	Tag      TlvTag
	Children TlvNodes
}

type TlvNilNode struct{}

type TlvNode interface {
	IsValidNode() bool
	GetTag() TlvTag
	GetValue() []byte
	GetNode(tag TlvTag) TlvNode
	GetNodeByOccur(tag TlvTag, occurrence int) TlvNode
	Encode() []byte
	String() string
	// contains filtered or unexported methods
}

type TlvNodes struct {
	Nodes []TlvNode
}

type TlvSimpleNode struct {
	Tag   TlvTag
	Value []byte
}

type TlvTag int

type Transceiver interface {
	Transceive(capdu []byte) []byte
}

type UnhandledInfo struct {
	Protocol asn1.ObjectIdentifier
	RawData  []byte
}