@joclaim/attestor-core 0.2.0 → 0.2.3

package/src/server/utils/iso.ts

@@ -1,258 +0,0 @@
-
-const countries = {
-	AF: 'Afghanistan',
-	AX: 'Åland Islands',
-	AL: 'Albania',
-	DZ: 'Algeria',
-	AS: 'American Samoa',
-	AD: 'Andorra',
-	AO: 'Angola',
-	AI: 'Anguilla',
-	AQ: 'Antarctica',
-	AG: 'Antigua and Barbuda',
-	AR: 'Argentina',
-	AM: 'Armenia',
-	AW: 'Aruba',
-	AU: 'Australia',
-	AT: 'Austria',
-	AZ: 'Azerbaijan',
-	BS: 'Bahamas',
-	BH: 'Bahrain',
-	BD: 'Bangladesh',
-	BB: 'Barbados',
-	BY: 'Belarus',
-	BE: 'Belgium',
-	BZ: 'Belize',
-	BJ: 'Benin',
-	BM: 'Bermuda',
-	BT: 'Bhutan',
-	BO: 'Bolivia, Plurinational State of',
-	BQ: 'Bonaire, Sint Eustatius and Saba',
-	BA: 'Bosnia and Herzegovina',
-	BW: 'Botswana',
-	BV: 'Bouvet Island',
-	BR: 'Brazil',
-	IO: 'British Indian Ocean Territory',
-	BN: 'Brunei Darussalam',
-	BG: 'Bulgaria',
-	BF: 'Burkina Faso',
-	BI: 'Burundi',
-	KH: 'Cambodia',
-	CM: 'Cameroon',
-	CA: 'Canada',
-	CV: 'Cape Verde',
-	KY: 'Cayman Islands',
-	CF: 'Central African Republic',
-	TD: 'Chad',
-	CL: 'Chile',
-	CN: 'China',
-	CX: 'Christmas Island',
-	CC: 'Cocos (Keeling) Islands',
-	CO: 'Colombia',
-	KM: 'Comoros',
-	CG: 'Congo',
-	CD: 'Congo, the Democratic Republic of the',
-	CK: 'Cook Islands',
-	CR: 'Costa Rica',
-	CI: "Côte d'Ivoire",
-	HR: 'Croatia',
-	CU: 'Cuba',
-	CW: 'Curaçao',
-	CY: 'Cyprus',
-	CZ: 'Czech Republic',
-	DK: 'Denmark',
-	DJ: 'Djibouti',
-	DM: 'Dominica',
-	DO: 'Dominican Republic',
-	EC: 'Ecuador',
-	EG: 'Egypt',
-	SV: 'El Salvador',
-	GQ: 'Equatorial Guinea',
-	ER: 'Eritrea',
-	EE: 'Estonia',
-	ET: 'Ethiopia',
-	FK: 'Falkland Islands (Malvinas)',
-	FO: 'Faroe Islands',
-	FJ: 'Fiji',
-	FI: 'Finland',
-	FR: 'France',
-	GF: 'French Guiana',
-	PF: 'French Polynesia',
-	TF: 'French Southern Territories',
-	GA: 'Gabon',
-	GM: 'Gambia',
-	GE: 'Georgia',
-	DE: 'Germany',
-	GH: 'Ghana',
-	GI: 'Gibraltar',
-	GR: 'Greece',
-	GL: 'Greenland',
-	GD: 'Grenada',
-	GP: 'Guadeloupe',
-	GU: 'Guam',
-	GT: 'Guatemala',
-	GG: 'Guernsey',
-	GN: 'Guinea',
-	GW: 'Guinea-Bissau',
-	GY: 'Guyana',
-	HT: 'Haiti',
-	HM: 'Heard Island and McDonald Mcdonald Islands',
-	VA: 'Holy See (Vatican City State)',
-	HN: 'Honduras',
-	HK: 'Hong Kong',
-	HU: 'Hungary',
-	IS: 'Iceland',
-	IN: 'India',
-	ID: 'Indonesia',
-	IR: 'Iran, Islamic Republic of',
-	IQ: 'Iraq',
-	IE: 'Ireland',
-	IM: 'Isle of Man',
-	IL: 'Israel',
-	IT: 'Italy',
-	JM: 'Jamaica',
-	JP: 'Japan',
-	JE: 'Jersey',
-	JO: 'Jordan',
-	KZ: 'Kazakhstan',
-	KE: 'Kenya',
-	KI: 'Kiribati',
-	XK: 'Kosovo',
-	KP: "Korea, Democratic People's Republic of",
-	KR: 'Korea, Republic of',
-	KW: 'Kuwait',
-	KG: 'Kyrgyzstan',
-	LA: "Lao People's Democratic Republic",
-	LV: 'Latvia',
-	LB: 'Lebanon',
-	LS: 'Lesotho',
-	LR: 'Liberia',
-	LY: 'Libya',
-	LI: 'Liechtenstein',
-	LT: 'Lithuania',
-	LU: 'Luxembourg',
-	MO: 'Macao',
-	MK: 'North Macedonia',
-	MG: 'Madagascar',
-	MW: 'Malawi',
-	MY: 'Malaysia',
-	MV: 'Maldives',
-	ML: 'Mali',
-	MT: 'Malta',
-	MH: 'Marshall Islands',
-	MQ: 'Martinique',
-	MR: 'Mauritania',
-	MU: 'Mauritius',
-	YT: 'Mayotte',
-	MX: 'Mexico',
-	FM: 'Micronesia, Federated States of',
-	MD: 'Moldova, Republic of',
-	MC: 'Monaco',
-	MN: 'Mongolia',
-	ME: 'Montenegro',
-	MS: 'Montserrat',
-	MA: 'Morocco',
-	MZ: 'Mozambique',
-	MM: 'Myanmar',
-	NA: 'Namibia',
-	NR: 'Nauru',
-	NP: 'Nepal',
-	NL: 'Netherlands',
-	AN: 'Netherlands Antilles',
-	NC: 'New Caledonia',
-	NZ: 'New Zealand',
-	NI: 'Nicaragua',
-	NE: 'Niger',
-	NG: 'Nigeria',
-	NU: 'Niue',
-	NF: 'Norfolk Island',
-	MP: 'Northern Mariana Islands',
-	NO: 'Norway',
-	OM: 'Oman',
-	PK: 'Pakistan',
-	PW: 'Palau',
-	PS: 'Palestine, State of',
-	PA: 'Panama',
-	PG: 'Papua New Guinea',
-	PY: 'Paraguay',
-	PE: 'Peru',
-	PH: 'Philippines',
-	PN: 'Pitcairn',
-	PL: 'Poland',
-	PT: 'Portugal',
-	PR: 'Puerto Rico',
-	QA: 'Qatar',
-	RE: 'Réunion',
-	RO: 'Romania',
-	RU: 'Russian Federation',
-	RW: 'Rwanda',
-	BL: 'Saint Barthélemy',
-	SH: 'Saint Helena, Ascension and Tristan da Cunha',
-	KN: 'Saint Kitts and Nevis',
-	LC: 'Saint Lucia',
-	MF: 'Saint Martin (French part)',
-	PM: 'Saint Pierre and Miquelon',
-	VC: 'Saint Vincent and the Grenadines',
-	WS: 'Samoa',
-	SM: 'San Marino',
-	ST: 'Sao Tome and Principe',
-	SA: 'Saudi Arabia',
-	SN: 'Senegal',
-	RS: 'Serbia',
-	SC: 'Seychelles',
-	SL: 'Sierra Leone',
-	SG: 'Singapore',
-	SX: 'Sint Maarten (Dutch part)',
-	SK: 'Slovakia',
-	SI: 'Slovenia',
-	SB: 'Solomon Islands',
-	SO: 'Somalia',
-	ZA: 'South Africa',
-	GS: 'South Georgia and the South Sandwich Islands',
-	SS: 'South Sudan',
-	ES: 'Spain',
-	LK: 'Sri Lanka',
-	SD: 'Sudan',
-	SR: 'Suriname',
-	SJ: 'Svalbard and Jan Mayen',
-	SZ: 'Swaziland',
-	SE: 'Sweden',
-	CH: 'Switzerland',
-	SY: 'Syrian Arab Republic',
-	TW: 'Taiwan, Province of China',
-	TJ: 'Tajikistan',
-	TZ: 'Tanzania, United Republic of',
-	TH: 'Thailand',
-	TL: 'Timor-Leste',
-	TG: 'Togo',
-	TK: 'Tokelau',
-	TO: 'Tonga',
-	TT: 'Trinidad and Tobago',
-	TN: 'Tunisia',
-	TR: 'Turkey',
-	TM: 'Turkmenistan',
-	TC: 'Turks and Caicos Islands',
-	TV: 'Tuvalu',
-	UG: 'Uganda',
-	UA: 'Ukraine',
-	AE: 'United Arab Emirates',
-	GB: 'United Kingdom',
-	US: 'United States',
-	UM: 'United States Minor Outlying Islands',
-	UY: 'Uruguay',
-	UZ: 'Uzbekistan',
-	VU: 'Vanuatu',
-	VE: 'Venezuela, Bolivarian Republic of',
-	VN: 'Viet Nam',
-	VG: 'Virgin Islands, British',
-	VI: 'Virgin Islands, U.S.',
-	WF: 'Wallis and Futuna',
-	EH: 'Western Sahara',
-	YE: 'Yemen',
-	ZM: 'Zambia',
-	ZW: 'Zimbabwe'
-}
-
-export function isValidCountryCode(countryCode: string): boolean {
-	return (countryCode.toUpperCase() in countries)
-}

package/src/server/utils/keep-alive.ts

@@ -1,50 +0,0 @@
-import type { Logger } from 'pino'
-import type { WebSocket } from 'ws'
-
-import { MAX_NO_DATA_INTERVAL_MS, PING_INTERVAL_MS } from '#src/config/index.ts'
-
-/**
- * Adds a keep-alive mechanism to the WebSocket
- * client
- */
-export function addKeepAlive(ws: WebSocket, logger: Logger) {
-	let sendTimeout: NodeJS.Timeout
-	let killTimeout: NodeJS.Timeout
-
-	ws.on('message', () => {
-		logger.trace('data recv, resetting timer')
-		resetTimer()
-	})
-	ws.on('pong', () => {
-		logger.trace('pong received, resetting timer')
-		resetTimer()
-	})
-
-	ws.on('error', cleanup)
-	ws.on('close', cleanup)
-
-	function resetTimer() {
-		cleanup()
-		resetSendTimeout()
-
-		killTimeout = setTimeout(() => {
-			logger.warn(
-				'no data received in a while, closing connection'
-			)
-			ws.close()
-		}, MAX_NO_DATA_INTERVAL_MS)
-	}
-
-	function resetSendTimeout() {
-		// reset ping
-		sendTimeout = setTimeout(() => {
-			ws.ping()
-			resetSendTimeout()
-		}, PING_INTERVAL_MS)
-	}
-
-	function cleanup() {
-		clearTimeout(killTimeout)
-		clearTimeout(sendTimeout)
-	}
-}

package/src/server/utils/nitro-attestation.ts

@@ -1,396 +0,0 @@
-/**
- * Working Nitro Attestation validation utilities
- */
-
-import { AsnParser } from '@peculiar/asn1-schema'
-import { SubjectPublicKeyInfo } from '@peculiar/asn1-x509'
-import { Crypto } from '@peculiar/webcrypto'
-import { X509Certificate, X509ChainBuilder } from '@peculiar/x509'
-import { sign } from 'cose-js'
-
-// Nitro-specific types
-export interface AttestationDocument {
-	module_id: string
-	digest: string
-	timestamp: bigint
-	pcrs: { [key: number]: Buffer }
-	certificate: Buffer
-	cabundle: Buffer[]
-	public_key?: Buffer
-	user_data?: Buffer
-	nonce?: Buffer
-}
-
-export interface NitroValidationResult {
-	isValid: boolean
-	errors: string[]
-	warnings: string[]
-	userDataType?: 'tee_k' | 'tee_t'
-	ethAddress?: string
-	pcr0: string
-}
-
-export interface AddressExtractionResult {
-	teeType: 'tee_k' | 'tee_t'
-	ethAddress?: string
-	pcr0: string
-}
-
-// Helper function to dynamically import cbor-x
-async function getCborDecode() {
-	const { decode } = await import('cbor-x')
-	return decode
-}
-
-// AWS Nitro root certificate (from nitrite)
-const AWS_NITRO_ROOT_CERT = `-----BEGIN CERTIFICATE-----
-MIICETCCAZagAwIBAgIRAPkxdWgbkK/hHUbMtOTn+FYwCgYIKoZIzj0EAwMwSTEL
-MAkGA1UEBhMCVVMxDzANBgNVBAoMBkFtYXpvbjEMMAoGA1UECwwDQVdTMRswGQYD
-VQQDDBJhd3Mubml0cm8tZW5jbGF2ZXMwHhcNMTkxMDI4MTMyODA1WhcNNDkxMDI4
-MTQyODA1WjBJMQswCQYDVQQGEwJVUzEPMA0GA1UECgwGQW1hem9uMQwwCgYDVQQL
-DANBV1MxGzAZBgNVBAMMEmF3cy5uaXRyby1lbmNsYXZlczB2MBAGByqGSM49AgEG
-BSuBBAAiA2IABPwCVOumCMHzaHDimtqQvkY4MpJzbolL//Zy2YlES1BR5TSksfbb
-48C8WBoyt7F2Bw7eEtaaP+ohG2bnUs990d0JX28TcPQXCEPZ3BABIeTPYwEoCWZE
-h8l5YoQwTcU/9KNCMEAwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkCW1DdkF
-R+eWw5b6cp3PmanfS5YwDgYDVR0PAQH/BAQDAgGGMAoGCCqGSM49BAMDA2kAMGYC
-MQCjfy+Rocm9Xue4YnwWmNJVA44fA0P5W2OpYow9OYCVRaEevL8uO1XYru5xtMPW
-rfMCMQCi85sWBbJwKKXdS6BptQFuZbT73o/gBh1qUxl/nNr12UO8Yfwr6wPLb+6N
-IwLz3/Y=
------END CERTIFICATE-----`
-
-// Expected PCR values (replace with actual values)
-// const EXPECTED_PCRS = {
-// 	//0: Buffer.from('000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000', 'hex'),
-// }
-//
-// // Secure buffer comparison to prevent timing attacks
-// function secureBufferCompare(a: Buffer, b: Buffer): boolean {
-// 	if(a.length !== b.length) {
-// 		return false
-// 	}
-//
-// 	let result = 0
-// 	for(const [i, element] of a.entries()) {
-// 		result |= element ^ b[i]
-// 	}
-//
-// 	return result === 0
-// }
-
-// Enhanced certificate chain validation
-async function validateCertificateChain(
-	targetCert: X509Certificate,
-	intermediateCerts: X509Certificate[],
-	rootCert: X509Certificate,
-	crypto: Crypto
-): Promise<{ isValid: boolean, errors: string[], chain: X509Certificate[] }> {
-	const errors: string[] = []
-
-	try {
-		// Validate root certificate is self-signed and trusted
-		const rootSubject = rootCert.subject
-		const rootIssuer = rootCert.issuer
-
-		if(rootSubject !== rootIssuer) {
-			errors.push('Root certificate is not self-signed')
-		}
-
-		// Verify root certificate signature (self-verification)
-		try {
-			const isRootValid = await rootCert.verify(undefined, crypto)
-			if(!isRootValid) {
-				errors.push('Root certificate signature verification failed')
-			}
-		} catch(error) {
-			errors.push(`Root certificate verification failed: ${(error as Error).message}`)
-		}
-
-		// Build the certificate chain
-		const chainBuilder = new X509ChainBuilder({
-			certificates: [rootCert, ...intermediateCerts]
-		})
-
-		let chain: X509Certificate[]
-		try {
-			chain = await chainBuilder.build(targetCert, crypto)
-		} catch(error) {
-			errors.push(`Certificate chain building failed: ${(error as Error).message}`)
-			return { isValid: false, errors, chain: [] }
-		}
-
-		if(!chain || chain.length === 0) {
-			errors.push('No valid certificate chain could be built')
-			return { isValid: false, errors, chain: [] }
-		}
-
-		// Validate each certificate in the chain
-		const now = new Date()
-		for(let i = 0; i < chain.length; i++) {
-			const cert = chain[i]
-
-			// Check expiration dates
-			if(now < cert.notBefore) {
-				errors.push(`Certificate ${i} (${cert.subject}) is not yet valid`)
-			}
-
-			if(now > cert.notAfter) {
-				errors.push(`Certificate ${i} (${cert.subject}) has expired`)
-			}
-
-			// Verify each certificate's signature (except root which is self-signed)
-			if(i < chain.length - 1) {
-				try {
-					const issuer = chain[i + 1]
-					const isValid = await cert.verify(issuer, crypto)
-					// eslint-disable-next-line max-depth
-					if(!isValid) {
-						errors.push(`Certificate ${i} signature verification failed`)
-					}
-				} catch(error) {
-					errors.push(`Certificate ${i} verification failed: ${(error as Error).message}`)
-				}
-			}
-		}
-
-		return {
-			isValid: errors.length === 0,
-			errors,
-			chain
-		}
-	} catch(error) {
-		errors.push(`Certificate chain validation error: ${(error as Error).message}`)
-		return { isValid: false, errors, chain: [] }
-	}
-}
-
-/**
- * Extract public key from user_data field in attestation document
- */
-function extractPublicKeyFromUserData(userDataBuffer: Buffer): AddressExtractionResult | null {
-	try {
-		const userDataString = userDataBuffer.toString('utf-8')
-
-		// Parse new format: "tee_k_public_key:0xETH_ADDRESS" or "tee_t_public_key:0xETH_ADDRESS"
-		const teeKMatch = userDataString.match(/^tee_k_public_key:(0x[0-9a-fA-F]{40})$/)
-		const teeTMatch = userDataString.match(/^tee_t_public_key:(0x[0-9a-fA-F]{40})$/)
-
-		if(teeKMatch) {
-			return {
-				teeType: 'tee_k',
-				ethAddress: teeKMatch[1], // Store the full ETH address with 0x prefix
-				pcr0: ''
-			}
-		}
-
-		if(teeTMatch) {
-			return {
-				teeType: 'tee_t',
-				ethAddress: teeTMatch[1], // Store the full ETH address with 0x prefix
-				pcr0: ''
-			}
-		}
-
-		return null
-	} catch(error) {
-		return null
-	}
-}
-
-/**
- * Working validation function copied from nitroattestor
- */
-export async function validateNitroAttestationAndExtractKey(
-	attestationBytes: Uint8Array
-): Promise<NitroValidationResult> {
-	const errors: string[] = []
-	const warnings: string[] = []
-
-	try {
-		// Set up WebCrypto
-		const crypto = new Crypto()
-
-		// Decode CBOR - use exact same approach as working nitroattestor
-		const decode = await getCborDecode()
-		let decoded: any
-		try {
-			decoded = decode(Buffer.from(attestationBytes))
-		} catch(error) {
-			errors.push(`CBOR decoding failed: ${(error as Error).message}`)
-			return { isValid: false, errors, warnings, pcr0: '' }
-		}
-
-		// Extract COSE_Sign1 structure
-		if(!Array.isArray(decoded) || decoded.length < 4) {
-			errors.push('Invalid COSE_Sign1 structure: expected array with 4 elements')
-			return { isValid: false, errors, warnings, pcr0: '' }
-		}
-
-		const [, , payload] = decoded
-
-		// Validate payload exists and is not empty
-		if(!payload || payload.length === 0) {
-			errors.push('Empty or missing payload in COSE_Sign1 structure')
-			return { isValid: false, errors, warnings, pcr0: '' }
-		}
-
-		// Decode payload - use exact same approach as working code
-		let doc: AttestationDocument
-		try {
-			doc = decode(payload) as AttestationDocument
-		} catch(error) {
-			errors.push(`Payload decoding failed: ${(error as Error).message}`)
-			return { isValid: false, errors, warnings, pcr0: '' }
-		}
-
-		// Validate mandatory fields with strict type checking
-		if(doc.module_id.length === 0) {
-			errors.push('Missing or invalid module_id')
-		}
-
-		if(doc.digest.length === 0) {
-			errors.push('Missing or invalid digest')
-		}
-
-		if(!doc.pcrs || typeof doc.pcrs !== 'object') {
-			errors.push('Missing or invalid pcrs')
-		}
-
-		if(!Buffer.isBuffer(doc.certificate) || doc.certificate.length === 0) {
-			errors.push('Missing or invalid certificate')
-		}
-
-		if(!Array.isArray(doc.cabundle) || doc.cabundle.length === 0) {
-			errors.push('Missing or invalid cabundle')
-		}
-
-		// Early return if basic validation fails
-		if(errors.length > 0) {
-			return { isValid: false, errors, warnings, pcr0: '' }
-		}
-
-		const pcr0 = doc.pcrs[0].toString('hex')
-
-		// Validate PCRs with secure comparison
-		// for(const [index, expected] of Object.entries(EXPECTED_PCRS)) {
-		// 	const pcrIndex = parseInt(index)
-		// 	const actualPcr = doc.pcrs[pcrIndex]
-		//
-		// 	if(!Buffer.isBuffer(actualPcr)) {
-		// 		errors.push(`PCR${index} is not a Buffer`)
-		// 		continue
-		// 	}
-		//
-		// 	if(!secureBufferCompare(expected, actualPcr)) {
-		// 		errors.push(`PCR${index} mismatch`)
-		// 	}
-		// }
-
-		// Parse certificates with better error handling
-		const intermediateCerts: X509Certificate[] = []
-		for(let i = 0; i < doc.cabundle.length; i++) {
-			try {
-				const cert = new X509Certificate(doc.cabundle[i].toString('base64'))
-				intermediateCerts.push(cert)
-			} catch(error) {
-				errors.push(`Failed to parse cabundle certificate ${i}: ${(error as Error).message}`)
-			}
-		}
-
-		// Parse target certificate
-		let targetCert: X509Certificate
-		try {
-			targetCert = new X509Certificate(doc.certificate.toString('base64'))
-		} catch(error) {
-			errors.push(`Failed to parse target certificate: ${(error as Error).message}`)
-			return { isValid: false, errors, warnings, pcr0: '' }
-		}
-
-		// Parse root certificate
-		let rootCert: X509Certificate
-		try {
-			rootCert = new X509Certificate(AWS_NITRO_ROOT_CERT)
-		} catch(error) {
-			errors.push(`Failed to parse AWS Nitro root certificate: ${(error as Error).message}`)
-			return { isValid: false, errors, warnings, pcr0: '' }
-		}
-
-		// Enhanced certificate chain validation
-		const chainResult = await validateCertificateChain(targetCert, intermediateCerts, rootCert, crypto)
-		if(!chainResult.isValid) {
-			errors.push(...chainResult.errors)
-			return { isValid: false, errors, warnings, pcr0: '' }
-		}
-
-		// Parse and validate public key
-		let publicKeyRaw: Buffer
-		try {
-			publicKeyRaw = Buffer.from(targetCert.publicKey.rawData)
-		} catch(error) {
-			errors.push(`Failed to extract public key: ${(error as Error).message}`)
-			return { isValid: false, errors, warnings, pcr0: '' }
-		}
-
-		// Validate public key format (P-384 ECDSA)
-		if(publicKeyRaw.length !== 120 || publicKeyRaw[0] !== 0x30) {
-			errors.push(`Invalid public key format: expected 120-byte DER-encoded key, got ${publicKeyRaw.length} bytes`)
-			return { isValid: false, errors, warnings, pcr0: '' }
-		}
-
-		let spki: SubjectPublicKeyInfo
-		try {
-			spki = AsnParser.parse(publicKeyRaw, SubjectPublicKeyInfo)
-		} catch(error) {
-			errors.push(`Failed to parse SubjectPublicKeyInfo: ${(error as Error).message}`)
-			return { isValid: false, errors, warnings, pcr0: '' }
-		}
-
-		const ecPoint = Buffer.from(spki.subjectPublicKey)
-		if(ecPoint.length !== 97 || ecPoint[0] !== 0x04) {
-			errors.push('Invalid EC point: expected 97-byte uncompressed P-384 key')
-			return { isValid: false, errors, warnings, pcr0: '' }
-		}
-
-		const x = ecPoint.subarray(1, 49) // 48-byte x coordinate
-		const y = ecPoint.subarray(49, 97) // 48-byte y coordinate
-
-		// Validate ECDSA signature using cose-js
-		try {
-			const verifier = {
-				key: {
-					x: x,
-					y: y,
-				},
-			}
-			const options = { defaultType: 18 } // cose.sign.Sign1Tag
-			await sign.verify(Buffer.from(attestationBytes), verifier, options)
-		} catch(error) {
-			errors.push(`COSE signature verification failed: ${(error as Error).message}`)
-			return { isValid: false, errors, warnings, pcr0: '' }
-		}
-
-		// Extract public key from user_data if present
-		let userDataType: 'tee_k' | 'tee_t' | undefined
-		let ethAddress: string | undefined
-
-		if(doc.user_data) {
-			const keyInfo = extractPublicKeyFromUserData(doc.user_data)
-			if(keyInfo) {
-				userDataType = keyInfo.teeType
-				ethAddress = keyInfo.ethAddress
-			}
-		}
-
-		return {
-			isValid: errors.length === 0,
-			errors,
-			warnings,
-			userDataType,
-			ethAddress,
-			pcr0: pcr0
-		}
-
-	} catch(error) {
-		errors.push(`Unexpected error during validation: ${(error as Error).message}`)
-		return { isValid: false, errors, warnings, pcr0: '' }
-	}
-}