зеркало из https://github.com/mozilla/gecko-dev.git
2241 строка
69 KiB
C
2241 строка
69 KiB
C
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
#if defined(WIN32)
|
|
#undef __STDC__
|
|
#include "fcntl.h"
|
|
#include "io.h"
|
|
#include <fcntl.h>
|
|
#else
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#endif
|
|
|
|
#include "secutil.h"
|
|
|
|
#include "nspr.h"
|
|
#include "prtypes.h"
|
|
#include "prtime.h"
|
|
#include "prlong.h"
|
|
#include "prinrval.h"
|
|
#include "prenv.h"
|
|
|
|
#include "pkcs11.h"
|
|
|
|
#include "pk11table.h"
|
|
|
|
#ifndef O_BINARY
|
|
#define O_BINARY 0
|
|
#endif
|
|
|
|
CK_ULONG systemFlags;
|
|
#define FLAG_NEGATE 0x80000000
|
|
#define FLAG_Verify 0x00000001
|
|
#define FLAG_VerifyFile 0x00000002
|
|
#define CKR_QUIT 0x80000000
|
|
|
|
int ArgSize(ArgType type);
|
|
const char *constLookup(const char *bp, CK_ULONG *value, ConstType *type);
|
|
|
|
int
|
|
isNum(char c)
|
|
{
|
|
return (c >= '0' && c <= '9');
|
|
}
|
|
|
|
int
|
|
isConst(const char *c)
|
|
{
|
|
CK_ULONG value;
|
|
ConstType type;
|
|
|
|
constLookup(c, &value, &type);
|
|
return type != ConstNone;
|
|
}
|
|
|
|
/*
|
|
* see if the variable is really a 'size' function. This
|
|
* function may modify var if it is a size function.
|
|
*/
|
|
char *
|
|
isSize(char *var, int *isArray)
|
|
{
|
|
char *ptr = NULL;
|
|
char *end;
|
|
int array = 0;
|
|
|
|
if (PL_strncasecmp(var, "sizeof(", /*)*/ 7) == 0) {
|
|
ptr = var + 7;
|
|
} else if (PL_strncasecmp(var, "size(", /*)*/ 5) == 0) {
|
|
ptr = var + 5;
|
|
} else if (PL_strncasecmp(var, "sizeofarray(", /*)*/ 12) == 0) {
|
|
ptr = var + 12;
|
|
array = 1;
|
|
} else if (PL_strncasecmp(var, "sizea(", /*)*/ 6) == 0) {
|
|
ptr = var + 6;
|
|
array = 1;
|
|
} else {
|
|
return NULL;
|
|
}
|
|
end = strchr(ptr, /*(*/ ')');
|
|
if (end == NULL) {
|
|
return NULL;
|
|
}
|
|
if (isArray)
|
|
*isArray = array;
|
|
*end = 0;
|
|
return ptr;
|
|
}
|
|
|
|
void
|
|
printConst(CK_ULONG value, ConstType type, int newLine)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < constCount; i++) {
|
|
if (consts[i].type == type && consts[i].value == value) {
|
|
printf("%s", consts[i].name);
|
|
break;
|
|
}
|
|
if (type == ConstNone && consts[i].value == value) {
|
|
printf("%s", consts[i].name);
|
|
break;
|
|
}
|
|
}
|
|
if (i == constCount) {
|
|
if ((type == ConstAvailableSizes) || (type == ConstCurrentSize)) {
|
|
printf("%lu", value);
|
|
} else {
|
|
printf("Unknown %s (%lu:0x%lx)", constTypeString[type], value, value);
|
|
}
|
|
}
|
|
if (newLine) {
|
|
printf("\n");
|
|
}
|
|
}
|
|
|
|
ConstType
|
|
getConstFromAttribute(CK_ATTRIBUTE_TYPE type)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < constCount; i++) {
|
|
if (consts[i].type == ConstAttribute && consts[i].value == type) {
|
|
return consts[i].attrType;
|
|
}
|
|
}
|
|
return ConstNone;
|
|
}
|
|
|
|
void
|
|
printChars(const char *name, CK_ULONG size)
|
|
{
|
|
CK_ULONG i;
|
|
for (i = 0; i < size; i++) {
|
|
if (name[i] == 0) {
|
|
break;
|
|
}
|
|
printf("%c", name[i]);
|
|
}
|
|
printf("\n");
|
|
}
|
|
|
|
#define DUMP_LEN 16
|
|
void
|
|
printDump(const unsigned char *buf, int size)
|
|
{
|
|
int i, j;
|
|
|
|
for (i = 0; i < size; i += DUMP_LEN) {
|
|
printf(" ");
|
|
for (j = 0; j < DUMP_LEN; j++) {
|
|
if (i + j < size) {
|
|
printf("%02x ", buf[i + j]);
|
|
} else {
|
|
printf(" ");
|
|
}
|
|
}
|
|
for (j = 0; j < DUMP_LEN; j++) {
|
|
if (i + j < size) {
|
|
if (buf[i + j] < ' ' || buf[i + j] >= 0x7f) {
|
|
printf(".");
|
|
} else {
|
|
printf("%c", buf[i + j]);
|
|
}
|
|
} else {
|
|
printf(" ");
|
|
}
|
|
}
|
|
printf("\n");
|
|
}
|
|
}
|
|
|
|
/*
|
|
* free an argument structure
|
|
*/
|
|
void
|
|
argFreeData(Value *arg)
|
|
{
|
|
if (arg->data && ((arg->type & ArgStatic) == 0)) {
|
|
if ((arg->type & ArgMask) == ArgAttribute) {
|
|
int i;
|
|
CK_ATTRIBUTE *template = (CK_ATTRIBUTE *)arg->data;
|
|
|
|
for (i = 0; i < arg->arraySize; i++) {
|
|
free(template[i].pValue);
|
|
}
|
|
}
|
|
if ((arg->type & ArgMask) == ArgInitializeArgs) {
|
|
CK_C_INITIALIZE_ARGS *init = (CK_C_INITIALIZE_ARGS *)arg->data;
|
|
if (init->LibraryParameters) {
|
|
free(init->LibraryParameters);
|
|
}
|
|
}
|
|
free(arg->data);
|
|
}
|
|
arg->type &= ~ArgStatic;
|
|
arg->data = NULL;
|
|
}
|
|
|
|
void
|
|
argFree(Value *arg)
|
|
{
|
|
if (arg == NULL)
|
|
return;
|
|
|
|
arg->reference--;
|
|
if (arg->reference == 0) {
|
|
if (arg->type & ArgFile) {
|
|
free(arg->filename);
|
|
}
|
|
argFreeData(arg);
|
|
free(arg);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* free and argument list
|
|
*/
|
|
void
|
|
parseFree(Value **ap)
|
|
{
|
|
int i;
|
|
for (i = 0; i < MAX_ARGS; i++) {
|
|
argFree(ap[i]);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* getEnd: how for to the end of this argmument list?
|
|
*/
|
|
int
|
|
getEnd(const char *bp)
|
|
{
|
|
int count = 0;
|
|
|
|
while (*bp) {
|
|
if (*bp == ' ' || *bp == '\t' || *bp == '\n')
|
|
return count;
|
|
count++;
|
|
bp++;
|
|
}
|
|
return (count);
|
|
}
|
|
|
|
/*
|
|
* strip: return the first none white space character
|
|
*/
|
|
const char *
|
|
strip(const char *bp)
|
|
{
|
|
while (*bp && (*bp == ' ' || *bp == '\t' || *bp == '\n'))
|
|
bp++;
|
|
return bp;
|
|
}
|
|
|
|
/*
|
|
* read in the next argument into dp ... don't overflow
|
|
*/
|
|
const char *
|
|
readChars(const char *bp, char *dp, int max)
|
|
{
|
|
int count = 1;
|
|
while (*bp) {
|
|
if (*bp == ' ' || *bp == '\t' || *bp == '\n') {
|
|
*dp = 0;
|
|
return bp;
|
|
}
|
|
*dp++ = *bp++;
|
|
if (++count == max)
|
|
break;
|
|
}
|
|
while (*bp && (*bp != ' ' && *bp != '\t' && *bp != '\n'))
|
|
bp++;
|
|
*dp = 0;
|
|
return (bp);
|
|
}
|
|
|
|
Value *varLookup(const char *bp, char *vname, int max, int *error);
|
|
|
|
CK_ULONG
|
|
getValue(const char *v, int *error)
|
|
{
|
|
Value *varVal = NULL;
|
|
CK_ULONG retVal = 0;
|
|
ConstType type;
|
|
char tvar[512];
|
|
|
|
*error = 0;
|
|
|
|
varVal = varLookup(v, tvar, sizeof(tvar), error);
|
|
|
|
if (varVal) {
|
|
if ((varVal->type & ArgMask) == ArgULong) {
|
|
retVal = *(CK_ULONG *)varVal->data;
|
|
} else {
|
|
fprintf(stderr, "%s: is not a ulong\n", v);
|
|
*error = 1;
|
|
}
|
|
argFree(varVal);
|
|
return retVal;
|
|
}
|
|
constLookup(v, &retVal, &type);
|
|
return retVal;
|
|
}
|
|
|
|
Value *
|
|
NewValue(ArgType type, CK_ULONG arraySize)
|
|
{
|
|
Value *value;
|
|
|
|
value = (Value *)malloc(sizeof(Value));
|
|
if (!value)
|
|
return NULL;
|
|
value->size = ArgSize(type) * arraySize;
|
|
value->type = type;
|
|
value->filename = NULL;
|
|
value->constType = ConstNone;
|
|
value->data = (void *)malloc(value->size);
|
|
if (!value->data) {
|
|
free(value);
|
|
return NULL;
|
|
}
|
|
value->reference = 1;
|
|
value->arraySize = (type == ArgChar) ? 1 : arraySize;
|
|
|
|
memset(value->data, 0, value->size);
|
|
return value;
|
|
}
|
|
|
|
#define INVALID_INDEX 0xffffffff
|
|
|
|
CK_ULONG
|
|
handleArray(char *vname, int *error)
|
|
{
|
|
char *bracket;
|
|
CK_ULONG index = INVALID_INDEX;
|
|
|
|
if ((bracket = strchr(vname, '[')) != 0) {
|
|
char *tmpv = bracket + 1;
|
|
*bracket = 0;
|
|
bracket = strchr(tmpv, ']');
|
|
|
|
if (bracket == 0) {
|
|
fprintf(stderr, "%s: missing closing brace\n", vname);
|
|
return INVALID_INDEX;
|
|
}
|
|
*bracket = 0;
|
|
|
|
index = getValue(tmpv, error);
|
|
if (*error == 1) {
|
|
return INVALID_INDEX;
|
|
} else if (index == INVALID_INDEX) {
|
|
fprintf(stderr, "%s: 0x%lx is an invalid index\n", vname, index);
|
|
*error = 1;
|
|
}
|
|
}
|
|
return index;
|
|
}
|
|
|
|
void *
|
|
makeArrayTarget(const char *vname, const Value *value, CK_ULONG index)
|
|
{
|
|
char *target;
|
|
CK_ULONG elementSize;
|
|
|
|
if (index >= (CK_ULONG)value->arraySize) {
|
|
fprintf(stderr, "%s[%lu]: index larger than array size (%d)\n",
|
|
vname, index, value->arraySize);
|
|
return NULL;
|
|
}
|
|
|
|
target = (char *)value->data;
|
|
elementSize = value->size / value->arraySize;
|
|
target += index * elementSize;
|
|
return target;
|
|
}
|
|
|
|
/*
|
|
* look up a variable from the variable chain
|
|
*/
|
|
static Variable *varHead = NULL;
|
|
Value *
|
|
varLookup(const char *bp, char *vname, int max, int *error)
|
|
{
|
|
Variable *current;
|
|
CK_ULONG index = INVALID_INDEX;
|
|
int isArray = 0;
|
|
char *ptr;
|
|
*error = 0;
|
|
|
|
if (bp != NULL) {
|
|
readChars(bp, vname, max);
|
|
}
|
|
|
|
/* don't make numbers into variables */
|
|
if (isNum(vname[0])) {
|
|
return NULL;
|
|
}
|
|
/* nor consts */
|
|
if (isConst(vname)) {
|
|
return NULL;
|
|
}
|
|
/* handle sizeof() */
|
|
if ((ptr = isSize(vname, &isArray)) != NULL) {
|
|
CK_ULONG size;
|
|
Value *targetValue = NULL;
|
|
Value *sourceValue = varLookup(NULL, ptr, 0, error);
|
|
if (!sourceValue) {
|
|
if (*error == 0) {
|
|
/* just didn't find it */
|
|
*error = 1;
|
|
fprintf(stderr, "Couldn't find variable %s to take size of\n",
|
|
ptr);
|
|
return NULL;
|
|
}
|
|
}
|
|
size = isArray ? sourceValue->arraySize : sourceValue->size;
|
|
targetValue = NewValue(ArgULong, 1);
|
|
memcpy(targetValue->data, &size, sizeof(size));
|
|
|
|
return targetValue;
|
|
}
|
|
|
|
/* modifies vname */
|
|
index = handleArray(vname, error);
|
|
if (*error == 1) {
|
|
return NULL;
|
|
}
|
|
|
|
for (current = varHead; current; current = current->next) {
|
|
if (PL_strcasecmp(current->vname, vname) == 0) {
|
|
char *target;
|
|
if (index == INVALID_INDEX) {
|
|
(current->value->reference)++;
|
|
return current->value;
|
|
}
|
|
target = makeArrayTarget(vname, current->value, index);
|
|
if (target) {
|
|
Value *element = NewValue(current->value->type, 1);
|
|
if (!element) {
|
|
fprintf(stderr, "MEMORY ERROR!\n");
|
|
*error = 1;
|
|
}
|
|
argFreeData(element);
|
|
element->data = target;
|
|
element->type |= ArgStatic;
|
|
return element;
|
|
}
|
|
*error = 1;
|
|
return NULL;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static CK_RV
|
|
list(void)
|
|
{
|
|
Variable *current;
|
|
|
|
if (varHead) {
|
|
printf(" %10s\t%16s\t%8s\tSize\tElements\n", "Name", "Type", "Const");
|
|
} else {
|
|
printf(" no variables set\n");
|
|
}
|
|
|
|
for (current = varHead; current; current = current->next) {
|
|
printf(" %10s\t%16s\t%8s\t%d\t%d\n", current->vname,
|
|
valueString[current->value->type & ArgMask],
|
|
constTypeString[current->value->constType],
|
|
current->value->size, current->value->arraySize);
|
|
}
|
|
return CKR_OK;
|
|
}
|
|
|
|
CK_RV
|
|
printFlags(const char *s, CK_ULONG flags, ConstType type)
|
|
{
|
|
CK_ULONG i;
|
|
int needComma = 0;
|
|
|
|
printf("%s", s);
|
|
for (i = 1; i; i = i << 1) {
|
|
if (flags & i) {
|
|
printf("%s", needComma ? "," : "");
|
|
printConst(i, type, 0);
|
|
needComma = 1;
|
|
}
|
|
}
|
|
if (!needComma) {
|
|
printf("Empty");
|
|
}
|
|
printf("\n");
|
|
return CKR_OK;
|
|
}
|
|
|
|
/*
|
|
* add a new variable to the chain
|
|
*/
|
|
const char *
|
|
AddVariable(const char *bp, Value **ptr)
|
|
{
|
|
char vname[512];
|
|
Variable *current;
|
|
int index = INVALID_INDEX;
|
|
int size;
|
|
int error = 0;
|
|
|
|
bp = readChars(bp, vname, sizeof(vname));
|
|
|
|
/* don't make numbers into variables */
|
|
if (isNum(vname[0])) {
|
|
return bp;
|
|
}
|
|
/* or consts */
|
|
if (isConst(vname)) {
|
|
return bp;
|
|
}
|
|
/* or NULLs */
|
|
if (vname[0] == 0) {
|
|
return bp;
|
|
}
|
|
/* or sizeof */
|
|
if (isSize(vname, NULL)) {
|
|
return bp;
|
|
}
|
|
/* arrays values should be written back to the original */
|
|
index = handleArray(vname, &error);
|
|
if (error == 1) {
|
|
return bp;
|
|
}
|
|
|
|
for (current = varHead; current; current = current->next) {
|
|
if (PL_strcasecmp(current->vname, vname) == 0) {
|
|
char *target;
|
|
/* found a complete object, return the found one */
|
|
if (index == INVALID_INDEX) {
|
|
argFree(*ptr);
|
|
*ptr = current->value;
|
|
return bp;
|
|
}
|
|
/* found an array, update the array element */
|
|
target = makeArrayTarget(vname, current->value, index);
|
|
if (target) {
|
|
memcpy(target, (*ptr)->data, (*ptr)->size);
|
|
argFreeData(*ptr);
|
|
(*ptr)->data = target;
|
|
(*ptr)->type |= ArgStatic;
|
|
}
|
|
return bp;
|
|
}
|
|
}
|
|
|
|
/* we are looking for an array and didn't find one */
|
|
if (index != INVALID_INDEX) {
|
|
return bp;
|
|
}
|
|
|
|
current = (Variable *)malloc(sizeof(Variable));
|
|
size = strlen(vname);
|
|
current->vname = (char *)malloc(size + 1);
|
|
strcpy(current->vname, vname);
|
|
current->value = *ptr;
|
|
(*ptr)->reference++;
|
|
|
|
current->next = varHead;
|
|
varHead = current;
|
|
return bp;
|
|
}
|
|
|
|
ArgType
|
|
FindTypeByName(const char *typeName)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < valueCount; i++) {
|
|
if (PL_strcasecmp(typeName, valueString[i]) == 0) {
|
|
return (ArgType)i;
|
|
}
|
|
if (valueString[i][0] == 'C' && valueString[i][1] == 'K' &&
|
|
valueString[i][2] == '_' &&
|
|
(PL_strcasecmp(typeName, &valueString[i][3]) == 0)) {
|
|
return (ArgType)i;
|
|
}
|
|
}
|
|
return ArgNone;
|
|
}
|
|
|
|
CK_RV
|
|
ArrayVariable(const char *bp, const char *typeName, CK_ULONG count)
|
|
{
|
|
ArgType type;
|
|
Value *value; /* new Value */
|
|
|
|
type = FindTypeByName(typeName);
|
|
if (type == ArgNone) {
|
|
fprintf(stderr, "Invalid type (%s)\n", typeName);
|
|
return CKR_FUNCTION_FAILED;
|
|
}
|
|
value = NewValue(type, count);
|
|
(void)AddVariable(bp, &value);
|
|
return CKR_OK;
|
|
}
|
|
|
|
#define MAX_TEMPLATE 25
|
|
|
|
CK_RV
|
|
ArrayTemplate(const char *bp, char *attributes)
|
|
{
|
|
char aname[512];
|
|
CK_ULONG attributeTypes[MAX_TEMPLATE];
|
|
CK_ATTRIBUTE *template;
|
|
Value *value; /* new Value */
|
|
char *ap;
|
|
int i, count = 0;
|
|
|
|
memcpy(aname, attributes, strlen(attributes) + 1);
|
|
|
|
for (ap = aname, count = 0; ap && *ap && count < MAX_TEMPLATE; count++) {
|
|
char *cur = ap;
|
|
ConstType type;
|
|
|
|
ap = strchr(ap, ',');
|
|
if (ap) {
|
|
*ap++ = 0;
|
|
}
|
|
|
|
(void)constLookup(cur, &attributeTypes[count], &type);
|
|
if ((type != ConstAttribute) && (type != ConstNone)) {
|
|
fprintf(stderr, "Unknown Attribute %s\n", cur);
|
|
return CKR_FUNCTION_FAILED;
|
|
}
|
|
}
|
|
|
|
value = NewValue(ArgAttribute, count);
|
|
|
|
template = (CK_ATTRIBUTE *)value->data;
|
|
for (i = 0; i < count; i++) {
|
|
template[i].type = attributeTypes[i];
|
|
}
|
|
(void)AddVariable(bp, &value);
|
|
return CKR_OK;
|
|
}
|
|
|
|
CK_RV
|
|
BuildTemplate(Value *vp)
|
|
{
|
|
CK_ATTRIBUTE *template = (CK_ATTRIBUTE *)vp->data;
|
|
int i;
|
|
|
|
for (i = 0; i < vp->arraySize; i++) {
|
|
if (((signed long)template[i].ulValueLen) > 0) {
|
|
if (template[i].pValue)
|
|
free(template[i].pValue);
|
|
template[i].pValue = malloc(template[i].ulValueLen);
|
|
}
|
|
}
|
|
return CKR_OK;
|
|
}
|
|
|
|
CK_RV
|
|
SetTemplate(Value *vp, CK_ULONG index, CK_ULONG value)
|
|
{
|
|
CK_ATTRIBUTE *template = (CK_ATTRIBUTE *)vp->data;
|
|
int isbool = 0;
|
|
CK_ULONG len;
|
|
ConstType attrType;
|
|
|
|
if (index >= (CK_ULONG)vp->arraySize) {
|
|
fprintf(stderr, "index (%lu) greater than array (%d)\n",
|
|
index, vp->arraySize);
|
|
return CKR_ARGUMENTS_BAD;
|
|
}
|
|
attrType = getConstFromAttribute(template[index].type);
|
|
|
|
if (attrType == ConstNone) {
|
|
fprintf(stderr, "can't set index (%lu) because ", index);
|
|
printConst(template[index].type, ConstAttribute, 0);
|
|
fprintf(stderr, " is not a CK_BBOOL or CK_ULONG\n");
|
|
return CKR_ARGUMENTS_BAD;
|
|
}
|
|
isbool = (attrType == ConstBool);
|
|
len = isbool ? sizeof(CK_BBOOL) : sizeof(CK_ULONG);
|
|
if ((template[index].ulValueLen != len) || (template[index].pValue)) {
|
|
free(template[index].pValue);
|
|
template[index].pValue = malloc(len);
|
|
template[index].ulValueLen = len;
|
|
}
|
|
if (isbool) {
|
|
*(CK_BBOOL *)template[index].pValue = (CK_BBOOL)value;
|
|
} else {
|
|
*(CK_ULONG *)template[index].pValue = (CK_ULONG)value;
|
|
}
|
|
return CKR_OK;
|
|
}
|
|
|
|
CK_RV
|
|
NewMechanism(const char *bp, CK_ULONG mechType)
|
|
{
|
|
Value *value; /* new Value */
|
|
CK_MECHANISM *mechanism;
|
|
|
|
value = NewValue(ArgMechanism, 1);
|
|
mechanism = (CK_MECHANISM *)value->data;
|
|
mechanism->mechanism = mechType;
|
|
mechanism->pParameter = NULL;
|
|
mechanism->ulParameterLen = 0;
|
|
(void)AddVariable(bp, &value);
|
|
return CKR_OK;
|
|
}
|
|
|
|
CK_RV
|
|
NewInitializeArgs(const char *bp, CK_ULONG flags, const char *param)
|
|
{
|
|
Value *value; /* new Value */
|
|
CK_C_INITIALIZE_ARGS *init;
|
|
|
|
value = NewValue(ArgInitializeArgs, 1);
|
|
init = (CK_C_INITIALIZE_ARGS *)value->data;
|
|
init->flags = flags;
|
|
if (strcmp(param, "null") != 0) {
|
|
init->LibraryParameters = (CK_CHAR_PTR *)strdup(param);
|
|
}
|
|
(void)AddVariable(bp, &value);
|
|
return CKR_OK;
|
|
}
|
|
|
|
/*
|
|
* add a new variable to the chain
|
|
*/
|
|
CK_RV
|
|
DeleteVariable(const char *bp)
|
|
{
|
|
char vname[512];
|
|
Variable **current;
|
|
|
|
bp = readChars(bp, vname, sizeof(vname));
|
|
|
|
for (current = &varHead; *current; current = &(*current)->next) {
|
|
if (PL_strcasecmp((*current)->vname, vname) == 0) {
|
|
argFree((*current)->value);
|
|
*current = (*current)->next;
|
|
break;
|
|
}
|
|
}
|
|
return CKR_OK;
|
|
}
|
|
|
|
/*
|
|
* convert an octal value to integer
|
|
*/
|
|
CK_ULONG
|
|
otoi(const char *o)
|
|
{
|
|
CK_ULONG value = 0;
|
|
|
|
while (*o) {
|
|
if ((*o >= '0') && (*o <= '7')) {
|
|
value = (value << 3) | (unsigned)(*o - '0');
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
|
|
/*
|
|
* convert a hex value to integer
|
|
*/
|
|
CK_ULONG
|
|
htoi(const char *x)
|
|
{
|
|
CK_ULONG value = 0;
|
|
|
|
while (*x) {
|
|
if ((*x >= '0') && (*x <= '9')) {
|
|
value = (value << 4) | (unsigned)(*x - '0');
|
|
} else if ((*x >= 'a') && (*x <= 'f')) {
|
|
value = (value << 4) | (unsigned)(*x - 'a');
|
|
} else if ((*x >= 'A') && (*x <= 'F')) {
|
|
value = (value << 4) | (unsigned)(*x - 'A');
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
|
|
/*
|
|
* look up or decode a constant value
|
|
*/
|
|
const char *
|
|
constLookup(const char *bp, CK_ULONG *value, ConstType *type)
|
|
{
|
|
char vname[512];
|
|
int i;
|
|
|
|
bp = readChars(bp, vname, sizeof(vname));
|
|
|
|
for (i = 0; i < constCount; i++) {
|
|
if ((PL_strcasecmp(consts[i].name, vname) == 0) ||
|
|
PL_strcasecmp(consts[i].name + 5, vname) == 0) {
|
|
*value = consts[i].value;
|
|
*type = consts[i].type;
|
|
return bp;
|
|
}
|
|
}
|
|
|
|
*type = ConstNone;
|
|
if (vname[0] == '0' && vname[1] == 'X') {
|
|
*value = htoi(&vname[2]);
|
|
} else if (vname[0] == '0') {
|
|
*value = otoi(&vname[1]);
|
|
} else {
|
|
*value = atoi(vname);
|
|
}
|
|
return bp;
|
|
}
|
|
|
|
int
|
|
ArgSize(ArgType type)
|
|
{
|
|
int size = 0;
|
|
type &= ArgMask;
|
|
|
|
switch (type) {
|
|
case ArgNone:
|
|
size = 0;
|
|
break;
|
|
case ArgULong:
|
|
size = sizeof(CK_ULONG);
|
|
break;
|
|
case ArgVar:
|
|
size = 1; /* get's changed later */
|
|
break;
|
|
case ArgChar:
|
|
case ArgUTF8:
|
|
size = 1;
|
|
break;
|
|
case ArgInfo:
|
|
size = sizeof(CK_INFO);
|
|
break;
|
|
case ArgSlotInfo:
|
|
size = sizeof(CK_SLOT_INFO);
|
|
break;
|
|
case ArgTokenInfo:
|
|
size = sizeof(CK_TOKEN_INFO);
|
|
break;
|
|
case ArgSessionInfo:
|
|
size = sizeof(CK_SESSION_INFO);
|
|
break;
|
|
case ArgAttribute:
|
|
size = sizeof(CK_ATTRIBUTE);
|
|
break;
|
|
case ArgMechanism:
|
|
size = sizeof(CK_MECHANISM);
|
|
break;
|
|
case ArgMechanismInfo:
|
|
size = sizeof(CK_MECHANISM_INFO);
|
|
break;
|
|
case ArgInitializeArgs:
|
|
size = sizeof(CK_C_INITIALIZE_ARGS);
|
|
break;
|
|
case ArgFunctionList:
|
|
size = sizeof(CK_FUNCTION_LIST);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return (size);
|
|
}
|
|
|
|
CK_RV
|
|
restore(const char *filename, Value *ptr)
|
|
{
|
|
int fd, size;
|
|
|
|
fd = open(filename, O_RDONLY | O_BINARY);
|
|
if (fd < 0) {
|
|
perror(filename);
|
|
return CKR_FUNCTION_FAILED;
|
|
}
|
|
|
|
size = read(fd, ptr->data, ptr->size);
|
|
if (systemFlags & FLAG_VerifyFile) {
|
|
printDump(ptr->data, ptr->size);
|
|
}
|
|
if (size < 0) {
|
|
perror(filename);
|
|
return CKR_FUNCTION_FAILED;
|
|
} else if (size != ptr->size) {
|
|
fprintf(stderr, "%s: only read %d bytes, needed to read %d bytes\n",
|
|
filename, size, ptr->size);
|
|
return CKR_FUNCTION_FAILED;
|
|
}
|
|
close(fd);
|
|
return CKR_OK;
|
|
}
|
|
|
|
CK_RV
|
|
save(const char *filename, Value *ptr)
|
|
{
|
|
int fd, size;
|
|
|
|
fd = open(filename, O_WRONLY | O_BINARY | O_CREAT, 0666);
|
|
if (fd < 0) {
|
|
perror(filename);
|
|
return CKR_FUNCTION_FAILED;
|
|
}
|
|
|
|
size = write(fd, ptr->data, ptr->size);
|
|
if (size < 0) {
|
|
perror(filename);
|
|
return CKR_FUNCTION_FAILED;
|
|
} else if (size != ptr->size) {
|
|
fprintf(stderr, "%s: only wrote %d bytes, need to write %d bytes\n",
|
|
filename, size, ptr->size);
|
|
return CKR_FUNCTION_FAILED;
|
|
}
|
|
close(fd);
|
|
return CKR_OK;
|
|
}
|
|
|
|
static CK_RV
|
|
increment(Value *ptr, CK_ULONG value)
|
|
{
|
|
if ((ptr->type & ArgMask) != ArgULong) {
|
|
return CKR_ARGUMENTS_BAD;
|
|
}
|
|
*(CK_ULONG *)ptr->data += value;
|
|
return CKR_OK;
|
|
}
|
|
|
|
static CK_RV
|
|
decrement(Value *ptr, CK_ULONG value)
|
|
{
|
|
if ((ptr->type & ArgMask) != ArgULong) {
|
|
return CKR_ARGUMENTS_BAD;
|
|
}
|
|
*(CK_ULONG *)ptr->data -= value;
|
|
return CKR_OK;
|
|
}
|
|
|
|
CK_RV
|
|
printArg(Value *ptr, int arg_number)
|
|
{
|
|
ArgType type = ptr->type & ArgMask;
|
|
CK_INFO *info;
|
|
CK_SLOT_INFO *slotInfo;
|
|
CK_TOKEN_INFO *tokenInfo;
|
|
CK_SESSION_INFO *sessionInfo;
|
|
CK_ATTRIBUTE *attribute;
|
|
CK_MECHANISM *mechanism;
|
|
CK_MECHANISM_INFO *mechanismInfo;
|
|
CK_C_INITIALIZE_ARGS *initArgs;
|
|
CK_FUNCTION_LIST *functionList;
|
|
CK_RV ckrv = CKR_OK;
|
|
ConstType constType;
|
|
|
|
if (arg_number) {
|
|
printf("Arg %d: \n", arg_number);
|
|
}
|
|
if (ptr->arraySize > 1) {
|
|
Value element;
|
|
int i;
|
|
int elementSize = ptr->size / ptr->arraySize;
|
|
char *dp = (char *)ptr->data;
|
|
|
|
/* build a temporary Value to hold a single element */
|
|
element.type = type;
|
|
element.constType = ptr->constType;
|
|
element.size = elementSize;
|
|
element.filename = ptr->filename;
|
|
element.reference = 1;
|
|
element.arraySize = 1;
|
|
for (i = 0; i < ptr->arraySize; i++) {
|
|
printf(" -----[ %d ] -----\n", i);
|
|
element.data = (void *)&dp[i * elementSize];
|
|
(void)printArg(&element, 0);
|
|
}
|
|
return ckrv;
|
|
}
|
|
if (ptr->data == NULL) {
|
|
printf(" NULL ptr to a %s\n", valueString[type]);
|
|
return ckrv;
|
|
}
|
|
switch (type) {
|
|
case ArgNone:
|
|
printf(" None\n");
|
|
break;
|
|
case ArgULong:
|
|
printf(" %lu (0x%lx)\n", *((CK_ULONG *)ptr->data),
|
|
*((CK_ULONG *)ptr->data));
|
|
if (ptr->constType != ConstNone) {
|
|
printf(" ");
|
|
printConst(*(CK_ULONG *)ptr->data, ptr->constType, 1);
|
|
}
|
|
break;
|
|
case ArgVar:
|
|
printf(" %s\n", (char *)ptr->data);
|
|
break;
|
|
case ArgUTF8:
|
|
printf(" %s\n", (char *)ptr->data);
|
|
break;
|
|
case ArgChar:
|
|
printDump(ptr->data, ptr->size);
|
|
break;
|
|
case ArgInfo:
|
|
#define VERSION(x) (x).major, (x).minor
|
|
info = (CK_INFO *)ptr->data;
|
|
printf(" Cryptoki Version: %d.%02d\n",
|
|
VERSION(info->cryptokiVersion));
|
|
printf(" Manufacturer ID: ");
|
|
printChars((char *)info->manufacturerID,
|
|
sizeof(info->manufacturerID));
|
|
printFlags(" Flags: ", info->flags, ConstInfoFlags);
|
|
printf(" Library Description: ");
|
|
printChars((char *)info->libraryDescription,
|
|
sizeof(info->libraryDescription));
|
|
printf(" Library Version: %d.%02d\n",
|
|
VERSION(info->libraryVersion));
|
|
break;
|
|
case ArgSlotInfo:
|
|
slotInfo = (CK_SLOT_INFO *)ptr->data;
|
|
printf(" Slot Description: ");
|
|
printChars((char *)slotInfo->slotDescription,
|
|
sizeof(slotInfo->slotDescription));
|
|
printf(" Manufacturer ID: ");
|
|
printChars((char *)slotInfo->manufacturerID,
|
|
sizeof(slotInfo->manufacturerID));
|
|
printFlags(" Flags: ", slotInfo->flags, ConstSlotFlags);
|
|
printf(" Hardware Version: %d.%02d\n",
|
|
VERSION(slotInfo->hardwareVersion));
|
|
printf(" Firmware Version: %d.%02d\n",
|
|
VERSION(slotInfo->firmwareVersion));
|
|
break;
|
|
case ArgTokenInfo:
|
|
tokenInfo = (CK_TOKEN_INFO *)ptr->data;
|
|
printf(" Label: ");
|
|
printChars((char *)tokenInfo->label, sizeof(tokenInfo->label));
|
|
printf(" Manufacturer ID: ");
|
|
printChars((char *)tokenInfo->manufacturerID,
|
|
sizeof(tokenInfo->manufacturerID));
|
|
printf(" Model: ");
|
|
printChars((char *)tokenInfo->model, sizeof(tokenInfo->model));
|
|
printf(" Serial Number: ");
|
|
printChars((char *)tokenInfo->serialNumber,
|
|
sizeof(tokenInfo->serialNumber));
|
|
printFlags(" Flags: ", tokenInfo->flags, ConstTokenFlags);
|
|
printf(" Max Session Count: ");
|
|
printConst(tokenInfo->ulMaxSessionCount, ConstAvailableSizes, 1);
|
|
printf(" Session Count: ");
|
|
printConst(tokenInfo->ulSessionCount, ConstCurrentSize, 1);
|
|
printf(" RW Session Count: ");
|
|
printConst(tokenInfo->ulMaxRwSessionCount, ConstAvailableSizes, 1);
|
|
printf(" Max Pin Length : ");
|
|
printConst(tokenInfo->ulMaxPinLen, ConstCurrentSize, 1);
|
|
printf(" Min Pin Length : ");
|
|
printConst(tokenInfo->ulMinPinLen, ConstCurrentSize, 1);
|
|
printf(" Total Public Memory: ");
|
|
printConst(tokenInfo->ulTotalPublicMemory, ConstAvailableSizes, 1);
|
|
printf(" Free Public Memory: ");
|
|
printConst(tokenInfo->ulFreePublicMemory, ConstCurrentSize, 1);
|
|
printf(" Total Private Memory: ");
|
|
printConst(tokenInfo->ulTotalPrivateMemory, ConstAvailableSizes, 1);
|
|
printf(" Free Private Memory: ");
|
|
printConst(tokenInfo->ulFreePrivateMemory, ConstCurrentSize, 1);
|
|
printf(" Hardware Version: %d.%02d\n",
|
|
VERSION(tokenInfo->hardwareVersion));
|
|
printf(" Firmware Version: %d.%02d\n",
|
|
VERSION(tokenInfo->firmwareVersion));
|
|
printf(" UTC Time: ");
|
|
printChars((char *)tokenInfo->utcTime, sizeof(tokenInfo->utcTime));
|
|
break;
|
|
case ArgSessionInfo:
|
|
sessionInfo = (CK_SESSION_INFO *)ptr->data;
|
|
printf(" SlotID: 0x%08lx\n", sessionInfo->slotID);
|
|
printf(" State: ");
|
|
printConst(sessionInfo->state, ConstSessionState, 1);
|
|
printFlags(" Flags: ", sessionInfo->flags, ConstSessionFlags);
|
|
printf(" Device error: %lu 0x%08lx\n", sessionInfo->ulDeviceError,
|
|
sessionInfo->ulDeviceError);
|
|
break;
|
|
case ArgAttribute:
|
|
attribute = (CK_ATTRIBUTE *)ptr->data;
|
|
printf(" Attribute Type: ");
|
|
printConst(attribute->type, ConstAttribute, 1);
|
|
printf(" Attribute Data: ");
|
|
if (attribute->pValue == NULL) {
|
|
printf("NULL\n");
|
|
printf("Attribute Len: %lu\n", attribute->ulValueLen);
|
|
} else {
|
|
constType = getConstFromAttribute(attribute->type);
|
|
if (constType != ConstNone) {
|
|
CK_ULONG value = (constType == ConstBool) ? *(CK_BBOOL *)attribute->pValue
|
|
: *(CK_ULONG *)attribute->pValue;
|
|
printConst(value, constType, 1);
|
|
} else {
|
|
printf("\n");
|
|
printDump(attribute->pValue, attribute->ulValueLen);
|
|
}
|
|
}
|
|
break;
|
|
case ArgMechanism:
|
|
mechanism = (CK_MECHANISM *)ptr->data;
|
|
printf(" Mechanism Type: ");
|
|
printConst(mechanism->mechanism, ConstMechanism, 1);
|
|
printf(" Mechanism Data:\n");
|
|
printDump(mechanism->pParameter, mechanism->ulParameterLen);
|
|
break;
|
|
case ArgMechanismInfo:
|
|
mechanismInfo = (CK_MECHANISM_INFO *)ptr->data;
|
|
printf(" Minimum Key Size: %ld\n", mechanismInfo->ulMinKeySize);
|
|
printf(" Maximum Key Size: %ld\n", mechanismInfo->ulMaxKeySize);
|
|
printFlags(" Flags: ", mechanismInfo->flags, ConstMechanismFlags);
|
|
break;
|
|
case ArgInitializeArgs:
|
|
initArgs = (CK_C_INITIALIZE_ARGS *)ptr->data;
|
|
printFlags(" Flags: ", initArgs->flags, ConstInitializeFlags);
|
|
if (initArgs->LibraryParameters) {
|
|
printf("Params: %s\n", (char *)initArgs->LibraryParameters);
|
|
}
|
|
case ArgFunctionList:
|
|
functionList = (CK_FUNCTION_LIST *)ptr->data;
|
|
printf(" Version: %d.%02d\n", VERSION(functionList->version));
|
|
#ifdef notdef
|
|
#undef CK_NEED_ARG_LIST
|
|
#define CK_PKCS11_FUNCTION_INFO(func) \
|
|
printf(" %s: 0x%08lx\n", #func, (unsigned long)functionList->func);
|
|
#include "pkcs11f.h"
|
|
#undef CK_NEED_ARG_LIST
|
|
#undef CK_PKCS11_FUNCTION_INFO
|
|
#endif
|
|
default:
|
|
ckrv = CKR_ARGUMENTS_BAD;
|
|
break;
|
|
}
|
|
|
|
return ckrv;
|
|
}
|
|
|
|
/*
|
|
* Feeling ambitious? turn this whole thing into lexx yacc parser
|
|
* with full expressions.
|
|
*/
|
|
Value **
|
|
parseArgs(int index, const char *bp)
|
|
{
|
|
const Commands *cp = &commands[index];
|
|
int size = strlen(cp->fname);
|
|
int i;
|
|
CK_ULONG value;
|
|
char vname[512];
|
|
Value **argList, *possible;
|
|
ConstType constType;
|
|
|
|
/*
|
|
* skip pass the command
|
|
*/
|
|
if ((cp->fname[0] == 'C') && (cp->fname[1] == '_') && (bp[1] != '_')) {
|
|
size -= 2;
|
|
}
|
|
bp += size;
|
|
|
|
/*
|
|
* Initialize our argument list
|
|
*/
|
|
argList = (Value **)malloc(sizeof(Value *) * MAX_ARGS);
|
|
for (i = 0; i < MAX_ARGS; i++) {
|
|
argList[i] = NULL;
|
|
}
|
|
|
|
/*
|
|
* Walk the argument list parsing it...
|
|
*/
|
|
for (i = 0; i < MAX_ARGS; i++) {
|
|
ArgType type = cp->args[i] & ArgMask;
|
|
int error;
|
|
|
|
/* strip blanks */
|
|
bp = strip(bp);
|
|
|
|
/* if we hit ArgNone, we've nabbed all the arguments we need */
|
|
if (type == ArgNone) {
|
|
break;
|
|
}
|
|
|
|
/* if we run out of space in the line, we weren't given enough
|
|
* arguments... */
|
|
if (*bp == '\0') {
|
|
/* we're into optional arguments, ok to quit now */
|
|
if (cp->args[i] & ArgOpt) {
|
|
break;
|
|
}
|
|
fprintf(stderr, "%s: only %d args found,\n", cp->fname, i);
|
|
parseFree(argList);
|
|
return NULL;
|
|
}
|
|
|
|
/* collect all the rest of the command line and send
|
|
* it as a single argument */
|
|
if (cp->args[i] & ArgFull) {
|
|
int size = strlen(bp) + 1;
|
|
argList[i] = NewValue(type, size);
|
|
memcpy(argList[i]->data, bp, size);
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* look up the argument in our variable list first... only
|
|
* exception is the new argument type for set...
|
|
*/
|
|
error = 0;
|
|
if ((cp->args[i] != (ArgVar | ArgNew)) &&
|
|
(possible = varLookup(bp, vname, sizeof(vname), &error))) {
|
|
/* ints are only compatible with other ints... all other types
|
|
* are interchangeable... */
|
|
if (type != ArgVar) { /* ArgVar's match anyone */
|
|
if ((type == ArgULong) ^
|
|
((possible->type & ArgMask) == ArgULong)) {
|
|
fprintf(stderr, "%s: Arg %d incompatible type with <%s>\n",
|
|
cp->fname, i + 1, vname);
|
|
argFree(possible);
|
|
parseFree(argList);
|
|
return NULL;
|
|
}
|
|
/*
|
|
* ... that is as long as they are big enough...
|
|
*/
|
|
if (ArgSize(type) > possible->size) {
|
|
fprintf(stderr,
|
|
"%s: Arg %d %s is too small (%d bytes needs to be %d bytes)\n",
|
|
cp->fname, i + 1, vname, possible->size, ArgSize(type));
|
|
argFree(possible);
|
|
parseFree(argList);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
/* everything looks kosher here, use it */
|
|
argList[i] = possible;
|
|
|
|
bp = readChars(bp, vname, sizeof(vname));
|
|
if (cp->args[i] & ArgOut) {
|
|
possible->type |= ArgOut;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (error == 1) {
|
|
parseFree(argList);
|
|
return NULL;
|
|
}
|
|
|
|
/* create space for our argument */
|
|
argList[i] = NewValue(type, 1);
|
|
|
|
if ((PL_strncasecmp(bp, "null", 4) == 0) && ((bp[4] == 0) ||
|
|
(bp[4] ==
|
|
' ') ||
|
|
(bp[4] ==
|
|
'\t') ||
|
|
(bp[4] == '\n'))) {
|
|
if (cp->args[i] == ArgULong) {
|
|
fprintf(stderr, "%s: Arg %d CK_ULONG can't be NULL\n",
|
|
cp->fname, i + 1);
|
|
parseFree(argList);
|
|
return NULL;
|
|
}
|
|
argFreeData(argList[i]);
|
|
argList[i]->data = NULL;
|
|
argList[i]->size = 0;
|
|
bp += 4;
|
|
if (*bp)
|
|
bp++;
|
|
continue;
|
|
}
|
|
|
|
/* if we're an output variable, we need to add it */
|
|
if (cp->args[i] & ArgOut) {
|
|
if (PL_strncasecmp(bp, "file(", 5) == 0 /* ) */) {
|
|
char filename[512];
|
|
bp = readChars(bp + 5, filename, sizeof(filename));
|
|
size = PL_strlen(filename);
|
|
if ((size > 0) && (/* ( */ filename[size - 1] == ')')) {
|
|
filename[size - 1] = 0;
|
|
}
|
|
filename[size] = 0;
|
|
argList[i]->filename = (char *)malloc(size + 1);
|
|
|
|
PL_strcpy(argList[i]->filename, filename);
|
|
|
|
argList[i]->type |= ArgOut | ArgFile;
|
|
break;
|
|
}
|
|
bp = AddVariable(bp, &argList[i]);
|
|
argList[i]->type |= ArgOut;
|
|
continue;
|
|
}
|
|
|
|
if (PL_strncasecmp(bp, "file(", 5) == 0 /* ) */) {
|
|
char filename[512];
|
|
|
|
bp = readChars(bp + 5, filename, sizeof(filename));
|
|
size = PL_strlen(filename);
|
|
if ((size > 0) && (/* ( */ filename[size - 1] == ')')) {
|
|
filename[size - 1] = 0;
|
|
}
|
|
|
|
if (restore(filename, argList[i]) != CKR_OK) {
|
|
parseFree(argList);
|
|
return NULL;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
switch (type) {
|
|
case ArgULong:
|
|
bp = constLookup(bp, &value, &constType);
|
|
*(int *)argList[i]->data = value;
|
|
argList[i]->constType = constType;
|
|
break;
|
|
case ArgVar:
|
|
argFreeData(argList[i]);
|
|
size = getEnd(bp) + 1;
|
|
argList[i]->data = (void *)malloc(size);
|
|
argList[i]->size = size;
|
|
/* fall through */
|
|
case ArgInfo:
|
|
case ArgSlotInfo:
|
|
case ArgTokenInfo:
|
|
case ArgSessionInfo:
|
|
case ArgAttribute:
|
|
case ArgMechanism:
|
|
case ArgMechanismInfo:
|
|
case ArgInitializeArgs:
|
|
case ArgUTF8:
|
|
case ArgChar:
|
|
bp = readChars(bp, (char *)argList[i]->data, argList[i]->size);
|
|
case ArgNone:
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
return argList;
|
|
}
|
|
|
|
/* lookup the command in the array */
|
|
int
|
|
lookup(const char *buf)
|
|
{
|
|
int size, i;
|
|
int buflen;
|
|
|
|
buflen = PL_strlen(buf);
|
|
|
|
for (i = 0; i < commandCount; i++) {
|
|
size = PL_strlen(commands[i].fname);
|
|
|
|
if (size <= buflen) {
|
|
if (PL_strncasecmp(buf, commands[i].fname, size) == 0) {
|
|
return i;
|
|
}
|
|
}
|
|
if (size - 2 <= buflen) {
|
|
if (commands[i].fname[0] == 'C' && commands[i].fname[1] == '_' &&
|
|
(PL_strncasecmp(buf, &commands[i].fname[2], size - 2) == 0)) {
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
fprintf(stderr, "Can't find command %s\n", buf);
|
|
return -1;
|
|
}
|
|
|
|
void
|
|
putOutput(Value **ptr)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < MAX_ARGS; i++) {
|
|
ArgType type;
|
|
|
|
if (ptr[i] == NULL)
|
|
break;
|
|
|
|
type = ptr[i]->type;
|
|
|
|
ptr[i]->type &= ~ArgOut;
|
|
if (type == ArgNone) {
|
|
break;
|
|
}
|
|
if (type & ArgOut) {
|
|
(void)printArg(ptr[i], i + 1);
|
|
}
|
|
if (type & ArgFile) {
|
|
save(ptr[i]->filename, ptr[i]);
|
|
free(ptr[i]->filename);
|
|
ptr[i]->filename = NULL; /* paranoia */
|
|
}
|
|
}
|
|
}
|
|
|
|
CK_RV
|
|
unloadModule(Module *module)
|
|
{
|
|
char *disableUnload = NULL;
|
|
|
|
disableUnload = PR_GetEnvSecure("NSS_DISABLE_UNLOAD");
|
|
|
|
if (module->library && !disableUnload) {
|
|
PR_UnloadLibrary(module->library);
|
|
}
|
|
|
|
module->library = NULL;
|
|
module->functionList = NULL;
|
|
|
|
return CKR_OK;
|
|
}
|
|
|
|
CK_RV
|
|
loadModule(Module *module, char *library)
|
|
{
|
|
PRLibrary *newLibrary;
|
|
CK_C_GetFunctionList getFunctionList;
|
|
CK_FUNCTION_LIST *functionList;
|
|
CK_RV ckrv;
|
|
|
|
newLibrary = PR_LoadLibrary(library);
|
|
if (!newLibrary) {
|
|
fprintf(stderr, "Couldn't load library %s\n", library);
|
|
return CKR_FUNCTION_FAILED;
|
|
}
|
|
getFunctionList = (CK_C_GetFunctionList)
|
|
PR_FindSymbol(newLibrary, "C_GetFunctionList");
|
|
if (!getFunctionList) {
|
|
fprintf(stderr, "Couldn't find \"C_GetFunctionList\" in %s\n", library);
|
|
return CKR_FUNCTION_FAILED;
|
|
}
|
|
|
|
ckrv = (*getFunctionList)(&functionList);
|
|
if (ckrv != CKR_OK) {
|
|
return ckrv;
|
|
}
|
|
|
|
if (module->library) {
|
|
PR_UnloadLibrary(module->library);
|
|
}
|
|
|
|
module->library = newLibrary;
|
|
module->functionList = functionList;
|
|
|
|
return CKR_OK;
|
|
}
|
|
|
|
static void
|
|
printHelp(int index, int full)
|
|
{
|
|
int j;
|
|
printf(" %s", commands[index].fname);
|
|
for (j = 0; j < MAX_ARGS; j++) {
|
|
ArgType type = commands[index].args[j] & ArgMask;
|
|
if (type == ArgNone) {
|
|
break;
|
|
}
|
|
printf(" %s", valueString[type]);
|
|
}
|
|
printf("\n");
|
|
printf(" %s\n", commands[index].helpString);
|
|
}
|
|
|
|
/* add Topical help here ! */
|
|
static CK_RV
|
|
printTopicHelp(char *topic)
|
|
{
|
|
int size, i;
|
|
int topicLen;
|
|
|
|
topicLen = PL_strlen(topic);
|
|
|
|
for (i = 0; i < topicCount; i++) {
|
|
size = PL_strlen(topics[i].name);
|
|
|
|
if (size <= topicLen) {
|
|
if (PL_strncasecmp(topic, topics[i].name, size) == 0) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (i == topicCount) {
|
|
fprintf(stderr, "Can't find topic '%s'\n", topic);
|
|
return CKR_DATA_INVALID;
|
|
}
|
|
|
|
printf(" %s", topic);
|
|
printf("\n");
|
|
printf(" %s\n", topics[i].helpString);
|
|
return CKR_OK;
|
|
}
|
|
|
|
static CK_RV
|
|
printGeneralHelp(void)
|
|
{
|
|
int i;
|
|
printf(" To get help on commands, select from the list below:");
|
|
for (i = 0; i < commandCount; i++) {
|
|
if (i % 5 == 0)
|
|
printf("\n");
|
|
printf("%s,", commands[i].fname);
|
|
}
|
|
printf("\n");
|
|
/* print help topics */
|
|
printf(" To get help on a topic, select from the list below:");
|
|
for (i = 0; i < topicCount; i++) {
|
|
if (i % 5 == 0)
|
|
printf("\n");
|
|
printf("%s,", topics[i].name);
|
|
}
|
|
printf("\n");
|
|
return CKR_OK;
|
|
}
|
|
|
|
static CK_RV
|
|
quitIf(CK_ULONG a, const char *cmp, CK_ULONG b)
|
|
{
|
|
if (strcmp(cmp, "<") == 0) {
|
|
return (a < b) ? CKR_QUIT : CKR_OK;
|
|
} else if (strcmp(cmp, ">") == 0) {
|
|
return (a > b) ? CKR_QUIT : CKR_OK;
|
|
} else if (strcmp(cmp, "<=") == 0) {
|
|
return (a <= b) ? CKR_QUIT : CKR_OK;
|
|
} else if (strcmp(cmp, ">=") == 0) {
|
|
return (a >= b) ? CKR_QUIT : CKR_OK;
|
|
} else if (strcmp(cmp, "=") == 0) {
|
|
return (a == b) ? CKR_QUIT : CKR_OK;
|
|
} else if (strcmp(cmp, "!=") == 0) {
|
|
return (a != b) ? CKR_QUIT : CKR_OK;
|
|
}
|
|
printf("Unkown integer comparator: '%s'\n", cmp);
|
|
return CKR_ARGUMENTS_BAD;
|
|
}
|
|
|
|
static CK_RV
|
|
quitIfString(const char *a, const char *cmp, const char *b)
|
|
{
|
|
|
|
if (strcmp(cmp, "=") == 0) {
|
|
return (strcmp(a, b) == 0) ? CKR_QUIT : CKR_OK;
|
|
} else if (strcmp(cmp, "!=") == 0) {
|
|
return (strcmp(a, b) != 0) ? CKR_QUIT : CKR_OK;
|
|
}
|
|
printf("Unkown string comparator: '%s'\n", cmp);
|
|
return CKR_ARGUMENTS_BAD;
|
|
}
|
|
|
|
CK_RV run(const char *);
|
|
CK_RV timeCommand(const char *);
|
|
CK_RV loop(const char *filename, const char *var,
|
|
CK_ULONG start, CK_ULONG end, CK_ULONG step);
|
|
|
|
/*
|
|
* Actually dispatch the function... Bad things happen
|
|
* if these don't match the commands array.
|
|
*/
|
|
CK_RV
|
|
do_func(int index, Value **a)
|
|
{
|
|
int value, helpIndex;
|
|
static Module module = { NULL, NULL };
|
|
CK_FUNCTION_LIST *func = module.functionList;
|
|
|
|
switch (commands[index].fType) {
|
|
case F_C_Initialize:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_Initialize((void *)a[0]->data);
|
|
case F_C_Finalize:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_Finalize((void *)a[0]->data);
|
|
case F_C_GetInfo:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_GetInfo((CK_INFO *)a[0]->data);
|
|
case F_C_GetFunctionList:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_GetFunctionList((CK_FUNCTION_LIST **)a[0]->data);
|
|
case F_C_GetSlotList:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_GetSlotList((CK_BBOOL) * (CK_ULONG *)a[0]->data,
|
|
(CK_SLOT_ID *)a[1]->data,
|
|
(CK_ULONG *)a[2]->data);
|
|
case F_C_GetSlotInfo:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_GetSlotInfo(*(CK_ULONG *)a[0]->data,
|
|
(CK_SLOT_INFO *)a[1]->data);
|
|
case F_C_GetTokenInfo:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_GetTokenInfo(*(CK_ULONG *)a[0]->data,
|
|
(CK_TOKEN_INFO *)a[1]->data);
|
|
case F_C_GetMechanismList:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
if (a[1]->data) {
|
|
a[1]->constType = ConstMechanism;
|
|
}
|
|
return func->C_GetMechanismList(*(CK_ULONG *)a[0]->data,
|
|
(CK_MECHANISM_TYPE *)a[1]->data,
|
|
(CK_ULONG *)a[2]->data);
|
|
case F_C_GetMechanismInfo:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_GetMechanismInfo(*(CK_ULONG *)a[0]->data,
|
|
*(CK_ULONG *)a[1]->data,
|
|
(CK_MECHANISM_INFO *)a[2]->data);
|
|
case F_C_InitToken:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_InitToken(*(CK_ULONG *)a[0]->data,
|
|
(CK_CHAR *)a[1]->data,
|
|
*(CK_ULONG *)a[2]->data,
|
|
(CK_CHAR *)a[3]->data);
|
|
case F_C_InitPIN:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_InitPIN(*(CK_ULONG *)a[0]->data,
|
|
(CK_CHAR *)a[1]->data,
|
|
*(CK_ULONG *)a[2]->data);
|
|
case F_C_SetPIN:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_SetPIN(*(CK_ULONG *)a[0]->data,
|
|
(CK_CHAR *)a[1]->data,
|
|
*(CK_ULONG *)a[2]->data,
|
|
(CK_CHAR *)a[3]->data,
|
|
*(CK_ULONG *)a[4]->data);
|
|
case F_C_OpenSession:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_OpenSession(*(CK_ULONG *)a[0]->data,
|
|
*(CK_ULONG *)a[1]->data,
|
|
(void *)NULL,
|
|
(CK_NOTIFY)NULL,
|
|
(CK_ULONG *)a[2]->data);
|
|
case F_C_CloseSession:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_CloseSession(*(CK_ULONG *)a[0]->data);
|
|
case F_C_CloseAllSessions:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_CloseAllSessions(*(CK_ULONG *)a[0]->data);
|
|
case F_C_GetSessionInfo:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_GetSessionInfo(*(CK_ULONG *)a[0]->data,
|
|
(CK_SESSION_INFO *)a[1]->data);
|
|
case F_C_GetOperationState:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_GetOperationState(*(CK_ULONG *)a[0]->data,
|
|
(CK_BYTE *)a[1]->data,
|
|
(CK_ULONG *)a[2]->data);
|
|
case F_C_SetOperationState:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_SetOperationState(*(CK_ULONG *)a[0]->data,
|
|
(CK_CHAR *)a[1]->data,
|
|
*(CK_ULONG *)a[2]->data,
|
|
*(CK_ULONG *)a[3]->data,
|
|
*(CK_ULONG *)a[4]->data);
|
|
case F_C_Login:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_Login(*(CK_ULONG *)a[0]->data,
|
|
*(CK_ULONG *)a[1]->data,
|
|
(CK_CHAR *)a[2]->data,
|
|
*(CK_ULONG *)a[3]->data);
|
|
case F_C_Logout:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_Logout(*(CK_ULONG *)a[0]->data);
|
|
case F_C_CreateObject:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_CreateObject(*(CK_ULONG *)a[0]->data,
|
|
(CK_ATTRIBUTE *)a[1]->data,
|
|
*(CK_ULONG *)a[2]->data,
|
|
(CK_ULONG *)a[3]->data);
|
|
case F_C_CopyObject:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_CopyObject(*(CK_ULONG *)a[0]->data,
|
|
*(CK_ULONG *)a[0]->data,
|
|
(CK_ATTRIBUTE *)a[1]->data,
|
|
*(CK_ULONG *)a[2]->data,
|
|
(CK_ULONG *)a[3]->data);
|
|
case F_C_DestroyObject:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_DestroyObject(*(CK_ULONG *)a[0]->data,
|
|
*(CK_ULONG *)a[1]->data);
|
|
case F_C_GetObjectSize:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_GetObjectSize(*(CK_ULONG *)a[0]->data,
|
|
*(CK_ULONG *)a[1]->data,
|
|
(CK_ULONG *)a[2]->data);
|
|
case F_C_GetAttributeValue:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_GetAttributeValue(*(CK_ULONG *)a[0]->data,
|
|
*(CK_ULONG *)a[1]->data,
|
|
(CK_ATTRIBUTE *)a[2]->data,
|
|
*(CK_ULONG *)a[3]->data);
|
|
case F_C_SetAttributeValue:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_SetAttributeValue(*(CK_ULONG *)a[0]->data,
|
|
*(CK_ULONG *)a[1]->data,
|
|
(CK_ATTRIBUTE *)a[2]->data,
|
|
*(CK_ULONG *)a[3]->data);
|
|
case F_C_FindObjectsInit:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_FindObjectsInit(*(CK_ULONG *)a[0]->data,
|
|
(CK_ATTRIBUTE *)a[1]->data,
|
|
*(CK_ULONG *)a[2]->data);
|
|
case F_C_FindObjects:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_FindObjects(*(CK_ULONG *)a[0]->data,
|
|
(CK_ULONG *)a[1]->data,
|
|
*(CK_ULONG *)a[2]->data,
|
|
(CK_ULONG *)a[3]->data);
|
|
case F_C_FindObjectsFinal:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_FindObjectsFinal(*(CK_ULONG *)a[0]->data);
|
|
case F_C_EncryptInit:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_EncryptInit(*(CK_ULONG *)a[0]->data,
|
|
(CK_MECHANISM *)a[1]->data,
|
|
*(CK_ULONG *)a[2]->data);
|
|
case F_C_Encrypt:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_Encrypt(*(CK_ULONG *)a[0]->data,
|
|
(CK_CHAR *)a[1]->data,
|
|
*(CK_ULONG *)a[2]->data,
|
|
(CK_CHAR *)a[3]->data,
|
|
(CK_ULONG *)a[4]->data);
|
|
case F_C_EncryptUpdate:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_EncryptUpdate(*(CK_ULONG *)a[0]->data,
|
|
(CK_CHAR *)a[1]->data,
|
|
*(CK_ULONG *)a[2]->data,
|
|
(CK_CHAR *)a[3]->data,
|
|
(CK_ULONG *)a[4]->data);
|
|
case F_C_EncryptFinal:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_EncryptFinal(*(CK_ULONG *)a[0]->data,
|
|
(CK_CHAR *)a[1]->data,
|
|
(CK_ULONG *)a[2]->data);
|
|
case F_C_DecryptInit:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_DecryptInit(*(CK_ULONG *)a[0]->data,
|
|
(CK_MECHANISM *)a[1]->data,
|
|
*(CK_ULONG *)a[2]->data);
|
|
case F_C_Decrypt:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_Decrypt(*(CK_ULONG *)a[0]->data,
|
|
(CK_CHAR *)a[1]->data,
|
|
*(CK_ULONG *)a[2]->data,
|
|
(CK_CHAR *)a[3]->data,
|
|
(CK_ULONG *)a[4]->data);
|
|
case F_C_DecryptUpdate:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_DecryptUpdate(*(CK_ULONG *)a[0]->data,
|
|
(CK_CHAR *)a[1]->data,
|
|
*(CK_ULONG *)a[2]->data,
|
|
(CK_CHAR *)a[3]->data,
|
|
(CK_ULONG *)a[4]->data);
|
|
case F_C_DecryptFinal:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_DecryptFinal(*(CK_ULONG *)a[0]->data,
|
|
(CK_CHAR *)a[1]->data,
|
|
(CK_ULONG *)a[2]->data);
|
|
case F_C_DigestInit:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_DigestInit(*(CK_ULONG *)a[0]->data,
|
|
(CK_MECHANISM *)a[1]->data);
|
|
case F_C_Digest:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_Digest(*(CK_ULONG *)a[0]->data,
|
|
(CK_CHAR *)a[1]->data,
|
|
*(CK_ULONG *)a[2]->data,
|
|
(CK_CHAR *)a[3]->data,
|
|
(CK_ULONG *)a[4]->data);
|
|
case F_C_DigestUpdate:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_DigestUpdate(*(CK_ULONG *)a[0]->data,
|
|
(CK_CHAR *)a[1]->data,
|
|
*(CK_ULONG *)a[2]->data);
|
|
case F_C_DigestKey:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_DigestKey(*(CK_ULONG *)a[0]->data,
|
|
*(CK_ULONG *)a[1]->data);
|
|
case F_C_DigestFinal:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_DigestFinal(*(CK_ULONG *)a[0]->data,
|
|
(CK_CHAR *)a[1]->data,
|
|
(CK_ULONG *)a[2]->data);
|
|
case F_C_SignInit:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_SignInit(*(CK_ULONG *)a[0]->data,
|
|
(CK_MECHANISM *)a[1]->data,
|
|
*(CK_ULONG *)a[2]->data);
|
|
case F_C_Sign:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_Sign(*(CK_ULONG *)a[0]->data,
|
|
(CK_CHAR *)a[1]->data,
|
|
*(CK_ULONG *)a[2]->data,
|
|
(CK_CHAR *)a[3]->data,
|
|
(CK_ULONG *)a[4]->data);
|
|
case F_C_SignUpdate:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_SignUpdate(*(CK_ULONG *)a[0]->data,
|
|
(CK_CHAR *)a[1]->data,
|
|
*(CK_ULONG *)a[2]->data);
|
|
case F_C_SignFinal:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_SignFinal(*(CK_ULONG *)a[0]->data,
|
|
(CK_CHAR *)a[1]->data,
|
|
(CK_ULONG *)a[2]->data);
|
|
|
|
case F_C_SignRecoverInit:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_SignRecoverInit(*(CK_ULONG *)a[0]->data,
|
|
(CK_MECHANISM *)a[1]->data,
|
|
*(CK_ULONG *)a[2]->data);
|
|
case F_C_SignRecover:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_SignRecover(*(CK_ULONG *)a[0]->data,
|
|
(CK_CHAR *)a[1]->data,
|
|
*(CK_ULONG *)a[2]->data,
|
|
(CK_CHAR *)a[3]->data,
|
|
(CK_ULONG *)a[4]->data);
|
|
case F_C_VerifyInit:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_VerifyInit(*(CK_ULONG *)a[0]->data,
|
|
(CK_MECHANISM *)a[1]->data,
|
|
*(CK_ULONG *)a[2]->data);
|
|
case F_C_Verify:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_Verify(*(CK_ULONG *)a[0]->data,
|
|
(CK_CHAR *)a[1]->data,
|
|
*(CK_ULONG *)a[2]->data,
|
|
(CK_CHAR *)a[3]->data,
|
|
*(CK_ULONG *)a[4]->data);
|
|
case F_C_VerifyUpdate:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_VerifyUpdate(*(CK_ULONG *)a[0]->data,
|
|
(CK_CHAR *)a[1]->data,
|
|
*(CK_ULONG *)a[2]->data);
|
|
case F_C_VerifyFinal:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_VerifyFinal(*(CK_ULONG *)a[0]->data,
|
|
(CK_CHAR *)a[1]->data,
|
|
*(CK_ULONG *)a[2]->data);
|
|
|
|
case F_C_VerifyRecoverInit:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_VerifyRecoverInit(*(CK_ULONG *)a[0]->data,
|
|
(CK_MECHANISM *)a[1]->data,
|
|
*(CK_ULONG *)a[2]->data);
|
|
case F_C_VerifyRecover:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_VerifyRecover(*(CK_ULONG *)a[0]->data,
|
|
(CK_CHAR *)a[1]->data,
|
|
*(CK_ULONG *)a[2]->data,
|
|
(CK_CHAR *)a[3]->data,
|
|
(CK_ULONG *)a[4]->data);
|
|
case F_C_DigestEncryptUpdate:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_DigestEncryptUpdate(*(CK_ULONG *)a[0]->data,
|
|
(CK_CHAR *)a[1]->data,
|
|
*(CK_ULONG *)a[2]->data,
|
|
(CK_CHAR *)a[3]->data,
|
|
(CK_ULONG *)a[4]->data);
|
|
case F_C_DecryptDigestUpdate:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_DecryptDigestUpdate(*(CK_ULONG *)a[0]->data,
|
|
(CK_CHAR *)a[1]->data,
|
|
*(CK_ULONG *)a[2]->data,
|
|
(CK_CHAR *)a[3]->data,
|
|
(CK_ULONG *)a[4]->data);
|
|
case F_C_SignEncryptUpdate:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_SignEncryptUpdate(*(CK_ULONG *)a[0]->data,
|
|
(CK_CHAR *)a[1]->data,
|
|
*(CK_ULONG *)a[2]->data,
|
|
(CK_CHAR *)a[3]->data,
|
|
(CK_ULONG *)a[4]->data);
|
|
case F_C_DecryptVerifyUpdate:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_DecryptVerifyUpdate(*(CK_ULONG *)a[0]->data,
|
|
(CK_CHAR *)a[1]->data,
|
|
*(CK_ULONG *)a[2]->data,
|
|
(CK_CHAR *)a[3]->data,
|
|
(CK_ULONG *)a[4]->data);
|
|
case F_C_GenerateKey:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_GenerateKey(*(CK_ULONG *)a[0]->data,
|
|
(CK_MECHANISM *)a[1]->data,
|
|
(CK_ATTRIBUTE *)a[2]->data,
|
|
*(CK_ULONG *)a[3]->data,
|
|
(CK_ULONG *)a[4]->data);
|
|
case F_C_GenerateKeyPair:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_GenerateKeyPair(*(CK_ULONG *)a[0]->data,
|
|
(CK_MECHANISM *)a[1]->data,
|
|
(CK_ATTRIBUTE *)a[2]->data,
|
|
*(CK_ULONG *)a[3]->data,
|
|
(CK_ATTRIBUTE *)a[4]->data,
|
|
*(CK_ULONG *)a[5]->data,
|
|
(CK_ULONG *)a[6]->data,
|
|
(CK_ULONG *)a[7]->data);
|
|
case F_C_WrapKey:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_WrapKey(*(CK_ULONG *)a[0]->data,
|
|
(CK_MECHANISM *)a[1]->data,
|
|
*(CK_ULONG *)a[2]->data,
|
|
*(CK_ULONG *)a[3]->data,
|
|
(CK_CHAR *)a[5]->data,
|
|
(CK_ULONG *)a[6]->data);
|
|
case F_C_UnwrapKey:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_UnwrapKey(*(CK_ULONG *)a[0]->data,
|
|
(CK_MECHANISM *)a[1]->data,
|
|
*(CK_ULONG *)a[2]->data,
|
|
(CK_CHAR *)a[3]->data,
|
|
*(CK_ULONG *)a[4]->data,
|
|
(CK_ATTRIBUTE *)a[5]->data,
|
|
*(CK_ULONG *)a[6]->data,
|
|
(CK_ULONG *)a[7]->data);
|
|
case F_C_DeriveKey:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_DeriveKey(*(CK_ULONG *)a[0]->data,
|
|
(CK_MECHANISM *)a[1]->data,
|
|
*(CK_ULONG *)a[2]->data,
|
|
(CK_ATTRIBUTE *)a[3]->data,
|
|
*(CK_ULONG *)a[4]->data,
|
|
(CK_ULONG *)a[5]->data);
|
|
case F_C_SeedRandom:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_SeedRandom(*(CK_ULONG *)a[0]->data,
|
|
(CK_CHAR *)a[1]->data,
|
|
*(CK_ULONG *)a[2]->data);
|
|
case F_C_GenerateRandom:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_GenerateRandom(*(CK_ULONG *)a[0]->data,
|
|
(CK_CHAR *)a[1]->data,
|
|
*(CK_ULONG *)a[2]->data);
|
|
case F_C_GetFunctionStatus:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_GetFunctionStatus(*(CK_ULONG *)a[0]->data);
|
|
case F_C_CancelFunction:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_CancelFunction(*(CK_ULONG *)a[0]->data);
|
|
case F_C_WaitForSlotEvent:
|
|
if (!func)
|
|
return CKR_CRYPTOKI_NOT_INITIALIZED;
|
|
return func->C_WaitForSlotEvent(*(CK_ULONG *)a[0]->data,
|
|
(CK_ULONG *)a[1]->data,
|
|
(void *)a[2]->data);
|
|
/* set a variable */
|
|
case F_SetVar:
|
|
case F_SetStringVar:
|
|
(void)DeleteVariable(a[0]->data);
|
|
(void)AddVariable(a[0]->data, &a[1]);
|
|
return CKR_OK;
|
|
/* print a value */
|
|
case F_Print:
|
|
return printArg(a[0], 0);
|
|
case F_SaveVar:
|
|
return save(a[0]->data, a[1]);
|
|
case F_RestoreVar:
|
|
return restore(a[0]->data, a[1]);
|
|
case F_Delete:
|
|
return DeleteVariable(a[0]->data);
|
|
case F_Increment:
|
|
return increment(a[0], *(CK_ULONG *)a[1]->data);
|
|
case F_Decrement:
|
|
return decrement(a[0], *(CK_ULONG *)a[1]->data);
|
|
case F_List:
|
|
return list();
|
|
case F_Run:
|
|
return run(a[0]->data);
|
|
case F_Time:
|
|
return timeCommand(a[0]->data);
|
|
case F_Load:
|
|
return loadModule(&module, a[0]->data);
|
|
case F_Unload:
|
|
return unloadModule(&module);
|
|
case F_NewArray:
|
|
(void)DeleteVariable(a[0]->data);
|
|
return ArrayVariable(a[0]->data, a[1]->data, *(CK_ULONG *)a[2]->data);
|
|
case F_NewTemplate:
|
|
(void)DeleteVariable(a[0]->data);
|
|
return ArrayTemplate(a[0]->data, a[1]->data);
|
|
case F_BuildTemplate:
|
|
return BuildTemplate(a[0]);
|
|
case F_SetTemplate:
|
|
return SetTemplate(a[0],
|
|
*(CK_ULONG *)a[1]->data,
|
|
*(CK_ULONG *)a[2]->data);
|
|
case F_NewMechanism:
|
|
(void)DeleteVariable(a[0]->data);
|
|
return NewMechanism(a[0]->data, *(CK_ULONG *)a[1]->data);
|
|
case F_NewInitializeArgs:
|
|
(void)DeleteVariable(a[0]->data);
|
|
return NewInitializeArgs(a[0]->data, *(CK_ULONG *)a[1]->data, a[2]->data);
|
|
case F_System:
|
|
value = *(int *)a[0]->data;
|
|
if (value & 0x80000000) {
|
|
systemFlags &= ~value;
|
|
} else {
|
|
systemFlags |= value;
|
|
}
|
|
return CKR_OK;
|
|
case F_Loop:
|
|
return loop(a[0]->data, a[1]->data, *(CK_ULONG *)a[2]->data,
|
|
*(CK_ULONG *)a[3]->data, *(CK_ULONG *)a[4]->data);
|
|
case F_Help:
|
|
if (a[0]) {
|
|
helpIndex = lookup(a[0]->data);
|
|
if (helpIndex < 0) {
|
|
return printTopicHelp(a[0]->data);
|
|
}
|
|
printHelp(helpIndex, 1);
|
|
return CKR_OK;
|
|
}
|
|
return printGeneralHelp();
|
|
case F_QuitIfString:
|
|
return quitIfString(a[0]->data, a[1]->data, a[2]->data);
|
|
case F_QuitIf:
|
|
return quitIf(*(CK_ULONG *)a[0]->data, a[1]->data, *(CK_ULONG *)a[2]->data);
|
|
case F_Quit:
|
|
return CKR_QUIT;
|
|
default:
|
|
fprintf(stderr,
|
|
"Function %s not yet supported\n", commands[index].fname);
|
|
return CKR_OK;
|
|
}
|
|
/* Not Reached */
|
|
return CKR_OK;
|
|
}
|
|
|
|
CK_RV
|
|
processCommand(const char *buf)
|
|
{
|
|
CK_RV error = CKR_OK;
|
|
int index;
|
|
const char *bp;
|
|
Value **arglist;
|
|
|
|
bp = strip(buf);
|
|
/* allow comments and blank lines in scripts */
|
|
if ((*bp == '#') || (*bp == 0) || (*bp == '\n')) {
|
|
return CKR_OK;
|
|
}
|
|
|
|
index = lookup(bp);
|
|
|
|
if (index < 0) {
|
|
return CKR_OK;
|
|
}
|
|
|
|
arglist = parseArgs(index, bp);
|
|
if (arglist == NULL) {
|
|
return CKR_OK;
|
|
}
|
|
|
|
error = do_func(index, arglist);
|
|
if (error == CKR_OK) {
|
|
putOutput(arglist);
|
|
} else if (error != CKR_QUIT) {
|
|
printf(">> Error : ");
|
|
printConst(error, ConstResult, 1);
|
|
}
|
|
|
|
parseFree(arglist);
|
|
return error;
|
|
}
|
|
|
|
CK_RV
|
|
timeCommand(const char *command)
|
|
{
|
|
CK_RV ckrv;
|
|
PRIntervalTime startTime = PR_IntervalNow();
|
|
PRIntervalTime endTime;
|
|
PRIntervalTime elapsedTime;
|
|
|
|
ckrv = processCommand(command);
|
|
|
|
endTime = PR_IntervalNow();
|
|
elapsedTime = endTime - startTime;
|
|
printf("Time -- %d msec \n",
|
|
PR_IntervalToMilliseconds(elapsedTime));
|
|
|
|
return ckrv;
|
|
}
|
|
|
|
CK_RV
|
|
process(FILE *inFile, int user)
|
|
{
|
|
char buf[2048];
|
|
CK_RV error;
|
|
CK_RV ckrv = CKR_OK;
|
|
|
|
if (user) {
|
|
printf("pkcs11> ");
|
|
fflush(stdout);
|
|
}
|
|
|
|
while (fgets(buf, 2048, inFile) != NULL) {
|
|
|
|
if (!user)
|
|
printf("* %s", buf);
|
|
error = processCommand(buf);
|
|
if (error == CKR_QUIT) {
|
|
break;
|
|
} else if (error != CKR_OK) {
|
|
ckrv = error;
|
|
}
|
|
if (user) {
|
|
printf("pkcs11> ");
|
|
fflush(stdout);
|
|
}
|
|
}
|
|
return ckrv;
|
|
}
|
|
|
|
CK_RV
|
|
run(const char *filename)
|
|
{
|
|
FILE *infile;
|
|
CK_RV ckrv;
|
|
|
|
infile = fopen(filename, "r");
|
|
|
|
if (infile == NULL) {
|
|
perror(filename);
|
|
return CKR_FUNCTION_FAILED;
|
|
}
|
|
|
|
ckrv = process(infile, 0);
|
|
|
|
fclose(infile);
|
|
return ckrv;
|
|
}
|
|
|
|
CK_RV
|
|
loop(const char *filename, const char *var,
|
|
CK_ULONG start, CK_ULONG end, CK_ULONG step)
|
|
{
|
|
CK_ULONG i = 0;
|
|
Value *value = 0;
|
|
CK_RV ckrv;
|
|
|
|
for (i = start; i < end; i += step) {
|
|
value = NewValue(ArgULong, 1);
|
|
*(CK_ULONG *)value->data = i;
|
|
DeleteVariable(var);
|
|
AddVariable(var, &value);
|
|
ckrv = run(filename);
|
|
argFree(value);
|
|
if (ckrv == CKR_QUIT) {
|
|
break;
|
|
}
|
|
}
|
|
return ckrv;
|
|
}
|
|
|
|
int
|
|
main(int argc, char **argv)
|
|
{
|
|
/* I suppose that some day we could parse some arguments */
|
|
(void)process(stdin, 1);
|
|
return 0;
|
|
}
|