SECStatus
outputPQGVerify(PQGVerify *pqgVerify, PRBool output_binary, PRBool output_raw,
FILE *outFile)
{
SECStatus rv = SECSuccess;
if (output_raw) {
SECItem item;
unsigned int counter;
rv = PK11_PQG_GetHFromVerify(pqgVerify, &item);
if (rv) {
SECU_PrintError(progName, "PK11_PQG_GetHFromVerify");
return rv;
}
SECU_PrintInteger(outFile, &item, "h", 1);
SECITEM_FreeItem(&item, PR_FALSE);
rv = PK11_PQG_GetSeedFromVerify(pqgVerify, &item);
if (rv) {
SECU_PrintError(progName, "PK11_PQG_GetSeedFromVerify");
return rv;
}
SECU_PrintInteger(outFile, &item, "SEED", 1);
fprintf(outFile, " g: %d\n", item.len * BPB);
SECITEM_FreeItem(&item, PR_FALSE);
counter = PK11_PQG_GetCounterFromVerify(pqgVerify);
fprintf(outFile, " counter: %d\n", counter);
fprintf(outFile, "\n");
}
return rv;
}
static SECStatus
secu_PrintUserNoticeQualifier(FILE *out, SECItem * qualifierValue,
char *msg, int level)
{
CERTUserNotice *userNotice = NULL;
if (qualifierValue)
userNotice = CERT_DecodeUserNotice(qualifierValue);
if (userNotice) {
if (userNotice->noticeReference.organization.len != 0) {
char *string =
itemToString(&userNotice->noticeReference.organization);
SECItem **itemList = userNotice->noticeReference.noticeNumbers;
while (itemList && *itemList) {
SECU_PrintInteger(out,*itemList,string,level+1);
itemList++;
}
PORT_Free(string);
}
if (userNotice->displayText.len != 0) {
SECU_PrintString(out,&userNotice->displayText,
"Display Text", level+1);
}
CERT_DestroyUserNotice(userNotice);
return SECSuccess;
}
return SECFailure; /* caller will print this value */
}
static void
print_ocsp_version (FILE *out_file, SECItem *version, int level)
{
if (version->len > 0) {
SECU_PrintInteger (out_file, version, "Version", level);
} else {
SECU_Indent (out_file, level);
fprintf (out_file, "Version: DEFAULT\n");
}
}
void print_crl_info(CERTName *name, SECItem *serial)
{
PRBool saveWrapeState = SECU_GetWrapEnabled();
SECU_EnableWrap(PR_FALSE);
SECU_PrintNameQuotesOptional(stdout, name, "# Issuer", 0, PR_FALSE);
printf("\n");
SECU_PrintInteger(stdout, serial, "# Serial Number", 0);
SECU_EnableWrap(saveWrapeState);
}
static void
print_ocsp_cert_id (FILE *out_file, CERTOCSPCertID *cert_id, int level)
{
SECU_Indent (out_file, level);
fprintf (out_file, "Cert ID:\n");
level++;
SECU_PrintAlgorithmID (out_file, &(cert_id->hashAlgorithm),
"Hash Algorithm", level);
SECU_PrintAsHex (out_file, &(cert_id->issuerNameHash),
"Issuer Name Hash", level);
SECU_PrintAsHex (out_file, &(cert_id->issuerKeyHash),
"Issuer Key Hash", level);
SECU_PrintInteger (out_file, &(cert_id->serialNumber),
"Serial Number", level);
/* XXX lookup the cert; if found, print something nice (nickname?) */
}
void print_info(SECItem *sdder, CERTCertificate *c)
{
PRBool saveWrapeState = SECU_GetWrapEnabled();
SECU_EnableWrap(PR_FALSE);
SECU_PrintNameQuotesOptional(stdout, &c->issuer, "# Issuer", 0, PR_FALSE);
printf("\n");
SECU_PrintInteger(stdout, &c->serialNumber, "# Serial Number", 0);
SECU_PrintNameQuotesOptional(stdout, &c->subject, "# Subject", 0, PR_FALSE);
printf("\n");
SECU_PrintTimeChoice(stdout, &c->validity.notBefore, "# Not Valid Before", 0);
SECU_PrintTimeChoice(stdout, &c->validity.notAfter, "# Not Valid After ", 0);
SECU_PrintFingerprints(stdout, sdder, "# Fingerprint", 0);
SECU_EnableWrap(saveWrapeState);
}
SECStatus
outputPQGParams(PQGParams *pqgParams, PRBool output_binary, PRBool output_raw,
FILE *outFile)
{
PLArenaPool *arena = NULL;
char *PQG;
SECItem *pItem;
int cc;
SECStatus rv;
SECItem encodedParams;
if (output_raw) {
SECItem item;
rv = PK11_PQG_GetPrimeFromParams(pqgParams, &item);
if (rv) {
SECU_PrintError(progName, "PK11_PQG_GetPrimeFromParams");
return rv;
}
SECU_PrintInteger(outFile, &item, "Prime", 1);
SECITEM_FreeItem(&item, PR_FALSE);
rv = PK11_PQG_GetSubPrimeFromParams(pqgParams, &item);
if (rv) {
SECU_PrintError(progName, "PK11_PQG_GetPrimeFromParams");
return rv;
}
SECU_PrintInteger(outFile, &item, "Subprime", 1);
SECITEM_FreeItem(&item, PR_FALSE);
rv = PK11_PQG_GetBaseFromParams(pqgParams, &item);
if (rv) {
SECU_PrintError(progName, "PK11_PQG_GetPrimeFromParams");
return rv;
}
SECU_PrintInteger(outFile, &item, "Base", 1);
SECITEM_FreeItem(&item, PR_FALSE);
fprintf(outFile, "\n");
return SECSuccess;
}
encodedParams.data = NULL;
encodedParams.len = 0;
arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
if (!arena) {
SECU_PrintError(progName, "PORT_NewArena");
return SECFailure;
}
pItem = SEC_ASN1EncodeItem(arena, &encodedParams, pqgParams,
seckey_PQGParamsTemplate);
if (!pItem) {
SECU_PrintError(progName, "SEC_ASN1EncodeItem");
PORT_FreeArena(arena, PR_FALSE);
return SECFailure;
}
if (output_binary) {
size_t len;
len = fwrite(encodedParams.data, 1, encodedParams.len, outFile);
PORT_FreeArena(arena, PR_FALSE);
if (len != encodedParams.len) {
fprintf(stderr, "%s: fwrite failed\n", progName);
return SECFailure;
}
return SECSuccess;
}
/* must be output ASCII */
PQG = BTOA_DataToAscii(encodedParams.data, encodedParams.len);
PORT_FreeArena(arena, PR_FALSE);
if (!PQG) {
SECU_PrintError(progName, "BTOA_DataToAscii");
return SECFailure;
}
cc = fprintf(outFile, "%s\n", PQG);
PORT_Free(PQG);
if (cc <= 0) {
fprintf(stderr, "%s: fprintf failed\n", progName);
return SECFailure;
}
return SECSuccess;
}