/* certman.c

*

* Copyright (C) 2014-2026 wolfSSL Inc.

*

* This file is part of wolfSSH.

*

* wolfSSH is free software; you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation; either version 3 of the License, or

* (at your option) any later version.

*

* wolfSSH is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with wolfSSH. If not, see <http://www.gnu.org/licenses/>.

*/

/*

* The certman module contains utility functions wrapping the wolfSSL

* certificate manager functions to validate user certificates.

*/

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#ifdef WOLFSSL_USER_SETTINGS

#include <wolfssl/wolfcrypt/settings.h>

#else

#include <wolfssl/options.h>

#endif

#include <wolfssl/ssl.h>

#include <wolfssl/ocsp.h>

#include <wolfssl/wolfcrypt/error-crypt.h>

#include <wolfssl/error-ssl.h>

#include <wolfssh/internal.h>

#include <wolfssh/certman.h>

#ifdef WOLFSSH_CERTS

#ifdef NO_INLINE

#include <wolfssh/misc.h>

#else

#define WOLFSSH_MISC_INCLUDED

#include "src/misc.c"

#endif

#define WLOG_ENTER() do { \

WLOG(WS_LOG_CERTMAN, "Entering %s()", __func__); \

} while (0)

#define WLOG_LEAVE(x) do { \

WLOG(WS_LOG_CERTMAN, "Leaving %s(), ret = %d", __func__, (x)); \

} while (0)

#define WLOG_LEAVE_VOID() do { \

WLOG(WS_LOG_CERTMAN, "Leaving %s()", __func__); \

} while (0)

#define WLOG_LEAVE_PTR(x) do { \

WLOG(WS_LOG_CERTMAN, "Leaving %s(), ret = %p", __func__, (x)); \

} while (0)

#ifdef DEBUG_WOLFSSH

#define DUMP(x,y) do { DumpOctetString((x),(y)); } while (0)

#else

#define DUMP(x,y)

#endif

struct WOLFSSH_CERTMAN {

void* heap;

WOLFSSL_CERT_MANAGER* cm;

};

static WOLFSSH_CERTMAN* _CertMan_init(WOLFSSH_CERTMAN* cm, void* heap)

{

WOLFSSH_CERTMAN* ret = NULL;

WLOG_ENTER();

ret = cm;

if (ret != NULL) {

WMEMSET(ret, 0, sizeof(WOLFSSH_CERTMAN));

ret->cm = wolfSSL_CertManagerNew_ex(heap);

if (ret->cm == NULL) {

ret = NULL;

}

#ifdef HAVE_OCSP

else {

int err;

err = wolfSSL_CertManagerEnableOCSP(ret->cm,

WOLFSSL_OCSP_CHECKALL);

if (err == WOLFSSL_SUCCESS) {

WLOG(WS_LOG_CERTMAN, "Enabled OCSP");

}

else {

WLOG(WS_LOG_CERTMAN, "Couldn't enable OCSP");

wolfSSL_CertManagerFree(ret->cm);

ret = NULL;

}

}

#endif

}

WLOG_LEAVE_PTR(ret);

return ret;

}

static void _CertMan_ResourceFree(WOLFSSH_CERTMAN* cm, void* heap)

{

WOLFSSH_UNUSED(heap);

WLOG_ENTER();

if (cm != NULL) {

if (cm->cm != NULL) {

wolfSSL_CertManagerFree(cm->cm);

}

WMEMSET(cm, 0, sizeof *cm);

}

WLOG_LEAVE_VOID();

}

WOLFSSH_CERTMAN* wolfSSH_CERTMAN_new(void* heap)

{

WOLFSSH_CERTMAN* cm = NULL;

WLOG_ENTER();

cm = (WOLFSSH_CERTMAN*)WMALLOC(sizeof *cm, heap, DYNTYPE_CERTMAN);

if (cm != NULL) {

if (_CertMan_init(cm, heap) == NULL) {

WFREE(cm, heap, DYNTYPE_CERTMAN);

cm = NULL;

}

}

WLOG_LEAVE_PTR(cm);

return cm;

}

void wolfSSH_CERTMAN_free(WOLFSSH_CERTMAN* cm)

{

WLOG_ENTER();

if (cm) {

void* heap = cm->heap;

_CertMan_ResourceFree(cm, heap);

WFREE(cm, heap, DYNTYPE_CERTMAN);

}

WLOG_LEAVE_VOID();

}

/* return WS_SUCCESS on success */

int wolfSSH_CERTMAN_LoadRootCA_buffer(WOLFSSH_CERTMAN* cm,

const unsigned char* rootCa, word32 rootCaSz)

{

int ret;

WLOG_ENTER();

ret = wolfSSL_CertManagerLoadCABuffer(cm->cm, rootCa, rootCaSz,

WOLFSSL_FILETYPE_ASN1);

if (ret == WOLFSSL_SUCCESS) {

ret = WS_SUCCESS;

}

WLOG_LEAVE(ret);

return ret;

}

#ifndef WOLFSSH_NO_FPKI

static int CheckProfile(DecodedCert* cert, int profile);

enum {

PROFILE_FPKI_WORKSHEET_6 = 6,

PROFILE_FPKI_WORKSHEET_10 = 10,

PROFILE_FPKI_WORKSHEET_16 = 16

};

#endif /* WOLFSSH_NO_FPKI */

/* if max chain depth not set in wolfSSL then default to 9 */

#ifndef MAX_CHAIN_DEPTH

#define MAX_CHAIN_DEPTH 9

#endif

/* if handling a chain it is expected to be the leaf cert first followed by

* intermediates and CA last (CA may be omitted) */

int wolfSSH_CERTMAN_VerifyCerts_buffer(WOLFSSH_CERTMAN* cm,

const unsigned char* certs, word32 certSz, word32 certsCount)

{

int ret = WS_SUCCESS;

word32 idx = 0;

int certIdx = 0;

unsigned char **certLoc; /* locations of certificate start */

word32 *certLen; /* size of certificate, in sync with certLoc */

WLOG_ENTER();

if (cm == NULL || certs == NULL) {

return WS_BAD_ARGUMENT;

}

if (certsCount > MAX_CHAIN_DEPTH) {

WLOG(WS_LOG_CERTMAN, "cert count is larger than MAX_CHAIN_DEPTH");

return WS_BAD_ARGUMENT;

}

certLoc = (unsigned char**)WMALLOC(certsCount * sizeof(unsigned char*),

cm->heap, DYNTYPE_CERT);

certLen = (word32*)WMALLOC(certsCount * sizeof(word32), cm->heap,

DYNTYPE_CERT);

if (certLoc == NULL || certLen == NULL) {

ret = WS_MEMORY_E;

}

if (ret == WS_SUCCESS) {

for (certIdx = 0; certIdx < (int)certsCount; certIdx++) {

word32 sz = 0;

if ((idx + UINT32_SZ) > certSz) {

WLOG(WS_LOG_CERTMAN, "cert count is past end of buffer");

ret = ASN_PARSE_E;

break;

}

certLoc[certIdx] = (byte*)certs + idx + UINT32_SZ;

/* get the size of the certificate */

ret = GetSize(&sz, certs, certSz, &idx);

/* advance current pointer and update current total size */

if (ret == WS_SUCCESS) {

certLen[certIdx] = sz;

if (idx + sz > certSz) {

WLOG(WS_LOG_CERTMAN, "cert found is too large!");

ret = ASN_PARSE_E;

break;

}

idx += sz;

}

else {

break;

}

}

}

if (ret == WS_SUCCESS) {

for (certIdx = certsCount - 1; certIdx >= 0; certIdx--) {

WLOG(WS_LOG_CERTMAN, "verifying cert at index %d", certIdx);

ret = wolfSSL_CertManagerVerifyBuffer(cm->cm, certLoc[certIdx],

certLen[certIdx], WOLFSSL_FILETYPE_ASN1);

if (ret == WOLFSSL_SUCCESS) {

ret = WS_SUCCESS;

}

else if (ret == ASN_NO_SIGNER_E) {

WLOG(WS_LOG_CERTMAN, "cert verify: no signer");

ret = WS_CERT_NO_SIGNER_E;

}

else if (ret == ASN_AFTER_DATE_E) {

WLOG(WS_LOG_CERTMAN, "cert verify: expired");

ret = WS_CERT_EXPIRED_E;

}

else if (ret == ASN_SIG_CONFIRM_E) {

WLOG(WS_LOG_CERTMAN, "cert verify: bad sig");

ret = WS_CERT_SIG_CONFIRM_E;

}

else {

WLOG(WS_LOG_CERTMAN, "cert verify: other error (%d)", ret);

ret = WS_CERT_OTHER_E;

}

#ifdef HAVE_OCSP

if (ret == WS_SUCCESS) {

ret = wolfSSL_CertManagerCheckOCSP(cm->cm, (byte*)certLoc[certIdx],

certLen[certIdx]);

if (ret == WOLFSSL_SUCCESS) {

ret = WS_SUCCESS;

}

else if (ret == OCSP_CERT_REVOKED) {

WLOG(WS_LOG_CERTMAN, "ocsp lookup: ocsp revoked");

ret = WS_CERT_REVOKED_E;

}

else {

WLOG(WS_LOG_CERTMAN, "ocsp lookup: other error (%d)", ret);

ret = WS_CERT_OTHER_E;

}

}

#endif /* HAVE_OCSP */

/* verified successfully, add intermideate as trusted */

if (ret == WS_SUCCESS && certIdx > 0) {

WLOG(WS_LOG_CERTMAN, "adding intermediate cert as trusted");

ret = wolfSSH_CERTMAN_LoadRootCA_buffer(cm, certLoc[certIdx],

certLen[certIdx]);

}

if (ret != WS_SUCCESS) {

break;

}

}

}

#ifndef WOLFSSH_NO_FPKI

/* FPKI checking on the leaf certificate */

if (ret == WS_SUCCESS) {

DecodedCert decoded;

wc_InitDecodedCert(&decoded, certLoc[0], certLen[0], cm->cm);

ret = wc_ParseCert(&decoded, WOLFSSL_FILETYPE_ASN1, 0, cm->cm);

if (ret == 0) {

ret =

CheckProfile(&decoded, PROFILE_FPKI_WORKSHEET_6) ||

CheckProfile(&decoded, PROFILE_FPKI_WORKSHEET_10) ||

CheckProfile(&decoded, PROFILE_FPKI_WORKSHEET_16);

if (ret == 0) {

WLOG(WS_LOG_CERTMAN, "certificate didn't match profile");

ret = WS_CERT_PROFILE_E;

}

else {

ret = WS_SUCCESS;

}

}

FreeDecodedCert(&decoded);

}

#endif /* WOLFSSH_NO_FPKI */

if (certLoc != NULL)

WFREE(certLoc, cm->heap, DYNTYPE_CERT);

if (certLen != NULL)

WFREE(certLen, cm->heap, DYNTYPE_CERT);

WLOG_LEAVE(ret);

return ret;

}

#ifndef WOLFSSH_NO_FPKI

static int CheckProfile(DecodedCert* cert, int profile)

{

int valid = (cert != NULL);

const char* certPolicies[2] = {NULL, NULL};

byte extKeyUsage = 0, extKeyUsageSsh = 0;

if (profile == PROFILE_FPKI_WORKSHEET_6) {

certPolicies[0] = "2.16.840.1.101.3.2.1.3.13";

extKeyUsage = EXTKEYUSE_CLIENT_AUTH;

extKeyUsageSsh = EXTKEYUSE_SSH_MSCL;

}

else if (profile == PROFILE_FPKI_WORKSHEET_10) {

certPolicies[0] = "2.16.840.1.101.3.2.1.3.40";

certPolicies[1] = "2.16.840.1.101.3.2.1.3.41";

extKeyUsage = EXTKEYUSE_CLIENT_AUTH;

}

else if (profile == PROFILE_FPKI_WORKSHEET_16) {

certPolicies[0] = "2.16.840.1.101.3.2.1.3.45";

extKeyUsage = EXTKEYUSE_CLIENT_AUTH;

extKeyUsageSsh = EXTKEYUSE_SSH_MSCL;

}

else {

valid = 0;

}

if (valid) {

valid = cert->extKeyUsageSet &&

cert->extKeyUsage == KEYUSE_DIGITAL_SIG &&

/*cert->extBasicConstCrit;*/ 1;

}

if (valid) {

valid = WSTRCMP(cert->countryOfCitizenship, "US") == 0;

if (valid != 1)

WLOG(WS_LOG_CERTMAN, "cert country of citizenship invalid");

}

if (valid) {

valid = !cert->isCA;

if (valid != 1)

WLOG(WS_LOG_CERTMAN, "cert basic constraint invalid");

}

if (valid) {

valid =

WMEMCMP(cert->extAuthKeyId, cert->extSubjKeyId, KEYID_SIZE) != 0;

if (valid != 1)

WLOG(WS_LOG_CERTMAN, "cert auth key and subject key mismatch");

}

if (valid) {

valid =

((certPolicies[1] != NULL) &&

(WSTRCMP(certPolicies[1], cert->extCertPolicies[0]) == 0 ||

WSTRCMP(certPolicies[1], cert->extCertPolicies[1]) == 0)) ||

((certPolicies[0] != NULL) &&

(WSTRCMP(certPolicies[0], cert->extCertPolicies[0]) == 0 ||

WSTRCMP(certPolicies[0], cert->extCertPolicies[1]) == 0));

if (valid != 1)

WLOG(WS_LOG_CERTMAN, "cert policy invalid");

}

/* validity period must be utc up to and including 2049, general time

* after 2049 */

if (valid) {

const byte* date;

int dateSz;

byte dateFormat;

struct tm t;

dateFormat = cert->afterDate[0]; /* i.e ASN_UTC_TIME */

dateSz = cert->afterDate[1];

date = &cert->afterDate[2];

wc_GetDateAsCalendarTime(date, dateSz, dateFormat, &t);

if (t.tm_year <= 149 && dateFormat != ASN_UTC_TIME) {

WLOG(WS_LOG_CERTMAN, "date format was not utc for year %d",

t.tm_year);

valid = 0;

}

if (t.tm_year > 149 && dateFormat != ASN_GENERALIZED_TIME) {

WLOG(WS_LOG_CERTMAN, "date format was not general for year %d",

t.tm_year);

valid = 0;

}

}

/* encoding of issuer DN must be exact match to CA subject DN */

if (valid) {

int sz = min(SIGNER_DIGEST_SIZE, KEYID_SIZE);

if (XMEMCMP(cert->ca->subjectNameHash, cert->issuerHash, sz) != 0) {

WLOG(WS_LOG_CERTMAN, "CA subject name hash did not match issuer");

valid = 0;

}

}

/* path length must be absent (i.e. 0) */

if (valid) {

if (cert->pathLength != 0) {

WLOG(WS_LOG_CERTMAN, "non-conforming pathlength of %d was larger "

"than 0", cert->pathLength);

valid = 0;

}

}

/* check on FASC-N and UUID */

if (valid) {

DNS_entry* current;

byte hasFascN = 0;

byte hasUUID = 0;

byte uuid[DEFAULT_UUID_SZ];

word32 uuidSz = DEFAULT_UUID_SZ;

/* cycle through alt names to check for needed types */

current = cert->altNames;

while (current != NULL) {

#ifdef WOLFSSL_FPKI

if (current->oidSum == FASCN_OID) {

hasFascN = 1;

}

#endif /* WOLFSSL_FPKI */

current = current->next;

}

#ifdef WOLFSSL_FPKI

if (wc_GetUUIDFromCert(cert, uuid, &uuidSz) == 0) {

hasUUID = 1;

}

#endif /* WOLFSSL_FPKI */

/* all must have UUID and worksheet 6 must have FASC-N in addition to

* UUID */

if (profile == PROFILE_FPKI_WORKSHEET_6 && hasFascN == 0) {

WLOG(WS_LOG_CERTMAN, "cert did not include a FASC-N");

valid = 0;

}

if (valid && hasUUID == 0) {

WLOG(WS_LOG_CERTMAN, "cert did not include a UUID");

valid = 0;

}

}

if (valid) {

valid =

/* Must include all in extKeyUsage */

((extKeyUsage == 0) ||

((cert->extExtKeyUsage & extKeyUsage) == extKeyUsage)) &&

/* Must include all in extKeyUsageSsh */

((extKeyUsageSsh == 0) ||

((cert->extExtKeyUsageSsh & extKeyUsageSsh)

== extKeyUsageSsh));

if (valid != 1) {

WLOG(WS_LOG_CERTMAN, "cert did not include all ext. key usage");

}

}

#ifdef DEBUG_WOLFSSH

switch (profile) {

case PROFILE_FPKI_WORKSHEET_6:

if (valid)

WLOG(WS_LOG_INFO, "Cert matched FPKI profile 6");

else

WLOG(WS_LOG_INFO, "Cert did not match FPKI profile 6");

break;

case PROFILE_FPKI_WORKSHEET_10:

if (valid)

WLOG(WS_LOG_INFO, "Cert matched FPKI profile 10");

else

WLOG(WS_LOG_INFO, "Cert did not match FPKI profile 10");

break;

case PROFILE_FPKI_WORKSHEET_16:

if (valid)

WLOG(WS_LOG_INFO, "Cert matched FPKI profile 16");

else

WLOG(WS_LOG_INFO, "Cert did not match FPKI profile 16");

break;

}

#endif /* DEBUG_WOLFSSH */

return valid;

}

#endif /* WOLFSSH_NO_FPKI */

#endif /* WOLFSSH_CERTS */