cert_summary.go

package gokalkan

import (
	"encoding/asn1"
	"encoding/base64"
	"encoding/pem"
	"regexp"
	"strings"
	"time"

	"github.com/ncanode-kz/gokalkan/ckalkan"
)

type (
	// RevocationType - способ проверки отозванности сертификата.
	RevocationType string

	// KeyUsage - упрощённое (в терминах NCA) назначение ключа сертификата.
	// Это НЕ побитовая семантика стандартного X.509 KeyUsage, а бизнес-классификация,
	// которую использует kz.gov.pki-экосистема: сертификат либо для аутентификации,
	// либо для подписи.
	KeyUsage string
)

const (
	RevocationTypeOCSP RevocationType = "OCSP"
	RevocationTypeCRL  RevocationType = "CRL"

	KeyUsageUnknown KeyUsage = "UNKNOWN"
	KeyUsageAuth    KeyUsage = "AUTH"
	KeyUsageSign    KeyUsage = "SIGN"
)

// Revocation - результат одной проверки отозванности (OCSP или CRL).
type Revocation struct {
	Type    RevocationType
	Revoked bool
	Reason  string
	// RevokedAt - точное время отзыва, если revoked=true и его удалось
	// извлечь из текстового отчёта нативной библиотеки (X509ValidateCertificate
	// возвращает секцию "Revocation Time: DD.MM.YYYY HH:MM:SS +HH:MM" при
	// проверке через OCSP - см. revokedAtRe). Zero value, если не найдено.
	RevokedAt time.Time
}

// CertificateInfo - расширенная информация о сертификате, аналог CertificateInfo
// в NCANode (Java): помимо разбора полей (см. Summary/X509CertificateGetSummary)
// содержит результат проверки отозванности и агрегированную валидность.
type CertificateInfo struct {
	Valid       bool
	Revocations []Revocation

	NotBefore time.Time
	NotAfter  time.Time

	KeyUsage KeyUsage
	// KeyUser - набор меток назначения сертификата: "INDIVIDUAL" или "ORGANIZATION",
	// и для организации дополнительно роль подписанта ("CEO", "SIGN", "SIGN_FINANCE",
	// "HR", "EMPLOYEE"). Кроме "INDIVIDUAL"/"ORGANIZATION"/"CEO" (сверено с NCANode)
	// остальные названия ролей - по аналогии, не сверялись с эталоном напрямую.
	KeyUser []string

	SerialNumber string
	SignAlg      string
	PublicKey    string
	// Signature - "сырое" значение подписи сертификата (BIT STRING из
	// Certificate.signatureValue), в base64. Извлекается обычным ASN.1-разбором
	// внешней структуры X.509 (не зависит от алгоритма подписи, GOST в том числе).
	Signature string

	Subject      CertSubject
	Organization *CertOrganization
	Issuer       CertIssuer
}

// GetCertificateInfo возвращает расширенную информацию о сертификате, включая
// результат проверки отозванности. checkOCSP включает проверку через OCSP
// (URL берётся из опций клиента, см. WithOCSP/OptsTest/OptsProd). crlPath,
// если не пустой, включает проверку по локальному файлу CRL (см. ValidateCertCRL).
func (cli *Client) GetCertificateInfo(cert string, checkOCSP bool, crlPath string) (*CertificateInfo, error) {
	summary, err := cli.X509CertificateGetSummary(cert)
	if err != nil {
		return nil, err
	}

	info := &CertificateInfo{
		Valid:        true,
		NotBefore:    summary.NotBefore,
		NotAfter:     summary.NotAfter,
		SerialNumber: strings.ToLower(summary.SerialNumber),
		PublicKey:    summary.PublicKey,
		Subject:      summary.Subject,
		Organization: summary.Organization,
		Issuer:       summary.Issuer,
	}

	now := time.Now()
	if now.Before(info.NotBefore) || now.After(info.NotAfter) {
		info.Valid = false
	}

	info.KeyUser = buildKeyUser(summary)

	rawKeyUsage, err := cli.kc.X509CertificateGetInfo(cert, ckalkan.CertPropKeyUsage)
	if err != nil {
		return nil, err
	}
	info.KeyUsage = parseKeyUsage(rawKeyUsage)

	rawSignAlg, err := cli.kc.X509CertificateGetInfo(cert, ckalkan.CertPropSignatureAlg)
	if err != nil {
		return nil, err
	}
	info.SignAlg = cleanupValue(rawSignAlg, "=")

	if sig, err := extractRawSignature(cert); err == nil {
		info.Signature = sig
	}

	if checkOCSP {
		raw, verr := cli.ValidateCertOCSP(cert)
		rev := Revocation{Type: RevocationTypeOCSP, Revoked: verr != nil}
		if verr != nil {
			rev.Reason = verr.Error()
			rev.RevokedAt = parseRevokedAt(raw)
			info.Valid = false
		}
		info.Revocations = append(info.Revocations, rev)
	}

	if crlPath != "" {
		_, verr := cli.ValidateCertCRL(cert, crlPath)
		rev := Revocation{Type: RevocationTypeCRL, Revoked: verr != nil}
		if verr != nil {
			rev.Reason = verr.Error()
			info.Valid = false
		}
		info.Revocations = append(info.Revocations, rev)
	}

	return info, nil
}

// parseKeyUsage сводит битовую маску X.509 KeyUsage к упрощённой классификации
// AUTH/SIGN, принятой в NCA-экосистеме: наличие nonRepudiation (contentCommitment,
// бит 1) означает сертификат для ЭЦП (SIGN), наличие keyEncipherment (бит 2) без
// nonRepudiation - сертификат для аутентификации/шифрования (AUTH).
func parseKeyUsage(raw string) KeyUsage {
	value := cleanupValue(raw, "=")
	bits := strings.Fields(value)

	set := make(map[string]bool, len(bits))
	for _, b := range bits {
		set[b] = true
	}

	switch {
	case set["nonRepudiation"]:
		return KeyUsageSign
	case set["keyEncipherment"]:
		return KeyUsageAuth
	default:
		return KeyUsageUnknown
	}
}

func buildKeyUser(summary *Summary) []string {
	if summary.Type == CertTypeIndividual {
		return []string{"INDIVIDUAL"}
	}

	users := []string{"ORGANIZATION"}

	if summary.Organization != nil {
		switch summary.Organization.SubjectRole {
		case CertSubjectRoleCEO:
			users = append(users, "CEO")
		case CertSubjectRoleSign:
			users = append(users, "SIGN")
		case CertSubjectRoleSignFinance:
			users = append(users, "SIGN_FINANCE")
		case CertSubjectRoleHR:
			users = append(users, "HR")
		case CertSubjectRoleEmployee:
			users = append(users, "EMPLOYEE")
		}
	}

	return users
}

//nolint:gochecknoglobals
var revokedAtRe = regexp.MustCompile(`Revocation Time: (\d{2}\.\d{2}\.\d{4} \d{2}:\d{2}:\d{2} \S+)`)

// parseRevokedAt извлекает точное время отзыва из текстового отчёта
// X509ValidateCertificate (см. ValidateCertOCSP) - эмпирически подтверждено,
// что при статусе OCSP "revoked" отчёт содержит строку вида
// "Revocation Time: 08.05.2026 14:57:29 ALMT" (либо, реже, с числовым
// оффсетом вместо аббревиатуры - см. parseKalkanTime). Возвращает нулевое
// время, если строка не найдена или не распозналась.
func parseRevokedAt(raw string) time.Time {
	m := revokedAtRe.FindStringSubmatch(raw)
	if m == nil {
		return time.Time{}
	}

	t, err := parseKalkanTime(m[1])
	if err != nil {
		return time.Time{}
	}

	return t
}

type derCertificate struct {
	TBSCertificate     asn1.RawValue
	SignatureAlgorithm asn1.RawValue
	SignatureValue     asn1.BitString
}

// extractRawSignature вытаскивает Certificate.signatureValue напрямую из DER,
// без разбора алгоритмо-специфичных полей внутри TBSCertificate - поэтому
// работает одинаково для GOST- и RSA-сертификатов.
func extractRawSignature(certPEM string) (string, error) {
	der := []byte(certPEM)

	if block, _ := pem.Decode([]byte(certPEM)); block != nil {
		der = block.Bytes
	}

	var c derCertificate
	if _, err := asn1.Unmarshal(der, &c); err != nil {
		return "", err
	}

	return base64.StdEncoding.EncodeToString(c.SignatureValue.Bytes), nil
}