| // Copyright 2022 Google LLC. |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // https://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| //go:build windows |
| // +build windows |
| |
| // Cert_util provides helpers for working with Windows certificates via crypt32.dll |
| |
| package ncrypt |
| |
| import ( |
| "crypto" |
| "crypto/x509" |
| "errors" |
| "fmt" |
| "io" |
| "syscall" |
| "unsafe" |
| |
| "golang.org/x/sys/windows" |
| ) |
| |
| const ( |
| // wincrypt.h constants |
| encodingX509ASN = 1 // X509_ASN_ENCODING |
| certStoreCurrentUserID = 1 // CERT_SYSTEM_STORE_CURRENT_USER_ID |
| certStoreLocalMachineID = 2 // CERT_SYSTEM_STORE_LOCAL_MACHINE_ID |
| infoIssuerFlag = 4 // CERT_INFO_ISSUER_FLAG |
| compareNameStrW = 8 // CERT_COMPARE_NAME_STR_A |
| certStoreProvSystem = 10 // CERT_STORE_PROV_SYSTEM |
| compareShift = 16 // CERT_COMPARE_SHIFT |
| locationShift = 16 // CERT_SYSTEM_STORE_LOCATION_SHIFT |
| findIssuerStr = compareNameStrW<<compareShift | infoIssuerFlag // CERT_FIND_ISSUER_STR_W |
| certStoreLocalMachine = certStoreLocalMachineID << locationShift // CERT_SYSTEM_STORE_LOCAL_MACHINE |
| certStoreCurrentUser = certStoreCurrentUserID << locationShift // CERT_SYSTEM_STORE_CURRENT_USER |
| signatureKeyUsage = 0x80 // CERT_DIGITAL_SIGNATURE_KEY_USAGE |
| acquireCached = 0x1 // CRYPT_ACQUIRE_CACHE_FLAG |
| acquireSilent = 0x40 // CRYPT_ACQUIRE_SILENT_FLAG |
| acquireOnlyNCryptKey = 0x40000 // CRYPT_ACQUIRE_ONLY_NCRYPT_KEY_FLAG |
| ncryptKeySpec = 0xFFFFFFFF // CERT_NCRYPT_KEY_SPEC |
| certChainCacheOnlyURLRetrieval = 0x00000004 // CERT_CHAIN_CACHE_ONLY_URL_RETRIEVAL |
| certChainDisableAIA = 0x00002000 // CERT_CHAIN_DISABLE_AIA |
| certChainRevocationCheckCacheOnly = 0x80000000 // CERT_CHAIN_REVOCATION_CHECK_CACHE_ONLY |
| |
| hcceLocalMachine = windows.Handle(0x01) // HCCE_LOCAL_MACHINE |
| |
| // winerror.h constants |
| cryptENotFound = 0x80092004 // CRYPT_E_NOT_FOUND |
| ) |
| |
| var ( |
| null = uintptr(unsafe.Pointer(nil)) |
| |
| crypt32 = windows.MustLoadDLL("crypt32.dll") |
| |
| certFindCertificateInStore = crypt32.MustFindProc("CertFindCertificateInStore") |
| certGetIntendedKeyUsage = crypt32.MustFindProc("CertGetIntendedKeyUsage") |
| cryptAcquireCertificatePrivateKey = crypt32.MustFindProc("CryptAcquireCertificatePrivateKey") |
| ) |
| |
| // findCert wraps the CertFindCertificateInStore call. Note that any cert context passed |
| // into prev will be freed. If no certificate was found, nil will be returned. |
| func findCert(store windows.Handle, enc uint32, findFlags uint32, findType uint32, para *uint16, prev *windows.CertContext) (*windows.CertContext, error) { |
| h, _, err := certFindCertificateInStore.Call( |
| uintptr(store), |
| uintptr(enc), |
| uintptr(findFlags), |
| uintptr(findType), |
| uintptr(unsafe.Pointer(para)), |
| uintptr(unsafe.Pointer(prev)), |
| ) |
| if h == 0 { |
| // Actual error, or simply not found? |
| errno, ok := err.(syscall.Errno) |
| if !ok { |
| return nil, err |
| } |
| if errno == cryptENotFound { |
| return nil, nil |
| } |
| return nil, err |
| } |
| return (*windows.CertContext)(unsafe.Pointer(h)), nil |
| } |
| |
| // extractSimpleChain extracts the final certificate chain from a CertSimpleChain. |
| // Adapted from crypto.x509.root_windows |
| func extractSimpleChain(simpleChain **windows.CertSimpleChain, chainCount int) ([]*x509.Certificate, error) { |
| if simpleChain == nil || chainCount == 0 { |
| return nil, errors.New("invalid simple chain") |
| } |
| // Convert the simpleChain array to a huge slice and slice it to the length we want. |
| // https://github.com/golang/go/wiki/cgo#turning-c-arrays-into-go-slices |
| simpleChains := (*[1 << 20]*windows.CertSimpleChain)(unsafe.Pointer(simpleChain))[:chainCount:chainCount] |
| // Each simple chain contains the chain of certificates, summary trust information |
| // about the chain, and trust information about each certificate element in the chain. |
| // Select the last chain since only expect to encounter one chain. |
| lastChain := simpleChains[chainCount-1] |
| chainLen := int(lastChain.NumElements) |
| elements := (*[1 << 20]*windows.CertChainElement)(unsafe.Pointer(lastChain.Elements))[:chainLen:chainLen] |
| chain := make([]*x509.Certificate, 0, chainLen) |
| for _, element := range elements { |
| xc, err := certContextToX509(element.CertContext) |
| if err != nil { |
| return nil, err |
| } |
| chain = append(chain, xc) |
| } |
| return chain, nil |
| } |
| |
| // findCertChain builds a chain from a given certificate using the local machine store. |
| func findCertChain(cert *windows.CertContext) ([]*x509.Certificate, error) { |
| var ( |
| chainPara windows.CertChainPara |
| chainCtx *windows.CertChainContext |
| ) |
| |
| // Search the system for candidate certificate chains. |
| // Because we are using unsafe pointers here, we CANNOT directly call |
| // CertGetCertificateChain and MUST either use the windows or syscall library |
| // to validly use unsafe pointers. |
| // See https://golang.org/pkg/unsafe/#Pointer for valid unsafe package patterns. |
| chainPara.Size = uint32(unsafe.Sizeof(chainPara)) |
| err := windows.CertGetCertificateChain( |
| hcceLocalMachine, |
| cert, |
| nil, |
| cert.Store, |
| &chainPara, |
| certChainRevocationCheckCacheOnly|certChainCacheOnlyURLRetrieval|certChainDisableAIA, |
| 0, |
| &chainCtx) |
| |
| if err != nil { |
| return nil, fmt.Errorf("getCertificateChain: %w", err) |
| } |
| defer windows.CertFreeCertificateChain(chainCtx) |
| |
| x509Certs, err := extractSimpleChain(chainCtx.Chains, int(chainCtx.ChainCount)) |
| if err != nil { |
| return nil, fmt.Errorf("getCertificateChain extractSimpleChain: %w", err) |
| } |
| return x509Certs, nil |
| } |
| |
| // intendedKeyUsage wraps CertGetIntendedKeyUsage. If there are key usage bytes they will be returned, |
| // otherwise 0 will be returned. |
| func intendedKeyUsage(enc uint32, cert *windows.CertContext) (usage uint16) { |
| _, _, _ = certGetIntendedKeyUsage.Call(uintptr(enc), uintptr(unsafe.Pointer(cert.CertInfo)), uintptr(unsafe.Pointer(&usage)), 2) |
| return |
| } |
| |
| // acquirePrivateKey wraps CryptAcquireCertificatePrivateKey. |
| func acquirePrivateKey(cert *windows.CertContext) (windows.Handle, error) { |
| var ( |
| key windows.Handle |
| keySpec uint32 |
| mustFree int |
| ) |
| r, _, err := cryptAcquireCertificatePrivateKey.Call( |
| uintptr(unsafe.Pointer(cert)), |
| acquireCached|acquireSilent|acquireOnlyNCryptKey, |
| null, |
| uintptr(unsafe.Pointer(&key)), |
| uintptr(unsafe.Pointer(&keySpec)), |
| uintptr(unsafe.Pointer(&mustFree)), |
| ) |
| if r == 0 { |
| return 0, fmt.Errorf("acquiring private key: %x %w", r, err) |
| } |
| if mustFree != 0 { |
| return 0, fmt.Errorf("wrong mustFree [%d != 0]", mustFree) |
| } |
| if keySpec != ncryptKeySpec { |
| return 0, fmt.Errorf("wrong keySpec [%d != %d]", keySpec, ncryptKeySpec) |
| } |
| return key, nil |
| } |
| |
| // certContextToX509 extracts the x509 certificate from the cert context. |
| func certContextToX509(ctx *windows.CertContext) (*x509.Certificate, error) { |
| // To ensure we don't mess with the cert context's memory, use a copy of it. |
| src := (*[1 << 20]byte)(unsafe.Pointer(ctx.EncodedCert))[:ctx.Length:ctx.Length] |
| der := make([]byte, int(ctx.Length)) |
| copy(der, src) |
| |
| xc, err := x509.ParseCertificate(der) |
| if err != nil { |
| return xc, err |
| } |
| return xc, nil |
| } |
| |
| // Cred returns a Key wrapping the first valid certificate in the system store |
| // matching a given issuer string. |
| func Cred(issuer string, storeName string, provider string) (*Key, error) { |
| var certStore uint32 |
| if provider == "local_machine" { |
| certStore = uint32(certStoreLocalMachine) |
| } else if provider == "current_user" { |
| certStore = uint32(certStoreCurrentUser) |
| } else { |
| return nil, errors.New("provider must be local_machine or current_user") |
| } |
| storeNamePtr, err := windows.UTF16PtrFromString(storeName) |
| if err != nil { |
| return nil, err |
| } |
| store, err := windows.CertOpenStore(certStoreProvSystem, 0, null, certStore, uintptr(unsafe.Pointer(storeNamePtr))) |
| if err != nil { |
| return nil, fmt.Errorf("opening certificate store: %w", err) |
| } |
| i, err := windows.UTF16PtrFromString(issuer) |
| if err != nil { |
| return nil, err |
| } |
| var prev *windows.CertContext |
| for { |
| nc, err := findCert(store, encodingX509ASN, 0, findIssuerStr, i, prev) |
| if err != nil { |
| return nil, fmt.Errorf("finding certificates: %w", err) |
| } |
| if nc == nil { |
| return nil, errors.New("no certificate found") |
| } |
| prev = nc |
| if (intendedKeyUsage(encodingX509ASN, nc) & signatureKeyUsage) == 0 { |
| continue |
| } |
| |
| xc, err := certContextToX509(nc) |
| if err != nil { |
| continue |
| } |
| |
| machineChain, err := findCertChain(nc) |
| if err != nil { |
| continue |
| } |
| return &Key{ |
| cert: xc, |
| ctx: nc, |
| store: store, |
| chain: machineChain, |
| }, nil |
| } |
| } |
| |
| // Key is a wrapper around the certificate store and context that uses it to |
| // implement signing-related methods with CryptoNG functionality. |
| type Key struct { |
| cert *x509.Certificate |
| ctx *windows.CertContext |
| store windows.Handle |
| chain []*x509.Certificate |
| } |
| |
| // CertificateChain returns the credential as a raw X509 cert chain. This |
| // contains the public key. |
| func (k *Key) CertificateChain() [][]byte { |
| // Convert the certificates to a list of encoded certificate bytes. |
| chain := make([][]byte, len(k.chain)) |
| for i, xc := range k.chain { |
| chain[i] = xc.Raw |
| } |
| return chain |
| } |
| |
| // Close releases resources held by the credential. |
| func (k *Key) Close() error { |
| if err := windows.CertFreeCertificateContext(k.ctx); err != nil { |
| return err |
| } |
| return windows.CertCloseStore(k.store, 0) |
| } |
| |
| // Public returns the corresponding public key for this Key. |
| func (k *Key) Public() crypto.PublicKey { |
| return k.cert.PublicKey |
| } |
| |
| // Sign signs a message digest. Here, we pass off the signing to the Windows CryptoNG library. |
| func (k *Key) Sign(_ io.Reader, digest []byte, opts crypto.SignerOpts) ([]byte, error) { |
| key, err := acquirePrivateKey(k.ctx) |
| if err != nil { |
| return nil, fmt.Errorf("cannot acquire private key handle: %w", err) |
| } |
| return SignHash(key, k.Public(), digest, opts) |
| } |
