Function DecryptWithCachedCrypto

internal/proxy/parser.go:464–523

DecryptWithCachedCrypto decrypts an Initial packet using pre-derived keys. This is faster than decryptInitialPacket as it reuses cipher objects. Uses buffer pool to avoid per-packet allocations.

(packet, encrypted []byte,
	hpCipher cipher.Block, aead cipher.AEAD, iv []byte)

// This is faster than decryptInitialPacket as it reuses cipher objects.
// Uses buffer pool to avoid per-packet allocations.
func DecryptWithCachedCrypto(packet, encrypted []byte,
	hpCipher cipher.Block, aead cipher.AEAD, iv []byte) ([]byte, error) {

	if len(encrypted) < 20 {
		return nil, errors.New("encrypted payload too short")
	}

	// Sample starts at 4 bytes into the payload (after packet number)
	sample := encrypted[4:20]
	var mask [16]byte // Stack allocation
	hpCipher.Encrypt(mask[:], sample)

	// Get buffer from pool for packet copy (avoids allocation)
	bufPtr := handler.GetBuffer()
	defer handler.PutBuffer(bufPtr)
	packetCopy := (*bufPtr)[:len(packet)]
	copy(packetCopy, packet)

	// Remove header protection from first byte
	if packetCopy[0]&0x80 == 0x80 {
		packetCopy[0] ^= mask[0] & 0x0f
	} else {
		packetCopy[0] ^= mask[0] & 0x1f
	}

	// Determine packet number length
	pnLen := (packetCopy[0] & 0x03) + 1

	// Find packet number offset (need to recalculate)
	pnOffset := len(packet) - len(encrypted)

	// Remove header protection from packet number
	for i := 0; i < int(pnLen); i++ {
		packetCopy[pnOffset+i] ^= mask[1+i]
	}

	// Read packet number
	var pn uint64
	for i := 0; i < int(pnLen); i++ {
		pn = (pn << 8) | uint64(packetCopy[pnOffset+i])
	}

	// Create nonce (stack allocation)
	var nonce [12]byte
	copy(nonce[:], iv)
	for i := 0; i < 8; i++ {
		nonce[4+i] ^= byte(pn >> (56 - 8*i))
	}

	// Decrypt
	ciphertext := encrypted[pnLen:]
	aad := packetCopy[:pnOffset+int(pnLen)] // Associated data is the header

	plaintext, err := aead.Open(nil, nonce[:], ciphertext, aad)
	if err != nil {
		return nil, fmt.Errorf("decryption failed: %w", err)
	}