pool/coolkey
SHA256
2
0
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
da9c26ea10
coolkey/coolkey-1.1.0-p15.patch

4380 lines
139 KiB
Diff
Raw Blame History

diff -up ./src/coolkey/coolkey.cpp.p15 ./src/coolkey/coolkey.cpp
--- ./src/coolkey/coolkey.cpp.p15 2015-07-06 10:27:55.769827286 -0700
+++ ./src/coolkey/coolkey.cpp 2015-07-06 10:27:55.784827002 -0700
@@ -599,13 +599,10 @@ C_Login(CK_SESSION_HANDLE hSession, CK_U
}
try {
log->log("C_Login called\n");
- if( userType != CKU_USER ) {
- throw PKCS11Exception(CKR_USER_TYPE_INVALID);
- }
if( pPin == NULL ) {
throw PKCS11Exception(CKR_ARGUMENTS_BAD);
}
- slotList->login(hSession, pPin, ulPinLen);
+ slotList->login(hSession, userType, pPin, ulPinLen);
return CKR_OK;
} catch(PKCS11Exception &e) {
e.log(log);
diff -up ./src/coolkey/object.cpp.p15 ./src/coolkey/object.cpp
--- ./src/coolkey/object.cpp.p15 2015-07-06 10:27:55.770827267 -0700
+++ ./src/coolkey/object.cpp 2015-07-06 10:27:55.785826984 -0700
@@ -19,9 +19,9 @@
#include "mypkcs11.h"
#include "PKCS11Exception.h"
-#include "object.h"
#include <algorithm>
#include <string.h>
+#include "object.h"
using std::find_if;
@@ -29,7 +29,7 @@ const CKYByte rsaOID[] = {0x2A,0x86,0x48
const CKYByte eccOID[] = {0x2a,0x86,0x48,0xce,0x3d,0x02,0x01};
#ifdef DEBUG
-void dump(CKYBuffer *buf)
+void dump(const char *label, const CKYBuffer *buf)
{
CKYSize i;
CKYSize size = CKYBuffer_Size(buf);
@@ -38,8 +38,10 @@ void dump(CKYBuffer *buf)
char *bp = &string[0];
CKYByte c;
+ printf("%s size=%d\n", label, (int)size);
+
for (i=0; i < size; i++) {
- if (i && ((i % (ROW_LENGTH-1)) == 0) ) {
+ if (i && ((i % (ROW_LENGTH)) == 0) ) {
*bp = 0;
printf(" %s\n",string);
bp = &string[0];
@@ -49,7 +51,35 @@ void dump(CKYBuffer *buf)
*bp++ = (c < ' ') ? '.' : ((c & 0x80) ? '*' : c);
}
*bp = 0;
- for (i= (i % (ROW_LENGTH-1)); i && (i < ROW_LENGTH); i++) {
+ for (i= (i % (ROW_LENGTH)); i && (i < ROW_LENGTH); i++) {
+ printf(" ");
+ }
+ printf(" %s\n",string);
+ fflush(stdout);
+}
+
+void dumpData(const char *label, const CKYByte *buf, CKYSize size)
+{
+ CKYSize i;
+#define ROW_LENGTH 16
+ char string[ROW_LENGTH+1];
+ char *bp = &string[0];
+ CKYByte c;
+
+ printf("%s size=%d:\n",label, (int)size);
+
+ for (i=0; i < size; i++) {
+ if (i && ((i % (ROW_LENGTH)) == 0) ) {
+ *bp = 0;
+ printf(" %s\n",string);
+ bp = &string[0];
+ }
+ c = buf[i];
+ printf("%02x ",c);
+ *bp++ = (c < ' ') ? '.' : ((c & 0x80) ? '*' : c);
+ }
+ *bp = 0;
+ for (i= (i % (ROW_LENGTH)); i && (i < ROW_LENGTH); i++) {
printf(" ");
}
printf(" %s\n",string);
@@ -77,16 +107,23 @@ class AttributeTypeMatch
};
PKCS11Object::PKCS11Object(unsigned long muscleObjID_,CK_OBJECT_HANDLE handle_)
- : muscleObjID(muscleObjID_), handle(handle_), label(NULL), name(NULL), keyType(unknown)
+ : muscleObjID(muscleObjID_), handle(handle_), label(NULL), keySize(0),
+ user(CKU_USER), name(NULL), keyType(unknown),
+ keyRef(PK15_INVALID_KEY_REF)
{
CKYBuffer_InitEmpty(&pubKey);
+ CKYBuffer_InitEmpty(&authId);
+ CKYBuffer_InitEmpty(&pinAuthId);
}
PKCS11Object::PKCS11Object(unsigned long muscleObjID_, const CKYBuffer *data,
CK_OBJECT_HANDLE handle_) : muscleObjID(muscleObjID_), handle(handle_),
- label(NULL), name(NULL), keyType(unknown)
+ label(NULL), keySize(0), user(CKU_USER), name(NULL),
+ keyType(unknown), keyRef(PK15_INVALID_KEY_REF)
{
CKYBuffer_InitEmpty(&pubKey);
+ CKYBuffer_InitEmpty(&authId);
+ CKYBuffer_InitEmpty(&pinAuthId);
CKYByte type = CKYBuffer_GetChar(data,0);
// verify object ID is what we think it is
@@ -582,6 +619,21 @@ PKCS11Object::setAttribute(CK_ATTRIBUTE_
}
void
+PKCS11Object::setAttribute(CK_ATTRIBUTE_TYPE type, const CKYByte *data,
+ CKYSize size)
+{
+ AttributeIter iter;
+
+ iter = find_if(attributes.begin(), attributes.end(),
+ AttributeTypeMatch(type));
+ if( iter != attributes.end() ) {
+ iter->setValue( data, size);
+ } else {
+ attributes.push_back(PKCS11Attribute(type, data, size));
+ }
+}
+
+void
PKCS11Object::setAttribute(CK_ATTRIBUTE_TYPE type, const char *string)
{
CKYBuffer buf;
@@ -613,7 +665,7 @@ PKCS11Object::setAttributeULong(CK_ATTRI
typedef struct {
const CKYByte*data;
- unsigned int len;
+ CKYSize len;
} CCItem;
typedef enum {
@@ -621,9 +673,9 @@ typedef enum {
SECFailure=1
} SECStatus;
-static const CKYByte*
-dataStart(const CKYByte *buf, unsigned int length,
- unsigned int *data_length, bool includeTag) {
+const CKYByte*
+dataStart(const CKYByte *buf, CKYSize length,
+ CKYSize *data_length, bool includeTag) {
unsigned char tag;
unsigned int used_length= 0;
@@ -673,7 +725,7 @@ dataStart(const CKYByte *buf, unsigned i
}
static const CKYByte *
-unwrapBitString(const CKYByte *buf, unsigned int len, unsigned int *retLen)
+unwrapBitString(const CKYByte *buf, CKYSize len, CKYSize *retLen)
{
/* for RSA, bit string always has byte number of bits */
if (buf[0] != 0) {
@@ -687,15 +739,15 @@ unwrapBitString(const CKYByte *buf, unsi
}
static SECStatus
-GetECKeyFieldItems(const CKYByte *spki_data,unsigned int spki_length,
+GetECKeyFieldItems(const CKYByte *spki_data, CKYSize spki_length,
CCItem *point, CCItem *params)
{
const CKYByte *buf = spki_data;
- unsigned int buf_length = spki_length;
+ CKYSize buf_length = spki_length;
const CKYByte *algid;
- unsigned int algidlen;
+ CKYSize algidlen;
const CKYByte *dummy;
- unsigned int dummylen;
+ CKYSize dummylen;
if (!point || !params || !buf)
return SECFailure;
@@ -756,12 +808,12 @@ GetKeyOIDMatches(const CKYByte *spki_dat
}
static SECStatus
-GetKeyAlgorithmId(const CKYByte *spki_data, unsigned int spki_length,
+GetKeyAlgorithmId(const CKYByte *spki_data, CKYSize spki_length,
CCItem *algorithmId)
{
const CKYByte *buf = spki_data;
- unsigned int buf_length = spki_length;
+ CKYSize buf_length = spki_length;
if ( algorithmId == NULL) return SECFailure;
@@ -786,7 +838,7 @@ GetKeyTypeFromSPKI(const CKYBuffer *key)
"Failed to decode key algorithm ID.");
}
- unsigned int length = 0;
+ CKYSize length = 0;
const CKYByte *keyData = NULL;
/* Get actual oid buffer */
@@ -829,13 +881,13 @@ GetKeyTypeFromSPKI(const CKYBuffer *key)
}
static SECStatus
-GetKeyFieldItems(const CKYByte *spki_data,unsigned int spki_length,
+GetKeyFieldItems(const CKYByte *spki_data,CKYSize spki_length,
CCItem *modulus, CCItem *exponent)
{
const CKYByte *buf = spki_data;
- unsigned int buf_length = spki_length;
+ CKYSize buf_length = spki_length;
const CKYByte*dummy;
- unsigned int dummylen;
+ CKYSize dummylen;
/* skip past the algorithm id */
dummy = dataStart(buf,buf_length,&dummylen,false);
@@ -955,7 +1007,7 @@ Key::Key(unsigned long muscleObjID, cons
}
void
-Key::completeKey(const PKCS11Object &cert)
+PKCS11Object::completeKey(const PKCS11Object &cert)
{
// infer key attributes from cert
bool modulusExists, exponentExists;
@@ -1015,14 +1067,14 @@ Key::completeKey(const PKCS11Object &cer
}
static SECStatus
-GetCertFieldItems(const CKYByte *dercert,unsigned int cert_length,
+GetCertFieldItems(const CKYByte *dercert, CKYSize cert_length,
CCItem *issuer, CCItem *serial, CCItem *derSN, CCItem *subject,
CCItem *valid, CCItem *subjkey)
{
const CKYByte *buf;
- unsigned int buf_length;
+ CKYSize buf_length;
const CKYByte*dummy;
- unsigned int dummylen;
+ CKYSize dummylen;
/* get past the signature wrap */
buf = dataStart(dercert,cert_length,&buf_length, false);
@@ -1330,10 +1382,10 @@ static const unsigned char CN_DATA[] = {
const unsigned int CN_LENGTH = sizeof(CN_DATA);
static SECStatus
-GetCN(const CKYByte *dn, unsigned int dn_length, CCItem *cn)
+GetCN(const CKYByte *dn, CKYSize dn_length, CCItem *cn)
{
const CKYByte *buf;
- unsigned int buf_length;
+ CKYSize buf_length;
/* unwrap the sequence */
buf = dataStart(dn,dn_length,&buf_length, false);
@@ -1341,9 +1393,9 @@ GetCN(const CKYByte *dn, unsigned int dn
while (buf_length) {
const CKYByte *name;
- unsigned int name_length;
+ CKYSize name_length;
const CKYByte *oid;
- unsigned int oid_length;
+ CKYSize oid_length;
/* unwrap the set */
name = dataStart(buf, buf_length, &name_length, false);
@@ -1408,13 +1460,6 @@ CACCert::CACCert(CKYByte instance, const
{
CKYBuffer id;
CKYBuffer empty;
- CK_BBOOL decrypt = FALSE;
-
- /* So we know what the key is supposed to be used for based on
- * the instance */
- if (instance == 2) {
- decrypt = TRUE;
- }
CKYBuffer_InitEmpty(&empty);
setAttributeULong(CKA_CLASS, CKO_CERTIFICATE);
@@ -1456,6 +1501,1063 @@ CACCert::CACCert(CKYByte instance, const
CKYBuffer_FreeData(&derIssuer);
}
+static const CKYByte rev[] = {
+ 0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
+ 0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
+ 0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
+ 0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
+ 0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
+ 0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
+ 0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
+ 0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
+ 0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
+ 0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
+ 0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
+ 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
+ 0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
+ 0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
+ 0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
+ 0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
+ 0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
+ 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
+ 0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
+ 0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
+ 0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
+ 0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
+ 0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
+ 0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
+ 0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
+ 0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
+ 0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
+ 0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
+ 0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
+ 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
+ 0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
+ 0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff
+};
+
+unsigned long GetBits(const CKYByte *entry, CKYSize entrySize,
+ unsigned int numBits, unsigned int numBytes)
+{
+ unsigned long bits = 0;
+ unsigned long bitFlag = 0;
+ unsigned int i;
+
+ /* size of zero is valid for no bits */
+ if (entrySize <= 1) {
+ return 0;
+ }
+ entrySize--;
+ entry++;
+
+ /* if we are longer than and unsigned, just bail now */
+ if (entrySize > sizeof (unsigned long)) {
+ bitFlag = BROKEN_FLAG;
+ entrySize = sizeof(unsigned long);
+ }
+ /* turn the flags into an int */
+ for (i=0; i < entrySize; i++) {
+ CKYByte c = rev[entry[i]];
+ bits = bits | (c << i*8);
+ }
+ return bits | bitFlag;
+}
+
+
+/*
+ * parse the path object.
+ * Caller has already unwrapped the outer ASN1Sequence
+ */
+CKYStatus PK15ObjectPath::setObjectPath(const CKYByte *current, CKYSize size)
+{
+ const CKYByte *entry;
+ CKYSize entrySize;
+ CKYSize tagSize;
+ unsigned int i;
+ CKYStatus status;
+
+
+ if ((current == NULL) || (current[0] != ASN1_OCTET_STRING)) {
+ return CKYINVALIDDATA;
+ }
+ /* entry */
+ entry = dataStart(current, size, &entrySize, false);
+ if (entry == NULL) { return CKYINVALIDDATA; }
+ tagSize = entry - current;
+ current += entrySize + tagSize;
+ size -= (entrySize +tagSize);
+ if (size < 0) { return CKYINVALIDDATA; }
+ status = CKYBuffer_Replace(&path, 0, entry, entrySize);
+ if (status != CKYSUCCESS) {
+ return status;
+ }
+
+ /* index */
+ if ((size != 0) && current[0] == ASN1_INTEGER) {
+ entry = dataStart(current, size, &entrySize, false);
+ if (entry == NULL) { return CKYINVALIDDATA; }
+ tagSize = entry - current;
+ current += entrySize + tagSize;
+ size -= (entrySize +tagSize);
+ if (size < 0) { return CKYINVALIDDATA; }
+ if (entrySize > 5) { return CKYINVALIDDATA; }
+ for (index = 0, i=0; i < entrySize; i++) {
+ index = (index << 8) + (unsigned int) entry[i];
+ }
+ }
+
+ /* length */
+ if ((size != 0) && ((current[0]|ASN1_CONSTRUCTED) == ASN1_CHOICE_0)) {
+ entry = dataStart(current, size, &entrySize, false);
+ if (entry == NULL) { return CKYINVALIDDATA; }
+ tagSize = entry - current;
+ current += entrySize + tagSize;
+ size -= (entrySize +tagSize);
+ if (size < 0) { return CKYINVALIDDATA; }
+ if (entrySize > 5) { return CKYINVALIDDATA; }
+ for (length = 0, i=0; i < entrySize; i++) {
+ length = (length << 8) + (unsigned int) entry[i];
+ }
+ }
+ return CKYSUCCESS;
+}
+
+static unsigned int pK15GetTag(PK15ObjectType type) {
+ switch (type) { case PK15PvKey: case PK15PuKey: return 'k'<<24;
+ case PK15Cert: return 'c' << 24; default: break; }
+ return 'v';
+}
+
+
+PK15Object::PK15Object(CKYByte inst, PK15ObjectType type,
+ const CKYByte *der, CKYSize derSize)
+ : PKCS11Object(pK15GetTag(type) | ((inst+'0') << 16), 0xa000 | inst)
+{
+ CKYStatus status;
+
+ instance = inst;
+ p15Type = type;
+ CKYBuffer_InitEmpty(&authId);
+ CKYBuffer_InitEmpty(&pinAuthId);
+ state = PK15StateInit;
+ pinInfo.pinFlags = 0;
+ pinInfo.pinType = P15PinUTF8;
+ pinInfo.minLength = 4;
+ pinInfo.storedLength = 0;
+ pinInfo.maxLength = 0;
+ pinInfo.pinRef = 0;
+ pinInfo.padChar = 0xff;
+
+ status = completeObject(der, derSize);
+ if (status != CKYSUCCESS) {
+ state = PK15StateInit; /* don't try to fetch any more if we failed */
+ }
+}
+
+/* returns true if there is more work to do... */
+CKYStatus
+PK15Object::completeObject(const CKYByte *current, CKYSize currentSize)
+{
+ const CKYByte *commonAttributes;
+ CKYSize commonSize;
+ const CKYByte *entry;
+ CKYSize entrySize;
+ CKYSize tagSize;
+ CKYByte objectTag;
+ CKYStatus status;
+ CKYBitFlags bits;
+
+ switch (state) {
+ case PK15StateInit:
+ case PK15StateNeedObject:
+ break;
+ case PK15StateNeedRawPublicKey:
+ return completeRawPublicKey(current, currentSize);
+ case PK15StateNeedRawCertificate:
+ return completeRawCertificate(current, currentSize);
+ case PK15StateComplete:
+ return CKYSUCCESS;
+ }
+
+ if (current == NULL) { return CKYINVALIDARGS; }
+
+ objectTag = current[0];
+
+ setAttributeBool(CKA_TOKEN, TRUE);
+
+ /* set type specific attributes */
+ switch (p15Type) {
+ case PK15Cert:
+ setAttributeULong(CKA_CLASS, CKO_CERTIFICATE);
+ setAttributeULong(CKA_CERTIFICATE_TYPE, CKC_X_509);
+ if (objectTag != PK15X509CertType) {
+ return CKYUNSUPPORTED;
+ }
+ break;
+ case PK15PvKey:
+ setAttributeULong(CKA_CLASS, CKO_PRIVATE_KEY);
+ goto set_key_type;
+ case PK15PuKey:
+ setAttributeULong(CKA_CLASS, CKO_PUBLIC_KEY);
+set_key_type:
+ switch (objectTag) {
+ case PK15RSAKeyType:
+ keyType = rsa;
+ setAttributeULong(CKA_KEY_TYPE, CKK_RSA);
+ break;
+ case PK15ECCKeyType:
+ keyType = ecc;
+ setAttributeULong(CKA_KEY_TYPE, CKK_EC);
+ break;
+ case PK15DSAKeyType:
+ case PK15DHKeyType:
+ default:
+ return CKYUNSUPPORTED;
+ }
+ break;
+ case PK15AuthObj:
+ setAttributeULong(CKA_CLASS, CKO_DATA);
+ break;
+ default:
+ return CKYUNSUPPORTED;
+ }
+
+ /* unwrap the object */
+ current = dataStart(current, currentSize, &currentSize, false);
+ if (current == NULL) { return CKYINVALIDDATA; }
+
+ /*
+ * parse the Common Attributes
+ * label UTF8_STRING
+ * flags BIT_STRING (optional)
+ * authid OCTET_STRING (optional)
+ */
+ if ((current == NULL) || (current[0] != ASN1_SEQUENCE))
+ { return CKYINVALIDDATA; }
+ /* unwrap */
+ commonAttributes = dataStart(current, currentSize, &commonSize, false);
+ if (commonAttributes == NULL) { return CKYINVALIDDATA; }
+
+ /* point current to the next section (cass attributes) */
+ tagSize = commonAttributes - current;
+ current += commonSize + tagSize;
+ currentSize -= (commonSize +tagSize);
+ if (currentSize < 0) { return CKYINVALIDDATA; }
+
+ /* get the CKA_LABEL */
+ if (commonAttributes[0] != ASN1_UTF8_STRING) { return CKYINVALIDDATA; }
+ entry = dataStart(commonAttributes, commonSize, &entrySize, false);
+ if (entry == NULL) { return CKYINVALIDARGS; }
+ tagSize = entry - commonAttributes;
+ commonAttributes += entrySize + tagSize;
+ commonSize -= (entrySize +tagSize);
+ setAttribute(CKA_LABEL, entry, entrySize);
+
+ /* parse optional flags */
+ bits = BROKEN_FLAG;
+ if (commonAttributes[0] == ASN1_BIT_STRING) {
+ entry = dataStart(commonAttributes, commonSize, &entrySize, false);
+ if (entry == NULL) { return CKYINVALIDARGS; }
+ tagSize = entry - commonAttributes;
+ commonAttributes += entrySize + tagSize;
+ commonSize -= (entrySize +tagSize);
+ bits = GetBits(entry,entrySize,2,1);
+ }
+
+ if (commonAttributes[0] == ASN1_OCTET_STRING) {
+ entry = dataStart(commonAttributes, commonSize, &entrySize, false);
+ if (entry == NULL) { return CKYINVALIDARGS; }
+ tagSize = entry - commonAttributes;
+ commonAttributes += entrySize + tagSize;
+ commonSize -= (entrySize +tagSize);
+ status = CKYBuffer_Replace(&authId, 0, entry, entrySize);
+ if (status != CKYSUCCESS) {
+ return status;
+ }
+ }
+
+ if (bits & BROKEN_FLAG) {
+ bits = defaultCommonBits();
+ }
+ setAttributeBool(CKA_PRIVATE,
+ (bits & P15FlagsPrivate) ? TRUE: FALSE);
+ setAttributeBool(CKA_MODIFIABLE, FALSE); /* our token is ReadOnly, so the
+ * object is never modifiable for
+ * us */
+ /* future common attributes here */
+
+ /*
+ * Parse Class variables
+ *
+ */
+ switch (p15Type) {
+ case PK15Cert:
+ status = completeCertObject(current,currentSize);
+ break;
+ case PK15PuKey:
+ case PK15PvKey:
+ status = completeKeyObject(current,currentSize);
+ break;
+ case PK15AuthObj:
+ status = completeAuthObject(current, currentSize);
+ break;
+ }
+ return status;
+}
+
+
+CKYStatus
+PK15Object::completeCertObject(const CKYByte *current, CKYSize currentSize)
+{
+ const CKYByte *commonCertAttributes;
+ CKYSize commonSize;
+ const CKYByte *entry;
+ CKYSize entrySize;
+ CKYSize tagSize;
+ CKYBuffer empty;
+ CKYStatus status;
+ CKYByte valueTag;
+
+ CKYBuffer_InitEmpty(&empty);
+
+ /*
+ * parse the Common Cert Attributes
+ * id OCTET_STRING
+ * authority BOOLEAN DEFAULT FALSE
+ * requestId BIT_STRING (optional)
+ * thumbprint [0] PKS15OOBCertHash (optional)
+ */
+ if ((current == NULL) || (current[0] != ASN1_SEQUENCE))
+ { return CKYINVALIDARGS; }
+ /* unwrap */
+ commonCertAttributes = dataStart(current, currentSize, &commonSize, false);
+ if (commonCertAttributes == NULL) { return CKYINVALIDDATA; }
+ /* point current to the next section (type attributes) */
+ tagSize = commonCertAttributes - current;
+ current += commonSize + tagSize;
+ currentSize -= (commonSize +tagSize);
+ if (currentSize < 0) { return CKYINVALIDDATA; }
+
+ /* get the id */
+ if (commonCertAttributes[0] != ASN1_OCTET_STRING) { return CKYINVALIDDATA; }
+ entry = dataStart(commonCertAttributes, commonSize, &entrySize, false);
+ if (entry == NULL) { return CKYINVALIDARGS; }
+ tagSize = entry - commonCertAttributes;
+ commonCertAttributes += entrySize + tagSize;
+ commonSize -= (entrySize +tagSize);
+ setAttribute(CKA_ID, entry, entrySize);
+
+
+ /* skip authority (currently unused) */
+ /* skip requestID */
+ /* skip thumbprint */
+ /* future common cert attributes here */
+
+ /* certs have not subclass attributes ASN1_CHOICE_0 */
+
+ /* handle the X509 type attributes */
+ if (current[0] != ASN1_CHOICE_1) { return CKYINVALIDDATA; }
+ /* unwrap */
+ commonCertAttributes = dataStart(current, currentSize, &commonSize, false);
+ if (commonCertAttributes == NULL) { return CKYINVALIDDATA; }
+
+ /*
+ * PCKS11X504CertificateAttributes
+ * value SEQUENCE or CHOICE_0
+ * ... don't care about the rest.
+ */
+ valueTag = commonCertAttributes[0];
+ /* unwrapp */
+ entry = dataStart(commonCertAttributes, commonSize, &entrySize, false);
+ if (entry == NULL) { return CKYINVALIDDATA; }
+ if (valueTag == ASN1_SEQUENCE) {
+ entry = dataStart(entry, entrySize, &entrySize, false);
+ if (entry == NULL) { return CKYINVALIDDATA; }
+ /* if we have a path, the actual object is in another file,
+ * tell the caller to get it and come back here */
+ status = objectPath.setObjectPath(entry, entrySize);
+ state = PK15StateNeedRawCertificate;
+ return status;
+ }
+ if (valueTag != ASN1_CHOICE_0) {
+ return CKYINVALIDDATA;
+ }
+ return completeRawCertificate(entry, entrySize);
+}
+
+CKYStatus
+PK15Object::completeAuthObject(const CKYByte *current, CKYSize currentSize)
+{
+ const CKYByte *commonAuthAttributes;
+ CKYSize commonSize;
+ const CKYByte *entry;
+ CKYSize entrySize;
+ CKYSize tagSize;
+ CKYBuffer empty;
+ CKYStatus status;
+
+ CKYBuffer_InitEmpty(&empty);
+
+ if (current == NULL) { return CKYINVALIDARGS; }
+ /* common Auth attributes */
+ if (current[0] == ASN1_SEQUENCE) {
+ /* unwrap */
+ commonAuthAttributes =
+ dataStart(current, currentSize, &commonSize, false);
+ if (commonAuthAttributes == NULL) { return CKYINVALIDDATA; }
+ tagSize = commonAuthAttributes - current;
+ current += commonSize + tagSize;
+ currentSize -= (commonSize + tagSize);
+ if (currentSize < 0) { return CKYINVALIDDATA; }
+ if (commonAuthAttributes[0] != ASN1_OCTET_STRING) {
+ return CKYINVALIDDATA;
+ }
+ entry = dataStart(commonAuthAttributes, commonSize, &entrySize, false);
+ if (entry == NULL) { return CKYINVALIDARGS; }
+ tagSize = entry - commonAuthAttributes;
+ commonAuthAttributes += entrySize + tagSize;
+ commonSize -= (entrySize +tagSize);
+ status = CKYBuffer_Replace(&pinAuthId, 0, entry, entrySize);
+ if (status != CKYSUCCESS) {
+ return status;
+ }
+
+ }
+ /* auth specific values */
+ if (current[0] != ASN1_CHOICE_1) { return CKYINVALIDARGS; }
+ /* unwrap */
+ commonAuthAttributes = dataStart(current, currentSize, &commonSize, false);
+ if (commonAuthAttributes == NULL) { return CKYINVALIDDATA; }
+ tagSize = commonAuthAttributes - current;
+ current += commonSize + tagSize;
+ currentSize -= (commonSize +tagSize);
+ if (currentSize < 0) { return CKYINVALIDDATA; }
+ /*
+ * parse the Pin Auth Attributes
+ * pinFlags BIT_STRING
+ * pinType ENUMERATED (bcd, ascii-numeric, utf8)
+ * minLength INTEGER
+ * storedLength INTEGER
+ * maxlength INTEGER (optional)
+ * pinReference CHOICE_0 (optional)
+ * padChar OCTET_STRING (optional)
+ * lastPinChange GENERALIZED_TIME (optional)
+ * path PKCS15Path (optional)
+ */
+ if (commonAuthAttributes[0] != ASN1_SEQUENCE) { return CKYINVALIDARGS; }
+ commonAuthAttributes = dataStart(commonAuthAttributes,
+ commonSize, &commonSize, false);
+ if (commonAuthAttributes == NULL) { return CKYINVALIDDATA; }
+
+ /* parse pin flags */
+ if (commonAuthAttributes[0] != ASN1_BIT_STRING) { return CKYINVALIDDATA; }
+
+ entry = dataStart(commonAuthAttributes, commonSize, &entrySize, false);
+ if (entry == NULL) { return CKYINVALIDARGS; }
+ tagSize = entry - commonAuthAttributes;
+ commonAuthAttributes += entrySize + tagSize;
+ commonSize -= (entrySize +tagSize);
+ pinInfo.pinFlags = GetBits(entry,entrySize,9,2);
+
+
+ /* parse PinType */
+ if (commonAuthAttributes[0] != ASN1_ENUMERATED) { return CKYINVALIDDATA; }
+ entry = dataStart(commonAuthAttributes, commonSize, &entrySize, false);
+ if (entry == NULL) { return CKYINVALIDARGS; }
+ tagSize = entry - commonAuthAttributes;
+ commonAuthAttributes += entrySize + tagSize;
+ commonSize -= (entrySize +tagSize);
+ /* turn entry into an int */
+ if (entrySize > 1) { return CKYINVALIDARGS; }
+ pinInfo.pinType = (P15PinType) *entry;
+
+ /* parse minLength */
+ if (commonAuthAttributes[0] != ASN1_INTEGER) { return CKYINVALIDDATA; }
+ entry = dataStart(commonAuthAttributes, commonSize, &entrySize, false);
+ if (entry == NULL) { return CKYINVALIDARGS; }
+ tagSize = entry - commonAuthAttributes;
+ commonAuthAttributes += entrySize + tagSize;
+ commonSize -= (entrySize +tagSize);
+ if (entrySize > 1) { return CKYINVALIDARGS; }
+ pinInfo.minLength = *entry;
+
+ /* parse storedLength */
+ if (commonAuthAttributes[0] != ASN1_INTEGER) { return CKYINVALIDDATA; }
+ entry = dataStart(commonAuthAttributes, commonSize, &entrySize, false);
+ if (entry == NULL) { return CKYINVALIDARGS; }
+ tagSize = entry - commonAuthAttributes;
+ commonAuthAttributes += entrySize + tagSize;
+ commonSize -= (entrySize +tagSize);
+ if (entrySize > 1) { return CKYINVALIDARGS; }
+ pinInfo.storedLength = *entry;
+
+ /* parse maxLength (optional) */
+ if (commonAuthAttributes[0] == ASN1_INTEGER) {
+ unsigned long maxPin;
+ entry = dataStart(commonAuthAttributes, commonSize, &entrySize, false);
+ if (entry == NULL) { return CKYINVALIDARGS; }
+ tagSize = entry - commonAuthAttributes;
+ commonAuthAttributes += entrySize + tagSize;
+ commonSize -= (entrySize +tagSize);
+ if (entrySize > sizeof (maxPin)) { return CKYINVALIDARGS; }
+ maxPin = 0;
+ CKYSize i;
+ for (i=0; i < entrySize; i++) {
+ maxPin = (maxPin << 8) | entry[i];
+ }
+ pinInfo.maxLength = maxPin;
+ }
+
+ /* parse pin ref (optional) */
+ if ((commonAuthAttributes[0]|ASN1_CONSTRUCTED) == ASN1_CHOICE_0) {
+ CKYByte pinRef;
+ entry = dataStart(commonAuthAttributes, commonSize, &entrySize, false);
+ if (entry == NULL) { return CKYINVALIDARGS; }
+ tagSize = entry - commonAuthAttributes;
+ commonAuthAttributes += entrySize + tagSize;
+ commonSize -= (entrySize +tagSize);
+ if (entrySize > 2) { return CKYINVALIDARGS; }
+ if (entrySize == 2) {
+ if (*entry != 0) { return CKYINVALIDARGS; }
+ pinRef = entry[1];
+ } else pinRef = entry[0];
+ pinInfo.pinRef = pinRef;
+ }
+
+ /* parse padChar */
+ if (commonAuthAttributes[0] == ASN1_OCTET_STRING) {
+ entry = dataStart(commonAuthAttributes, commonSize, &entrySize, false);
+ if (entry == NULL) { return CKYINVALIDARGS; }
+ tagSize = entry - commonAuthAttributes;
+ commonAuthAttributes += entrySize + tagSize;
+ commonSize -= (entrySize +tagSize);
+ if (entrySize > 1) { return CKYINVALIDARGS; }
+ pinInfo.padChar = *entry;
+ }
+
+ /* skip lastPinChange */
+ if (commonAuthAttributes[0] == ASN1_GENERALIZED_TIME) {
+ entry = dataStart(commonAuthAttributes, commonSize, &entrySize, false);
+ if (entry == NULL) { return CKYINVALIDARGS; }
+ tagSize = entry - commonAuthAttributes;
+ commonAuthAttributes += entrySize + tagSize;
+ commonSize -= (entrySize +tagSize);
+ }
+ /* parse path */
+ if (commonAuthAttributes[0] == ASN1_SEQUENCE) {
+ entry = dataStart(commonAuthAttributes, commonSize,
+ &entrySize, false);
+ if (entry == NULL) { return CKYINVALIDARGS; }
+ tagSize = entry - commonAuthAttributes;
+ commonAuthAttributes += entrySize + tagSize;
+ commonSize -= (entrySize +tagSize);
+ /* if we have a path, the actual object is in another file,
+ * tell the caller to get it and come back here */
+ status = objectPath.setObjectPath(entry, entrySize);
+ if (status != CKYSUCCESS) { return status; }
+ }
+ state = PK15StateComplete;
+ return CKYSUCCESS;
+}
+
+CKYStatus
+PK15Object::completeKeyObject(const CKYByte *current, CKYSize currentSize)
+{
+ const CKYByte *commonKeyAttributes;
+ CKYSize commonSize;
+ const CKYByte *entry;
+ CKYSize entrySize;
+ CKYSize tagSize;
+ CKYBuffer empty;
+ CKYStatus status;
+ unsigned long bits;
+ /*bool native; */
+
+ CKYBuffer_InitEmpty(&empty);
+ /*
+ * parse the Common Key Attributes
+ * id OCTET_STRING
+ * usageFlags BIT_STRING
+ * native BOOLEAN DEFAULT TRUE
+ * accessFlags BIT_STRING (optional)
+ * keyReference OCTET_STRING (optional)
+ * startDate GENERALIZED_TIME (optional)
+ * endDate [0] GENERALIZED_TYPE (optional)
+ */
+ if ((current == NULL) || (current[0] != ASN1_SEQUENCE))
+ { return CKYINVALIDARGS; }
+ /* unwrap */
+ commonKeyAttributes = dataStart(current, currentSize, &commonSize, false);
+ if (commonKeyAttributes == NULL) { return CKYINVALIDDATA; }
+
+ /* point current to the next section (sublcass attributes) */
+ tagSize = commonKeyAttributes - current;
+ current += commonSize + tagSize;
+ currentSize -= (commonSize +tagSize);
+ if (currentSize < 0) { return CKYINVALIDDATA; }
+
+ /* get the id */
+ if (commonKeyAttributes[0] != ASN1_OCTET_STRING) { return CKYINVALIDDATA; }
+ entry = dataStart(commonKeyAttributes, commonSize, &entrySize, false);
+ if (entry == NULL) { return CKYINVALIDARGS; }
+ tagSize = entry - commonKeyAttributes;
+ commonKeyAttributes += entrySize + tagSize;
+ commonSize -= (entrySize +tagSize);
+ setAttribute(CKA_ID, entry, entrySize);
+
+ /* parse flags */
+ if (commonKeyAttributes[0] != ASN1_BIT_STRING) { return CKYINVALIDDATA; }
+ entry = dataStart(commonKeyAttributes, commonSize, &entrySize, false);
+ if (entry == NULL) { return CKYINVALIDARGS; }
+ tagSize = entry - commonKeyAttributes;
+ commonKeyAttributes += entrySize + tagSize;
+ commonSize -= (entrySize +tagSize);
+ bits = GetBits(entry,entrySize,10,2);
+ if (bits & BROKEN_FLAG) {
+ bits = defaultUsageBits();
+ }
+ setAttributeBool(CKA_ENCRYPT,
+ (bits & P15UsageEncrypt) ? TRUE : FALSE);
+ setAttributeBool(CKA_DECRYPT,
+ (bits & P15UsageDecrypt) ? TRUE : FALSE);
+ setAttributeBool(CKA_SIGN,
+ (bits & P15UsageSign) ? TRUE : FALSE);
+ setAttributeBool(CKA_SIGN_RECOVER,
+ (bits & P15UsageSignRecover) ? TRUE : FALSE);
+ setAttributeBool(CKA_WRAP,
+ (bits & P15UsageWrap) ? TRUE : FALSE);
+ setAttributeBool(CKA_UNWRAP,
+ (bits & P15UsageUnwrap) ? TRUE : FALSE);
+ setAttributeBool(CKA_VERIFY,
+ (bits & P15UsageVerify) ? TRUE : FALSE);
+ setAttributeBool(CKA_VERIFY_RECOVER,
+ (bits & P15UsageVerifyRecover) ? TRUE : FALSE);
+ setAttributeBool(CKA_DERIVE,
+ (bits & P15UsageDerive) ? TRUE : FALSE);
+ /* no CKA value for P15UsageNonRepudiation */
+ if (bits & P15UsageNonRepudiation) {
+ /* set signing and sign recover. Non-repudiation keys are automatically
+ * signing keys */
+ setAttributeBool(CKA_SIGN, TRUE);
+ if (keyType == rsa) {
+ setAttributeBool(CKA_SIGN_RECOVER, TRUE);
+ }
+ }
+
+ /* parse native (currently unused) */
+ /*native=true; */
+ if (commonKeyAttributes[0] == ASN1_BOOLEAN) {
+ entry = dataStart(commonKeyAttributes, commonSize, &entrySize, false);
+ if (entry == NULL) { return CKYINVALIDARGS; }
+ tagSize = entry - commonKeyAttributes;
+ commonKeyAttributes += entrySize + tagSize;
+ commonSize -= (entrySize +tagSize);
+ /*if ((entrySize == 1) && (entry[0] == 0)) {
+ native = false;
+ } */
+ }
+ /* parse access flags */
+ bits = BROKEN_FLAG;
+ if (commonKeyAttributes[0] == ASN1_BIT_STRING) {
+ entry = dataStart(commonKeyAttributes, commonSize, &entrySize, false);
+ if (entry == NULL) { return CKYINVALIDARGS; }
+ tagSize = entry - commonKeyAttributes;
+ commonKeyAttributes += entrySize + tagSize;
+ commonSize -= (entrySize +tagSize);
+ bits = GetBits(entry,entrySize,4,1);
+ }
+ if (bits & BROKEN_FLAG) {
+ bits = defaultAccessBits();
+ }
+ setAttributeBool(CKA_SENSITIVE,
+ (bits & P15AccessSensitive) ? TRUE : FALSE);
+ setAttributeBool(CKA_EXTRACTABLE,
+ (bits & P15AccessExtractable) ? TRUE : FALSE);
+ setAttributeBool(CKA_ALWAYS_SENSITIVE,
+ (bits & P15AccessAlwaysSenstive) ? TRUE : FALSE);
+ setAttributeBool(CKA_NEVER_EXTRACTABLE,
+ (bits & P15AccessNeverExtractable)? TRUE : FALSE);
+ setAttributeBool(CKA_LOCAL,
+ (bits & P15AccessLocal) ? TRUE : FALSE);
+
+ /* parse the key reference */
+ keyRef = PK15_INVALID_KEY_REF; /* invalid keyRef */
+ if (commonKeyAttributes[0] == ASN1_INTEGER) {
+ entry = dataStart(commonKeyAttributes, commonSize, &entrySize, false);
+ if (entry == NULL) { return CKYINVALIDARGS; }
+ tagSize = entry - commonKeyAttributes;
+ commonKeyAttributes += entrySize + tagSize;
+ commonSize -= (entrySize +tagSize);
+ if (entrySize == 1) {
+ keyRef = entry[0];
+ } else if ((entrySize == 2) && (entry[0] == 0)) {
+ keyRef = entry[1];
+ }
+ }
+ setAttribute(CKA_START_DATE, &empty);
+ if (commonKeyAttributes[0] == ASN1_GENERALIZED_TIME) {
+ entry = dataStart(commonKeyAttributes, commonSize, &entrySize, false);
+ if (entry == NULL) { return CKYINVALIDARGS; }
+ tagSize = entry - commonKeyAttributes;
+ commonKeyAttributes += entrySize + tagSize;
+ commonSize -= (entrySize +tagSize);
+ setAttribute(CKA_START_DATE,entry, entrySize);
+ }
+ setAttribute(CKA_END_DATE, &empty);
+ if (commonKeyAttributes[0] == ASN1_CHOICE_0) {
+ entry = dataStart(commonKeyAttributes, commonSize, &entrySize, false);
+ if (entry == NULL) { return CKYINVALIDARGS; }
+ tagSize = entry - commonKeyAttributes;
+ commonKeyAttributes += entrySize + tagSize;
+ commonSize -= (entrySize +tagSize);
+ setAttribute(CKA_END_DATE,entry, entrySize);
+ }
+ /* future common key attributes here */
+
+ /*
+ * Parse Class variables
+ *
+ */
+ switch (p15Type) {
+ case PK15PuKey:
+ status = completePubKeyObject(current,currentSize);
+ break;
+ case PK15PvKey:
+ status = completePrivKeyObject(current,currentSize);
+ break;
+ default:
+ status=CKYLIBFAIL; /* shouldn't happen */
+ break;
+ }
+ return status;
+}
+
+CKYStatus PK15Object::completePrivKeyObject(const CKYByte *current,
+ CKYSize currentSize)
+{
+ const CKYByte *commonPrivKeyAttributes;
+ CKYSize commonSize;
+ const CKYByte *entry;
+ CKYSize entrySize;
+ CKYSize tagSize;
+ CKYBuffer empty;
+ CKYStatus status;
+ unsigned int modulusSize;
+ unsigned int i;
+
+ CKYBuffer_InitEmpty(&empty);
+ if (current == NULL) { return CKYINVALIDARGS; }
+
+ /* optional subclass = CommonPrivateKeyAttributes */
+ if (current[0] == ASN1_CHOICE_0) {
+ /*
+ * PKCS15CommonPrivateKeyAttributes
+ *
+ * subjectName SEQUENCE optional
+ * keyIdentifiers CHOICE 0 optional
+ */
+ /* unwrap */
+ commonPrivKeyAttributes =
+ dataStart(current, currentSize, &commonSize, false);
+ if (commonPrivKeyAttributes == NULL) { return CKYINVALIDDATA; }
+ /* point current to the next section (type attributes) */
+ tagSize = commonPrivKeyAttributes - current;
+ current += commonSize + tagSize;
+ currentSize -= (commonSize +tagSize);
+ if (currentSize < 0) { return CKYINVALIDDATA; }
+
+ /* subjectName */
+ if (commonPrivKeyAttributes[0] == ASN1_SEQUENCE) {
+ entry = dataStart(commonPrivKeyAttributes, commonSize,
+ &entrySize, false);
+ if (entry == NULL) { return CKYINVALIDARGS; }
+ tagSize = entry - commonPrivKeyAttributes;
+ commonPrivKeyAttributes += entrySize + tagSize;
+ commonSize -= (entrySize +tagSize);
+ setAttribute(CKA_SUBJECT, entry, entrySize);
+ }
+
+ /* keyIdentfiers */
+ /* future CommonPrivateKeyAttributes here */
+ }
+
+
+ /* Type attributes (either PKCS15RSAPrivateKeyAttributes or
+ * PKCS15ECCPrivateKeyAttributes) -- Not Optional */
+ if (current[0] != ASN1_CHOICE_1) { return CKYINVALIDDATA; }
+ /*
+ * PKCS15RSAPrivateKeyAttributes
+ * value PKCS15ObjectValue
+ * modulusLength INTEGER
+ * keyInfo SEQUENCE optional
+ * PKCS15ECCPrivateKeyAttributes
+ * value PKCS15ObjectValue
+ * keyInfo SEQUENCE optional
+ */
+ /* unwrap */
+ commonPrivKeyAttributes =
+ dataStart(current, currentSize, &commonSize, false);
+ if (commonPrivKeyAttributes == NULL) { return CKYINVALIDDATA; }
+
+ /* value */
+ /* don't support direct private key objects */
+ if (commonPrivKeyAttributes[0] == ASN1_CHOICE_0) { return CKYUNSUPPORTED; }
+ if (commonPrivKeyAttributes[0] != ASN1_SEQUENCE) { return CKYINVALIDDATA; }
+ commonPrivKeyAttributes = dataStart(commonPrivKeyAttributes, commonSize, &commonSize, false);
+ if (commonPrivKeyAttributes == NULL) { return CKYINVALIDARGS; }
+ entry = dataStart(commonPrivKeyAttributes, commonSize, &entrySize, false);
+ if (entry == NULL) { return CKYINVALIDARGS; }
+ tagSize = entry - commonPrivKeyAttributes;
+ commonPrivKeyAttributes += entrySize + tagSize;
+ commonSize -= (entrySize +tagSize);
+ /* if we have a path, the actual object is in another file,
+ * tell the caller to get it and come back here */
+ status = objectPath.setObjectPath(entry, entrySize);
+ if (status != CKYSUCCESS) { return status; }
+
+ /* parse modulus size */
+ if ((keyType == rsa) && commonPrivKeyAttributes[0] == ASN1_INTEGER) {
+ entry = dataStart(commonPrivKeyAttributes, commonSize,
+ &entrySize, false);
+ if (entry == NULL) { return CKYINVALIDARGS; }
+ tagSize = entry - commonPrivKeyAttributes;
+ commonPrivKeyAttributes += entrySize + tagSize;
+ commonSize -= (entrySize +tagSize);
+ if (entrySize > 4) {
+ return CKYINVALIDDATA;
+ }
+ for (modulusSize = 0, i=0; i < entrySize; i++) {
+ modulusSize = (modulusSize << 8) + entry[i];
+ }
+ setKeySize(modulusSize);
+ }
+
+ if (keyType == rsa) {
+ state = PK15StateComplete;
+ return CKYSUCCESS; /* we're done with RSA */
+ }
+
+ /* parse keyinfo at this point all we are after is the EC_PARAM*/
+ if (commonPrivKeyAttributes[0] == ASN1_SEQUENCE) {
+ /* unwrap */
+ commonPrivKeyAttributes = dataStart(commonPrivKeyAttributes,
+ commonSize, &commonSize, true);
+ if (commonPrivKeyAttributes == NULL) { return CKYINVALIDDATA; }
+ if (commonPrivKeyAttributes[0] == ASN1_SEQUENCE) {
+ entry = dataStart(commonPrivKeyAttributes, commonSize,
+ &entrySize, true);
+ if (entry == NULL) { return CKYINVALIDDATA; }
+ setAttribute(CKA_EC_PARAMS, entry, entrySize);
+ }
+ }
+ state = PK15StateComplete;
+ return CKYSUCCESS;
+}
+
+CKYStatus
+PK15Object::completePubKeyObject(const CKYByte *current, CKYSize currentSize)
+{
+ const CKYByte *commonPubKeyAttributes;
+ CKYSize commonSize;
+ const CKYByte *entry;
+ CKYSize entrySize;
+ CKYSize tagSize;
+ CKYBuffer empty;
+ CKYStatus status;
+ unsigned int modulusSize;
+ unsigned int i;
+
+ CKYBuffer_InitEmpty(&empty);
+ if (current == NULL) { return CKYINVALIDDATA; }
+
+ /* optional subclass = CommonPublicKeyAttributes */
+ if (current[0] == ASN1_CHOICE_0) {
+ /*
+ * PKCS15CommonPublicKeyAttributes
+ *
+ * subjectName SEQUENCE optional
+ * keyIdentifiers CHOICE 0 optional
+ */
+ /* unwrap */
+ commonPubKeyAttributes =
+ dataStart(current, currentSize, &commonSize, false);
+ if (commonPubKeyAttributes == NULL) { return CKYINVALIDDATA; }
+ /* point current to the next section (type attributes) */
+ tagSize = commonPubKeyAttributes - current;
+ current += commonSize + tagSize;
+ currentSize -= (commonSize +tagSize);
+ if (currentSize < 0) { return CKYINVALIDDATA; }
+
+ /* subjectName */
+ if (commonPubKeyAttributes[0] == ASN1_SEQUENCE) {
+ entry = dataStart(commonPubKeyAttributes, commonSize,
+ &entrySize, false);
+ if (entry == NULL) { return CKYINVALIDARGS; }
+ tagSize = entry - commonPubKeyAttributes;
+ commonPubKeyAttributes += entrySize + tagSize;
+ commonSize -= (entrySize +tagSize);
+ setAttribute(CKA_SUBJECT, entry, entrySize);
+ }
+ /* future CommonPublicKeyAttributes here */
+ }
+
+
+ /* Type attributes (either PKCS15RSAPublicKeyAttributes or
+ * PKCS15ECCPublicKeyAttributes) -- Not Optional */
+ if (current[0] != ASN1_CHOICE_1) { return CKYINVALIDDATA; }
+ /*
+ * PKCS15RSAPublicKeyAttributes
+ * value PKCS15ObjectValue
+ * modulusLength INTEGER
+ * keyInfo SEQUENCE optional
+ * PKCS15ECCPublicKeyAttributes
+ * value PKCS15ObjectValue
+ * keyInfo SEQUENCE optional
+ */
+ /* unwrap */
+ commonPubKeyAttributes =
+ dataStart(current, currentSize, &commonSize, false);
+ if (commonPubKeyAttributes == NULL) { return CKYINVALIDDATA; }
+
+ /* value */
+ if (commonPubKeyAttributes[0] == ASN1_CHOICE_0) {
+ entry = dataStart(commonPubKeyAttributes, commonSize,
+ &entrySize, false);
+ if (entry == NULL) { return CKYINVALIDARGS; }
+ status = completeRawPublicKey(entry, entrySize);
+ if (status != CKYSUCCESS) { return status; }
+ } else if (commonPubKeyAttributes[0] == ASN1_SEQUENCE) {
+ entry = dataStart(commonPubKeyAttributes, commonSize,
+ &entrySize, false);
+ if (entry == NULL) { return CKYINVALIDARGS; }
+ tagSize = entry - commonPubKeyAttributes;
+ commonPubKeyAttributes += entrySize + tagSize;
+ commonSize -= (entrySize +tagSize);
+ /* if we have a path, the actual object is in another file,
+ * tell the caller to get it and come back here */
+ status = objectPath.setObjectPath(entry, entrySize);
+ if (status != CKYSUCCESS) { return status; }
+ state = PK15StateNeedRawPublicKey;
+ }
+
+ /* parse modulus size */
+ if ((keyType == rsa) && commonPubKeyAttributes[0] == ASN1_INTEGER) {
+ entry = dataStart(commonPubKeyAttributes, commonSize,
+ &entrySize, false);
+ if (entry == NULL) { return CKYINVALIDARGS; }
+ tagSize = entry - commonPubKeyAttributes;
+ commonPubKeyAttributes += entrySize + tagSize;
+ commonSize -= (entrySize +tagSize);
+ if (entrySize > 4) {
+ return CKYINVALIDDATA;
+ }
+ for (modulusSize = 0, i=0; i < entrySize; i++) {
+ modulusSize = (modulusSize << 8) + entry[i];
+ }
+ setKeySize(modulusSize);
+ }
+
+ if (keyType == rsa) {
+ return CKYSUCCESS; /* we're done with RSA */
+ }
+
+ /* parse keyinfo at this point all we are after is the EC_PARAM*/
+ if (commonPubKeyAttributes[0] == ASN1_SEQUENCE) {
+ /* unwrap */
+ commonPubKeyAttributes = dataStart(commonPubKeyAttributes,
+ commonSize, &commonSize, true);
+ if (commonPubKeyAttributes == NULL) { return CKYINVALIDDATA; }
+ if (commonPubKeyAttributes[0] == ASN1_SEQUENCE) {
+ entry = dataStart(commonPubKeyAttributes, commonSize,
+ &entrySize, true);
+ if (entry == NULL) { return CKYINVALIDDATA; }
+ setAttribute(CKA_EC_PARAMS, entry, entrySize);
+ }
+ }
+ return CKYSUCCESS;
+
+}
+
+CKYStatus
+PK15Object::completeRawCertificate(const CKYByte *derCert, CKYSize derCertSize)
+{
+ SECStatus rv;
+ CCItem issuerItem, serialItem, derSerialItem, subjectItem,
+ validityItem, subjectKeyItem;
+ const char *certLabel;
+
+ setAttribute(CKA_VALUE, derCert, derCertSize);
+ rv = GetCertFieldItems(derCert, derCertSize,
+ &issuerItem, &serialItem, &derSerialItem, &subjectItem, &validityItem,
+ &subjectKeyItem);
+ if (rv != SECSuccess) {
+ return CKYINVALIDDATA;
+ }
+ setAttribute(CKA_SERIAL_NUMBER, derSerialItem.data, derSerialItem.len);
+ setAttribute(CKA_SUBJECT, subjectItem.data, subjectItem.len);
+ setAttribute(CKA_ISSUER, issuerItem.data, issuerItem.len);
+ CKYBuffer_Replace(&pubKey, 0, subjectKeyItem.data, subjectKeyItem.len);
+ /* if we didn't get a label, set one based on the CN */
+ certLabel = getLabel();
+ if ((certLabel == NULL) || (*certLabel == 0)) {
+ CKYBuffer subject;
+ char *newLabel;
+ CKYBuffer_InitFromData(&subject, subjectItem.data, subjectItem.len);
+ newLabel = GetUserName(&subject);
+ if (newLabel) {
+ setAttribute(CKA_LABEL, (CKYByte *)newLabel,
+ (CKYSize) strlen(newLabel)-1);
+ delete [] newLabel;
+ }
+ CKYBuffer_FreeData(&subject);
+ }
+ state = PK15StateComplete;
+ return CKYSUCCESS;
+}
+
+CKYStatus
+PK15Object::completeRawPublicKey(const CKYByte *current, CKYSize size)
+{
+ const CKYByte *entry;
+ CKYSize entrySize;
+ CKYSize tagSize;
+
+ if ((current == NULL) || (current[0] != ASN1_SEQUENCE)) {
+ return CKYINVALIDDATA;
+ }
+ /* unwrap*/
+ current = dataStart(current, size, &size, false);
+ if (current == NULL) { return CKYINVALIDDATA; }
+
+ /* modulus */
+ if (current[0] != ASN1_INTEGER) { return CKYINVALIDDATA; }
+ entry = dataStart(current, size, &entrySize, false);
+ if (entry == NULL) { return CKYINVALIDDATA; }
+ tagSize = entry - current;
+ current += entrySize + tagSize;
+ size -= (entrySize +tagSize);
+ if (size < 0) { return CKYINVALIDDATA; }
+ if ((entry[0] == 0) && (entrySize > 1)) {
+ entry++; entrySize--;
+ }
+ setAttribute(CKA_MODULUS, entry, entrySize);
+
+ /* exponent */
+ if (current[0] != ASN1_INTEGER) { return CKYINVALIDDATA; }
+ entry = dataStart(current, size, &entrySize, false);
+ if (entry == NULL) { return CKYINVALIDDATA; }
+ tagSize = entry - current;
+ current += entrySize + tagSize;
+ size -= (entrySize +tagSize);
+ if (size < 0) { return CKYINVALIDDATA; }
+ if ((entry[0] == 0) && (entrySize > 1)) {
+ entry++; entrySize--;
+ }
+ setAttribute(CKA_PUBLIC_EXPONENT, entry, entrySize);
+ state = PK15StateComplete;
+ return CKYSUCCESS;
+}
+
DEREncodedSignature::DEREncodedSignature(const CKYBuffer *derSig)
{
@@ -1483,9 +2585,9 @@ int DEREncodedSignature::getRawSignature
CKYBuffer_Zero(rawSig);
- unsigned int seq_length = 0;
- unsigned int expected_sig_len = ( (keySize + 7) / 8 ) * 2 ;
- unsigned int expected_piece_size = expected_sig_len / 2 ;
+ CKYSize seq_length = 0;
+ CKYSize expected_sig_len = ( (keySize + 7) / 8 ) * 2 ;
+ CKYSize expected_piece_size = expected_sig_len / 2 ;
/* unwrap the sequence */
buf = dataStart(CKYBuffer_Data(&derEncodedSignature), CKYBuffer_Size(&derEncodedSignature),&seq_length, false);
@@ -1494,7 +2596,7 @@ int DEREncodedSignature::getRawSignature
// unwrap first multi byte integer
- unsigned int int_length = 0;
+ CKYSize int_length = 0;
const CKYByte *int1Buf = NULL;
const CKYByte *int2Buf = NULL;
@@ -1525,7 +2627,7 @@ int DEREncodedSignature::getRawSignature
// unwrap second multi byte integer
- unsigned int second_int_length = 0;
+ CKYSize second_int_length = 0;
int2Buf = dataStart(buf, seq_length, &second_int_length, false);
@@ -1552,3 +2654,91 @@ int DEREncodedSignature::getRawSignature
return CKYSUCCESS;
}
+
+DEREncodedTokenInfo::DEREncodedTokenInfo(CKYBuffer *derTokenInfo)
+{
+ const CKYByte *current = CKYBuffer_Data(derTokenInfo);
+ const CKYByte *entry;
+ CKYSize size = CKYBuffer_Size(derTokenInfo);
+ CKYSize entrySize;
+ CKYSize tagSize;
+ /* set token name, etc */
+
+ version = -1;
+ CKYBuffer_InitEmpty(&serialNumber);
+ manufacturer = NULL;
+ tokenName = NULL;
+
+ if (current[0] != ASN1_SEQUENCE) {
+ return; /* just use the defaults */
+ }
+ /* unwrap */
+ current = dataStart(current, size, &size, false);
+ if (current == NULL) return;
+
+ /* parse the version */
+ if (current[0] != ASN1_INTEGER) { return; }
+ entry = dataStart(current, size, &entrySize, false);
+ if (entry == NULL) return;
+ tagSize = entry - current;
+ current += tagSize + entrySize;
+ size -= tagSize + entrySize;
+ if (entrySize < 1) {
+ version = *entry;
+ }
+ if (size < 0) return;
+
+ /* get the serial number */
+ if (current[0] != ASN1_OCTET_STRING) { return ; }
+ entry = dataStart(current, size, &entrySize, false);
+ if (entry == NULL) return;
+ tagSize = entry - current;
+ current += tagSize + entrySize;
+ size -= tagSize + entrySize;
+ CKYBuffer_Replace(&serialNumber, 0, entry, entrySize);
+ /* should we fake the cuid here? */
+
+ /* get the optional manufacture ID */
+ if (current[0] == ASN1_UTF8_STRING) {
+ entry = dataStart(current, size, &entrySize, false);
+ if (entry == NULL) return;
+ tagSize = entry - current;
+ current += tagSize + entrySize;
+ size -= tagSize + entrySize;
+ manufacturer = (char *)malloc(entrySize+1);
+ if (manufacturer) {
+ memcpy(manufacturer, entry, entrySize);
+ manufacturer[entrySize] = 0;
+ }
+ }
+
+ /* get the optional token name */
+ /* most choices are constructed,
+ * but this one isn't explicity add the flag */
+ if ((current[0]|ASN1_CONSTRUCTED) == ASN1_CHOICE_0) {
+ entry = dataStart(current, size, &entrySize, false);
+ if (entry == NULL) return;
+ tagSize = entry - current;
+ current += tagSize + entrySize;
+ size -= tagSize + entrySize;
+ tokenName = (char *)malloc(entrySize+1);
+ if (tokenName) {
+ memcpy(tokenName, entry, entrySize);
+ tokenName[entrySize] = 0;
+ }
+ }
+
+ /* parsing flags */
+ if (current[0] == ASN1_BIT_STRING) {
+ /* recordinfo parsing would go here */
+ unsigned long bits;
+ entry = dataStart(current, size, &entrySize, false);
+ if (entry == NULL) return;
+ tagSize = entry - current;
+ current += tagSize + entrySize;
+ size -= tagSize + entrySize;
+ bits = GetBits(entry, entrySize,8,2);
+ }
+ return;
+}
+
diff -up ./src/coolkey/object.h.p15 ./src/coolkey/object.h
--- ./src/coolkey/object.h.p15 2015-07-06 10:27:55.770827267 -0700
+++ ./src/coolkey/object.h 2015-07-06 10:27:55.785826984 -0700
@@ -27,6 +27,33 @@
using std::list;
+/*
+ * Sigh PKCS 15 is heavily ASN.1...
+ */
+const CKYByte ASN1_BOOLEAN = 0x01;
+const CKYByte ASN1_INTEGER = 0x02;
+const CKYByte ASN1_BIT_STRING = 0x03;
+const CKYByte ASN1_OCTET_STRING = 0x04;
+const CKYByte ASN1_ENUMERATED = 0x0a;
+const CKYByte ASN1_UTF8_STRING = 0x0c;
+const CKYByte ASN1_GENERALIZED_TIME = 0x18;
+const CKYByte ASN1_CONSTRUCTED = 0x20;
+const CKYByte ASN1_SEQUENCE = 0x30;
+const CKYByte ASN1_CHOICE_0 = 0xa0;
+const CKYByte ASN1_CHOICE_1 = 0xa1;
+const CKYByte ASN1_CHOICE_2 = 0xa2;
+const CKYByte ASN1_CHOICE_3 = 0xa3;
+
+const CKYBitFlags BROKEN_FLAG = 0x80000000;
+const unsigned int PK11_INVALID_KEY_REF = -1;
+
+const CKYByte PK15X509CertType = ASN1_SEQUENCE;
+const CKYByte PK15RSAKeyType = ASN1_SEQUENCE;
+const CKYByte PK15ECCKeyType = ASN1_CHOICE_0;
+const CKYByte PK15DHKeyType = ASN1_CHOICE_1;
+const CKYByte PK15DSAKeyType = ASN1_CHOICE_2;
+const CKYByte PK15KEAKeyType = ASN1_CHOICE_3;
+
class PKCS11Attribute {
private:
CK_ATTRIBUTE_TYPE type;
@@ -52,9 +79,30 @@ class PKCS11Attribute {
PKCS11Attribute() : type(0){ CKYBuffer_InitEmpty(&value); }
PKCS11Attribute(CK_ATTRIBUTE_TYPE type_, const CKYBuffer *value_)
: type(type_) { CKYBuffer_InitFromCopy(&value, value_); }
+ PKCS11Attribute(CK_ATTRIBUTE_TYPE type_, const CKYByte *data_,
+ CKYSize size_) : type(type_)
+ { CKYBuffer_InitFromData(&value, data_, size_); }
~PKCS11Attribute() { CKYBuffer_FreeData(&value); }
};
+class PK15ObjectPath {
+ private:
+ CKYBuffer path;
+ CKYOffset index;
+ CKYSize length;
+ public:
+ PK15ObjectPath() : index(0), length(0) { CKYBuffer_InitEmpty(&path); }
+ PK15ObjectPath(const PK15ObjectPath &cpy) :
+ index(cpy.index), length(cpy.length)
+ { CKYBuffer_InitFromCopy(&path, &cpy.path); }
+ ~PK15ObjectPath() { CKYBuffer_FreeData(&path); }
+ const CKYBuffer *getPath() const { return &path; }
+ CKYOffset getIndex() const { return index; }
+ CKYSize getLength() const { return length; }
+ CKYStatus setObjectPath(const CKYByte *entry, CKYSize size);
+};
+
+
class PKCS11Object {
public:
enum KeyType {
@@ -72,6 +120,8 @@ class PKCS11Object {
unsigned long muscleObjID;
CK_OBJECT_HANDLE handle;
char *label;
+ unsigned int keySize;
+ CK_USER_TYPE user;
void parseOldObject(const CKYBuffer *data);
void parseNewObject(const CKYBuffer *data);
@@ -82,19 +132,37 @@ class PKCS11Object {
protected :
char *name;
KeyType keyType;
+ unsigned int keyRef;
CKYBuffer pubKey;
+ CKYBuffer authId;
+ CKYBuffer pinAuthId;
+ PK15ObjectPath objectPath;
public:
PKCS11Object(unsigned long muscleObjID, CK_OBJECT_HANDLE handle);
PKCS11Object(unsigned long muscleObjID, const CKYBuffer *data,
CK_OBJECT_HANDLE handle);
- ~PKCS11Object() { delete label; delete name; CKYBuffer_FreeData(&pubKey);
- attributes.clear(); }
+ virtual ~PKCS11Object() { delete [] label; delete [] name;
+ CKYBuffer_FreeData(&pubKey); CKYBuffer_FreeData(&authId);
+ CKYBuffer_FreeData(&pinAuthId); attributes.clear(); }
PKCS11Object(const PKCS11Object& cpy) :
attributes(cpy.attributes), muscleObjID(cpy.muscleObjID),
- handle(cpy.handle), label(NULL), name(NULL), keyType(cpy.keyType) {
- CKYBuffer_InitFromCopy(&pubKey,&cpy.pubKey); }
+ handle(cpy.handle), label(NULL), keySize(cpy.keySize),
+ user(cpy.user), name(NULL), keyType(cpy.keyType), keyRef(cpy.keyRef),
+ objectPath(cpy.objectPath) {
+ /* label is just a cached value, don't need
+ * to copy it. */
+ if (cpy.name != NULL) {
+ int len = strlen(cpy.name);
+ name= new char [len+1];
+ if (name) {
+ memcpy(name,cpy.name,len+1);
+ }
+ }
+ CKYBuffer_InitFromCopy(&pubKey,&cpy.pubKey);
+ CKYBuffer_InitFromCopy(&authId,&cpy.authId);
+ CKYBuffer_InitFromCopy(&pinAuthId,&cpy.pinAuthId); }
unsigned long getMuscleObjID() const { return muscleObjID; }
@@ -107,6 +175,8 @@ class PKCS11Object {
void setAttribute(CK_ATTRIBUTE_TYPE type, const CKYBuffer *value);
void setAttribute(CK_ATTRIBUTE_TYPE type, const char *);
+ void setAttribute(CK_ATTRIBUTE_TYPE type, const CKYByte *data,
+ CKYSize size);
/* bools and ulongs are too close, don't abuse function overloading
* for these cases */
void setAttributeBool(CK_ATTRIBUTE_TYPE type, CK_BBOOL);
@@ -124,14 +194,21 @@ class PKCS11Object {
return &pubKey;
}
- KeyType getKeyType() const { return keyType;}
+ KeyType getKeyType(void) const { return keyType;}
+ unsigned int getKeySize(void) const { return keySize; }
+ unsigned int getKeyRef(void) const { return keyRef; }
+ CK_USER_TYPE getUser(void) const { return user; }
void setKeyType(KeyType theType) { keyType = theType; }
+ void setKeySize(unsigned int keySize_) { keySize = keySize_; }
+ const CKYBuffer *getAuthId(void) const { return &authId; }
+ const CKYBuffer *getPinAuthId(void) const { return &pinAuthId; }
+ const PK15ObjectPath &getObjectPath() const { return objectPath; }
+ void completeKey(const PKCS11Object &cert);
};
class Key : public PKCS11Object {
public:
Key(unsigned long muscleObjID, const CKYBuffer *data, CK_OBJECT_HANDLE handle);
- void completeKey(const PKCS11Object &cert);
};
class Cert : public PKCS11Object {
@@ -155,6 +232,84 @@ class CACCert : public PKCS11Object {
CACCert(CKYByte instance, const CKYBuffer *derCert);
};
+typedef enum { PK15StateInit, PK15StateNeedObject,
+ PK15StateNeedRawPublicKey,PK15StateNeedRawCertificate,
+ PK15StateComplete } PK15State;
+
+typedef enum {PK15PvKey, PK15PuKey, PK15Cert, PK15AuthObj} PK15ObjectType;
+const unsigned int PK15_INVALID_KEY_REF = -1;
+
+class PK15Object : public PKCS11Object {
+ private:
+ CKYByte instance;
+ PK15ObjectType p15Type;
+ PK15State state;
+ P15PinInfo pinInfo;
+
+ CKYStatus completeCertObject(const CKYByte *buf, CKYSize size);
+ CKYStatus completeAuthObject(const CKYByte *buf, CKYSize size);
+ CKYStatus completeKeyObject(const CKYByte *buf, CKYSize size);
+ CKYStatus completePrivKeyObject(const CKYByte *buf, CKYSize size);
+ CKYStatus completePubKeyObject(const CKYByte *buf, CKYSize size);
+ CKYStatus completeRawPublicKey(const CKYByte *buf, CKYSize size);
+ CKYStatus completeRawCertificate(const CKYByte *buf, CKYSize size);
+
+ CKYBitFlags defaultCommonBits() {
+ return ((p15Type == PK15PvKey) && (CKYBuffer_Size(&authId) != 0)) ?
+ P15FlagsPrivate : 0;
+ }
+ CKYBitFlags defaultUsageBits() {
+ CKYBitFlags sign, recover, encrypt;
+ switch (p15Type) {
+ case PK15PuKey:
+ sign = P15UsageVerify; recover = P15UsageVerifyRecover;
+ encrypt = P15UsageEncrypt;
+ break;
+ case PK15PvKey:
+ sign = P15UsageSign; recover = P15UsageSignRecover;
+ encrypt = P15UsageDecrypt;
+ break;
+ default:
+ sign = 0; recover = 0; encrypt = 0;
+ break;
+ }
+ switch(keyType) {
+ case rsa:
+ return sign | recover | encrypt;
+ case ecc:
+ return sign | P15UsageDerive;
+ default:
+ break;
+ }
+ return 0;
+ }
+ CKYBitFlags defaultAccessBits() {
+ switch (p15Type) {
+ case PK15PuKey:
+ return P15AccessExtractable | P15AccessLocal;
+ case PK15PvKey:
+ return P15AccessSensitive | P15AccessLocal;
+ default:
+ break;
+ }
+ return 0;
+ }
+ CKYBitFlags defaultPinBits() {
+ return ((p15Type == PK15AuthObj) ? P15PinInitialized : 0);
+ }
+
+ public:
+ PK15Object(CKYByte inst, PK15ObjectType type,
+ const CKYByte *derObject, CKYSize size);
+ CKYStatus completeObject(const CKYByte *data, CKYSize size);
+ PK15State getState(void) const { return state; }
+ bool isSO(void) const { return
+ (pinInfo.pinFlags & P15PinSOPin) ? true : false; }
+ bool isLocal(void) const { return
+ (pinInfo.pinFlags & P15PinLocal) ? true : false; }
+ const P15PinInfo *getPinInfo(void) const { return &pinInfo; }
+};
+
class Reader : public PKCS11Object {
public:
Reader(unsigned long muscleObjID, CK_OBJECT_HANDLE handle,
@@ -180,6 +335,21 @@ class DEREncodedSignature {
};
+class DEREncodedTokenInfo {
+public:
+ int version;
+ CKYBuffer serialNumber;
+ char *manufacturer;
+ char *tokenName;
+ public :
+ DEREncodedTokenInfo(CKYBuffer *derTokenInfo);
+ ~DEREncodedTokenInfo() {
+ CKYBuffer_FreeData(&serialNumber);
+ free(manufacturer);
+ free(tokenName);
+ }
+};
+
class AttributeMatch {
private:
@@ -202,6 +372,9 @@ makeLEUInt(const CKYBuffer *buf, unsigne
(b[offset+0] << 0) ;
}
+const CKYByte* dataStart(const CKYByte *buf, CKYSize length,
+ CKYSize *data_length, bool includeTag);
+
// fixed object ID constants
#define READER_ID 0x72300000 /* 'r0\0\0' */
#define COMBINED_ID 0x7a300000 /* 'z0\0\0' */
diff -up ./src/coolkey/pkcs11t.h.p15 ./src/coolkey/pkcs11t.h
--- ./src/coolkey/pkcs11t.h.p15 2015-07-06 10:27:55.770827267 -0700
+++ ./src/coolkey/pkcs11t.h 2015-07-06 10:29:32.293005407 -0700
@@ -274,6 +274,7 @@ typedef CK_ULONG CK_USER_TYPE;
#define CKU_SO 0
/* Normal user */
#define CKU_USER 1
+#define CKU_CONTEXT_SPECIFIC 2
/* CK_STATE enumerates the session states */
@@ -492,6 +493,9 @@ typedef CK_ULONG CK_ATTRIBUTE_T
#define CKA_RESET_ON_INIT 0x00000301
#define CKA_HAS_RESET 0x00000302
+/* new for v2.20 */
+#define CKA_ALWAYS_AUTHENTICATE 0x00000202
+
#define CKA_VENDOR_DEFINED 0x80000000
diff -up ./src/coolkey/slot.cpp.p15 ./src/coolkey/slot.cpp
--- ./src/coolkey/slot.cpp.p15 2015-07-06 10:27:55.782827040 -0700
+++ ./src/coolkey/slot.cpp 2015-07-06 10:27:55.786826965 -0700
@@ -54,6 +54,11 @@ const CKYByte ATR2[] =
{ 0x3B, 0x6F, 0x00, 0xFF, 0x52, 0x53, 0x41, 0x53, 0x65, 0x63, 0x75, 0x72,
0x49, 0x44, 0x28, 0x52, 0x29, 0x31, 0x30 };
+/* PKCS #15 AID */
+const CKYByte P15AID[] =
+{ 0xa0, 0, 0, 0, 0x63, 'P', 'K', 'C', 'S', '-', '1', '5'};
+
+
/* ECC curve information
* Provide information for the limited set of curves supported by our smart card(s).
@@ -405,19 +410,29 @@ SlotList::updateReaderList()
Slot::Slot(const char *readerName_, Log *log_, CKYCardContext* context_)
: log(log_), readerName(NULL), personName(NULL), manufacturer(NULL),
+ tokenManufacturer(NULL),
slotInfoFound(false), context(context_), conn(NULL), state(UNKNOWN),
isVersion1Key(false), needLogin(false), fullTokenName(false),
- mCoolkey(false), mOldCAC(false),mCACLocalLogin(false),
- pivContainer(-1), pivKey(-1), mECC(false),
+ mCoolkey(false), mOldCAC(false), mCACLocalLogin(false),
+ pivContainer(-1), pivKey(-1), mECC(false), p15aid(0), p15odfAddr(0),
+ p15tokenInfoAddr(0), p15Instance(0),
#ifdef USE_SHMEM
shmem(readerName_),
#endif
sessionHandleCounter(1), objectHandleCounter(1)
{
+ int i;
+
+ for (i=0; i < MAX_AUTH_USERS; i++) {
+ auth[i]=NULL;
+ }
tokenFWVersion.major = 0;
tokenFWVersion.minor = 0;
-
+ CKYBuffer_InitFromData(&p15AID, P15AID, sizeof(P15AID));
+ CKYBuffer_InitEmpty(&p15tokenInfo);
+ CKYBuffer_InitEmpty(&p15odf);
+ CKYBuffer_InitEmpty(&p15serialNumber);
try {
conn = CKYCardConnection_Create(context);
@@ -433,6 +448,8 @@ Slot::Slot(const char *readerName_, Log
loggedIn = false;
pinCache.invalidate();
pinCache.clearPin();
+ contextPinCache.invalidate();
+ contextPinCache.clearPin();
//readSlotInfo();
manufacturer = strdup("Unknown");
if (!manufacturer) {
@@ -515,12 +532,23 @@ Slot::~Slot()
if (manufacturer) {
free(manufacturer);
}
+ if (tokenManufacturer) {
+ free(tokenManufacturer);
+ }
CKYBuffer_FreeData(&nonce);
CKYBuffer_FreeData(&cardATR);
CKYBuffer_FreeData(&mCUID);
+ CKYBuffer_FreeData(&p15AID);
+ CKYBuffer_FreeData(&p15odf);
+ CKYBuffer_FreeData(&p15tokenInfo);
+ CKYBuffer_FreeData(&p15serialNumber);
for (int i=0; i < MAX_CERT_SLOTS; i++) {
CKYBuffer_FreeData(&cardAID[i]);
}
+ for (int i=0; i < MAX_AUTH_USERS; i++) {
+ if (auth[i]) delete auth[i];
+ auth[i]=NULL;
+ }
}
template <class C>
@@ -637,9 +665,10 @@ Slot::getPIVLoginType(void)
}
done:
CKYBuffer_FreeData(&buffer);
- return true;
+ return local;
}
+
void
Slot::connectToToken()
{
@@ -745,7 +774,7 @@ Slot::connectToToken()
/* CARD is a PIV card */
state |= PIV_CARD | APPLET_SELECTABLE | APPLET_PERSONALIZED;
isVersion1Key = 0;
- needLogin = 1;
+ needLogin = true;
mCoolkey = 0;
mOldCAC = 0;
mCACLocalLogin = getPIVLoginType();
@@ -757,12 +786,22 @@ Slot::connectToToken()
status = getCACAid();
if (status != CKYSUCCESS) {
log->log("CAC Select failed 0x%x\n", status);
- if (status == CKYSCARDERR) {
+ status = getP15Params();
+ if (status != CKYSUCCESS) {
+ if (status == CKYSCARDERR) {
log->log("Card Failure 0x%x\n",
CKYCardConnection_GetLastError(conn));
disconnect();
- }
- /* CARD is unknown */
+ }
+ /* CARD is unknown */
+ return;
+ }
+ /* enable PCKS 15 */
+ state |= P15_CARD | APPLET_SELECTABLE | APPLET_PERSONALIZED;
+ isVersion1Key = 0;
+ needLogin = false; /* get it from token info */
+ mCoolkey = 0;
+ mCACLocalLogin = false;
return;
}
state |= CAC_CARD | APPLET_SELECTABLE | APPLET_PERSONALIZED;
@@ -771,7 +810,7 @@ Slot::connectToToken()
* other apps may be running now, so resetting the cac is a bit
* unfriendly */
isVersion1Key = 0;
- needLogin = 1;
+ needLogin = true;
mCoolkey = 0;
mCACLocalLogin = false;
return;
@@ -841,6 +880,8 @@ Slot::invalidateLogin(bool hard)
} else {
loggedIn = false;
pinCache.invalidate();
+ contextPinCache.invalidate();
+ contextPinCache.clearPin();
if (hard) {
pinCache.clearPin();
}
@@ -951,6 +992,414 @@ done:
return status;
}
+CKYStatus Slot::getP15Params()
+{
+ CKYStatus status = CKYSCARDERR;
+ int i;
+ CKYISOStatus apduRC;
+
+ /* read the EF(DIR) */
+ status = CACApplet_SelectFile(conn, 0x2f00, &apduRC);
+ if (status == CKYSUCCESS) {
+ CKYBuffer record;
+
+ CKYBuffer_InitEmpty(&record);
+ /* dump it out */
+ for (i=1; i < 255; i++) {
+ status = P15Applet_ReadRecord(conn, i, 0, P15_READ_P1, 255,
+ &record, &apduRC);
+ if (status != CKYSUCCESS) {
+ log->log("EF(DIR) Read Record %d failed 0x%x apduRC=0x%x\n",
+ i, status, apduRC);
+ break;
+ }
+ }
+ CKYBuffer_FreeData(&record);
+ return CKYSCARDERR; /* don't yet support EF(DIR)*/
+
+ } else {
+ log->log("EF(DIR) Select failed 0x%x apduRC=0x%0x\n", status, apduRC);
+ p15aid = 0; /* use the default */
+ p15odfAddr=0x5031;
+ p15tokenInfoAddr=0x5032;
+ }
+
+ status = CKYApplet_SelectFile(conn, &p15AID, &apduRC);
+ if (status != CKYSUCCESS) {
+ log->log("DF(PKCS-15) select failed 0x%x apduRC=0x%0x\n", status,
+ apduRC);
+ return status;
+ }
+ status = P15Applet_SelectFile(conn, p15tokenInfoAddr, &apduRC);
+ if (status != CKYSUCCESS) {
+ log->log("EF(TokenInfo) select failed 0x%x apduRC=0x%0x\n", status,
+ apduRC);
+ return status;
+ }
+ /* dump it out */
+ CKYBuffer_Resize(&p15tokenInfo, 0);
+ status = P15Applet_ReadBinary(conn, 0, 0, 0, 0, &p15tokenInfo, &apduRC);
+ if (status != CKYSUCCESS) {
+ log->log("EF(TokenInfo) Read binary failed 0x%x apduRC=0x%x\n", status,
+ apduRC);
+ return status;
+ }
+ status = P15Applet_SelectFile(conn, p15odfAddr, &apduRC);
+ if (status != CKYSUCCESS) {
+ log->log("EF(ODF) select failed 0x%x apduRC=0x%0x\n", status,
+ apduRC);
+ return status;
+ }
+
+ CKYBuffer_Resize(&p15odf, 0);
+ status = P15Applet_ReadBinary(conn, 0, 0, 0, 0, &p15odf, &apduRC);
+ if (status != CKYSUCCESS) {
+ log->log("EF(ODF) Read binary failed 0x%x apduRC=0x%x\n", status,
+ apduRC);
+ return status;
+ }
+
+ return CKYSUCCESS;
+}
+
+CKYStatus
+Slot::readFromPath(const PK15ObjectPath &obj, CKYBuffer *file)
+{
+ CKYStatus status;
+ CKYISOStatus apduRC;
+ CKYSize bufSize;
+ CKYOffset index = obj.getIndex();
+ CKYSize length = obj.getLength();
+
+ CKYBuffer_Resize(file, 0);
+ status = selectPath(obj.getPath(), &apduRC);
+ if (status != CKYSUCCESS) {
+ return status;
+ }
+ status = P15Applet_ReadBinary(conn, index, 0, 0,
+ (length >= 256)?0:length, file, &apduRC);
+ if (status != CKYSUCCESS) {
+ return status;
+ }
+
+ /* if we asked for a specific length and got it, or we asked for
+ * an indeterminate length and got less than 256 bytes, then we
+ * got everything. */
+ bufSize = CKYBuffer_Size(file);
+ if ((length && (bufSize >= length)) || ((length == 0) && (bufSize < 256))) {
+ /* we've already got it all */
+ return status;
+ }
+ if (bufSize < 0x82) {
+ /* make sure we have enough bytes to handle the worst case ANS.1
+ * mistake */
+ return CKYINVALIDDATA;
+ }
+
+ if (length == 0) {
+ /* we don't yet know how long the length is, use the ASN.1 parser to
+ * find out. We lie to dataStart about actual size so that it won't
+ * fail since we know we don't have the whole buffer yet.*/
+ (void) dataStart(CKYBuffer_Data(file), 65535, &length, true);
+ }
+ if (length > 65535) {
+ return CKYINVALIDDATA;
+ }
+ while ((bufSize =CKYBuffer_Size(file)) < length) {
+ CKYSize tmpLength = length - bufSize;
+
+ if (tmpLength >= 256) tmpLength = 0;
+
+ status = P15Applet_ReadBinary(conn, (unsigned short)(index+bufSize),
+ 0, 0, tmpLength, file, &apduRC);
+ if (status != CKYSUCCESS) {
+ return status;
+ }
+ }
+
+ return CKYSUCCESS;
+}
+
+void
+Slot::parseEF_TokenInfo(void)
+{
+ DEREncodedTokenInfo derTokenInfo(&p15tokenInfo);
+ const CKYBuffer *serial=&derTokenInfo.serialNumber;
+
+ if (derTokenInfo.version >= 0) {
+ tokenFWVersion.major = derTokenInfo.version;
+ tokenFWVersion.minor = 0;
+ }
+
+ if (CKYSize(serial) != 0) {
+ CKYBuffer_Replace(&p15serialNumber, 0, CKYBuffer_Data(serial),
+ CKYBuffer_Size(serial));
+ }
+
+ if (derTokenInfo.manufacturer) {
+ if (tokenManufacturer) {
+ free(tokenManufacturer);
+ tokenManufacturer = NULL;
+ }
+ tokenManufacturer = derTokenInfo.manufacturer;
+ derTokenInfo.manufacturer = NULL; /* adopted */
+ }
+
+ if (derTokenInfo.tokenName) {
+ if (personName) {
+ free(personName);
+ personName = NULL;
+ }
+ personName = derTokenInfo.tokenName;
+ derTokenInfo.tokenName = NULL; /* adopted */
+ fullTokenName = true;
+ }
+ return;
+}
+
+void
+Slot::parseEF_ODF(void)
+{
+ const CKYByte *current = CKYBuffer_Data(&p15odf);
+ CKYSize size = CKYBuffer_Size(&p15odf);
+ CKYBuffer files;
+
+ CKYBuffer_InitEmpty(&files);
+
+ while (size > 0) {
+ const CKYByte *entry;
+ CKYSize entrySize;
+ CKYSize tagSize;
+ CKYByte type, type1;
+ PK15ObjectPath objPath;
+ bool skip;
+
+ type = current[0];
+ entry = dataStart(current, size, &entrySize, false);
+ if (entry == NULL) { break; }
+ tagSize = entry-current;
+ current += entrySize + tagSize;
+ size -= (entrySize + tagSize);
+
+ /* skip those entries we aren't going to parse */
+ skip = false;
+ switch (type) {
+ case 0xa2: skip=true; break; /* skip EF(PuKDF-trusted) */
+ case 0xa3: skip=true; break; /* skip EF(SKDF) */
+ case 0xa7: skip=true; break; /* skip EF(DODF) */
+ default: skip=true; break;
+ case 0xa0: /* EF(PvKDF) */
+ case 0xa1: /* EF(PuKDF) */
+ case 0xa4: /* EF(CDF) */
+ case 0xa5: /* EF(CDF-trusted) */
+ case 0xa6: /* EF(CDF-useful) */
+ case 0xa8: break; /* EF(AODF) */
+ }
+ if (skip) continue;
+
+ type1 = entry[0];
+ /* unwrap */
+ entry = dataStart(entry, entrySize, &entrySize, false);
+ if (entry == NULL) continue;
+ if (type1 == ASN1_SEQUENCE) {
+ objPath.setObjectPath(entry, entrySize);
+ CKYBuffer_Resize(&files, 0);
+ readFromPath(objPath, &files);
+ entry = CKYBuffer_Data(&files);
+ entrySize = CKYBuffer_Size(&files);
+ } else if (type1 != ASN1_CHOICE_0) {
+ continue;
+ }
+
+ switch (type) {
+ case 0xa0: parseEF_Directory(entry, entrySize, PK15PvKey); break;
+ case 0xa1: parseEF_Directory(entry, entrySize, PK15PuKey); break;
+ case 0xa4: parseEF_Directory(entry, entrySize, PK15Cert); break;
+ case 0xa5: parseEF_Directory(entry, entrySize, PK15Cert); break;
+ case 0xa6: parseEF_Directory(entry, entrySize, PK15Cert); break;
+ case 0xa8: parseEF_Directory(entry, entrySize, PK15AuthObj); break;
+ default: break;
+ }
+ }
+ CKYBuffer_FreeData(&files);
+ return;
+}
+
+
+class ObjectCertCKAIDMatch {
+ private:
+ const CKYBuffer *cka_id;
+ public:
+ ObjectCertCKAIDMatch(const CKYBuffer *cka_id_) : cka_id(cka_id_) {}
+ bool operator()(const PKCS11Object& obj) {
+ const CKYBuffer *id;
+ const CKYBuffer *objClass;
+ CK_OBJECT_CLASS certClass = CKO_CERTIFICATE;
+ objClass = obj.getAttribute(CKA_CLASS);
+ if (objClass == NULL || !CKYBuffer_DataIsEqual(objClass,
+ (CKYByte *)&certClass, sizeof(certClass))) {
+ return false;
+ }
+ id = obj.getAttribute(CKA_ID);
+ return (id != NULL && CKYBuffer_IsEqual(id,cka_id)) ? true : false;
+ }
+};
+
+class ObjectKeyCKAIDMatch {
+ private:
+ const CKYBuffer *cka_id;
+ public:
+ ObjectKeyCKAIDMatch(const CKYBuffer *cka_id_) : cka_id(cka_id_) {}
+ bool operator()(const PKCS11Object& obj) {
+ const CKYBuffer *id;
+ const CKYBuffer *objClass;
+ CK_OBJECT_CLASS keyClass = CKO_PRIVATE_KEY;
+ objClass = obj.getAttribute(CKA_CLASS);
+ if (objClass == NULL || !CKYBuffer_DataIsEqual(objClass,
+ (CKYByte *)&keyClass, sizeof(keyClass))) {
+ return false;
+ }
+ id = obj.getAttribute(CKA_ID);
+ return (id != NULL && CKYBuffer_IsEqual(id,cka_id)) ? true : false;
+ }
+};
+
+CKYStatus
+Slot::parseEF_Directory(const CKYByte *current,
+ CKYSize size, PK15ObjectType type)
+{
+ CKYBuffer file;
+ CKYBuffer_InitEmpty(&file);
+ CKYStatus status;
+
+
+ while (size > 0) {
+ const CKYByte *entry;
+ CKYSize entrySize;
+
+ if (current[0] != ASN1_SEQUENCE) {
+ /* no more */
+ break;
+ }
+
+ entry = dataStart(current, size, &entrySize, true);
+ if (entry == NULL) { break; }
+ current += entrySize;
+ size -= entrySize;
+
+ do {
+ PK15Object obj(PK15Instance(), type, entry, entrySize);
+
+ /* if state failed, then there is something wrong with this
+ * der, skip this object */
+ if (obj.getState() == PK15StateInit) {
+ break;
+ }
+ status = CKYSUCCESS;
+ while (obj.getState() != PK15StateComplete) {
+ CKYBuffer_Resize(&file, 0);
+ readFromPath(obj.getObjectPath(), &file);
+ status = obj.completeObject(CKYBuffer_Data(&file),
+ CKYBuffer_Size(&file));
+ if (status != CKYSUCCESS) {
+ break;
+ }
+ }
+ if (status != CKYSUCCESS) {
+ break;
+ }
+ assert(obj.getState() == PK15StateComplete);
+ /* handle type specific per object fixups */
+ switch (type) {
+ case PK15AuthObj:
+ /* if we're an auth object, squirrel us away for future use */
+ if (obj.isSO()) {
+ if (auth[CKU_SO] != 0) {
+ auth[CKU_SO] = new PK15Object(obj);
+ }
+ } else if (auth[CKU_USER] == NULL) {
+ auth[CKU_USER] = new PK15Object(obj);
+ } else if (auth[CKU_CONTEXT_SPECIFIC] == NULL) {
+ ObjectIter iter;
+ const CKYBuffer *authid = obj.getPinAuthId();
+
+ /* these should put on the individual keys */
+ auth[CKU_CONTEXT_SPECIFIC] = new PK15Object(obj);
+
+ for( iter = tokenObjects.begin();
+ iter != tokenObjects.end(); ++iter) {
+ if( CKYBuffer_IsEqual(iter->getAuthId(),authid)) {
+ iter->setAttributeBool(CKA_ALWAYS_AUTHENTICATE,
+ TRUE);
+ }
+ }
+ }
+ /* drop unkown */
+ break;
+ case PK15PvKey:
+ /* does the cert already exist? */
+ {
+ ObjectConstIter iter;
+ const CKYBuffer *id;
+
+ id = obj.getAttribute(CKA_ID);
+ if ((!id) || (CKYBuffer_Size(id) != 1)) {
+ break;
+ }
+ iter = find_if(tokenObjects.begin(), tokenObjects.end(),
+ ObjectCertCKAIDMatch(id));
+
+ if ( iter != tokenObjects.end() ) {
+ obj.completeKey(*iter);
+ }
+ }
+ break;
+ case PK15Cert:
+ /* does a corresponding key already exist? */
+ {
+ ObjectIter iter;
+ const CKYBuffer *id;
+
+ id = obj.getAttribute(CKA_ID);
+ if ((!id) || (CKYBuffer_Size(id) != 1)) {
+ break;
+ }
+ iter = find_if(tokenObjects.begin(), tokenObjects.end(),
+ ObjectKeyCKAIDMatch(id));
+
+ if ( iter != tokenObjects.end() ) {
+ iter->completeKey(obj);
+ }
+ }
+ break;
+ case PK15PuKey:
+ break;
+ }
+ tokenObjects.push_back(obj);
+ } while ( false );
+ }
+ CKYBuffer_FreeData(&file);
+ return CKYSUCCESS;
+}
+
+
+CKYStatus
+Slot::selectPath(const CKYBuffer *path, CKYISOStatus *apduRC)
+{
+ CKYSize size = CKYBuffer_Size(path);
+ CKYStatus status = CKYINVALIDARGS;
+ CKYOffset pos;
+
+ for (pos=0; pos < size; pos +=2) {
+ unsigned short ef = CKYBuffer_GetShort(path, pos);
+ status = P15Applet_SelectFile(conn, ef, apduRC);
+ if (status != CKYSUCCESS) {
+ break;
+ }
+ }
+ return status;
+}
+
void
Slot::refreshTokenState()
{
@@ -1132,8 +1581,20 @@ void
Slot::makeSerialString(char *serialNumber, int maxSize,
const unsigned char *cuid)
{
+ CKYSize ssize = CKYBuffer_Size(&p15serialNumber);
memset(serialNumber, ' ', maxSize);
+ if (ssize != 0) {
+ CKYSize i;
+ ssize = MIN((CKYSize)maxSize/2, ssize);
+ for (i=0; i < ssize; i++) {
+ CKYByte c = CKYBuffer_GetChar(&p15serialNumber, i);
+ serialNumber[2*i] = hex((c >> 4) & 0xf);
+ serialNumber[2*i+1] = hex(c & 0xf);
+ }
+ }
+
+
// otherwise we use the eepromSerialNumber as a hex value
if (cuid) {
makeCUIDString(serialNumber, maxSize, cuid);
@@ -1204,7 +1665,8 @@ struct _manList {
static const struct _manList manList[] = {
{ 0x4090, "Axalto" },
{ 0x2050, "Oberthur" },
- { 0x4780, "RSA" }
+ { 0x4780, "RSA" },
+ { 0x534e, "SafeNet" }
};
static int manListSize = sizeof(manList)/sizeof(manList[0]);
@@ -1213,8 +1675,15 @@ void
Slot::makeManufacturerString(char *man, int maxSize, const unsigned char *cuid)
{
char *cp = man;
+ int manLen;
memset(man, ' ', maxSize);
+ if (tokenManufacturer) {
+ manLen = strlen(tokenManufacturer);
+ memcpy(man, tokenManufacturer, MIN(manLen, maxSize));
+ // UTF8 Truncate fixup! don't drop halfway through a UTF8 character
+ return;
+ }
if (!cuid) {
return;
}
@@ -1633,26 +2102,6 @@ class KeyNumMatch {
}
};
-class ObjectCertCKAIDMatch {
- private:
- CKYByte cka_id;
- public:
- ObjectCertCKAIDMatch(CKYByte cka_id_) : cka_id(cka_id_) {}
- bool operator()(const PKCS11Object& obj) {
- const CKYBuffer *id;
- const CKYBuffer *objClass;
- CK_OBJECT_CLASS certClass = CKO_CERTIFICATE;
- objClass = obj.getAttribute(CKA_CLASS);
- if (objClass == NULL || !CKYBuffer_DataIsEqual(objClass,
- (CKYByte *)&certClass, sizeof(certClass))) {
- return false;
- }
- id = obj.getAttribute(CKA_ID);
- return (id != NULL && CKYBuffer_DataIsEqual(id,&cka_id, 1))
- ? true : false;
- }
-};
-
CK_OBJECT_HANDLE
Slot::generateUnusedObjectHandle()
{
@@ -1706,7 +2155,7 @@ Slot::addKeyObject(list<PKCS11Object>& o
"Missing or invalid CKA_ID value");
}
iter = find_if(objectList.begin(), objectList.end(),
- ObjectCertCKAIDMatch(CKYBuffer_GetChar(id,0)));
+ ObjectCertCKAIDMatch(id));
if ( iter == objectList.end() ) {
// We failed to find a cert with a matching CKA_ID. This
// can happen if the cert is not present on the token, or
@@ -1758,6 +2207,11 @@ Slot::unloadObjects()
free(personName);
personName = NULL;
fullTokenName = false;
+ if (tokenManufacturer) {
+ free(tokenManufacturer);
+ tokenManufacturer = NULL;
+ }
+ CKYBuffer_Resize(&p15serialNumber,0);
}
#ifdef USE_SHMEM
@@ -2956,6 +3410,17 @@ Slot::loadObjects()
loadReaderObject();
return;
}
+ if (state & P15_CARD) {
+ parseEF_TokenInfo();
+ parseEF_ODF();
+ if (auth[CKU_USER] != NULL) {
+ /* set need login */
+ needLogin = true;
+ }
+ status = trans.end();
+ loadReaderObject();
+ return;
+ }
selectApplet();
log->log("time load object: Select Applet (again) %d ms\n",
@@ -3123,15 +3588,15 @@ Slot::getSessionInfo(SessionHandleSuffix
}
void
-SlotList::login(CK_SESSION_HANDLE hSession, CK_UTF8CHAR_PTR pPin,
- CK_ULONG ulPinLen)
+SlotList::login(CK_SESSION_HANDLE hSession, CK_USER_TYPE user,
+ CK_UTF8CHAR_PTR pPin, CK_ULONG ulPinLen)
{
CK_SLOT_ID slotID;
SessionHandleSuffix suffix;
decomposeSessionHandle(hSession, slotID, suffix);
- slots[slotIDToIndex(slotID)]->login(suffix, pPin, ulPinLen);
+ slots[slotIDToIndex(slotID)]->login(suffix, user, pPin, ulPinLen);
}
void
@@ -3181,8 +3646,8 @@ Slot::isLoggedIn()
}
void
-Slot::login(SessionHandleSuffix handleSuffix, CK_UTF8CHAR_PTR pPin,
- CK_ULONG ulPinLen)
+Slot::login(SessionHandleSuffix handleSuffix, CK_USER_TYPE user,
+ CK_UTF8CHAR_PTR pPin, CK_ULONG ulPinLen)
{
refreshTokenState();
@@ -3191,10 +3656,23 @@ Slot::login(SessionHandleSuffix handleSu
"Slot::login\n", (unsigned long) handleSuffix);
throw PKCS11Exception(CKR_SESSION_HANDLE_INVALID);
}
+ /* only support CKU_USER for CAC, PIV, and coolkey... CKU_USER and
+ * CKU_CONTEX_SPECIFIC for P15Card */
+ if (user != CKU_USER) {
+ if ((user != CKU_CONTEXT_SPECIFIC) || ((state & P15_CARD) == 0)) {
+ throw PKCS11Exception(CKR_USER_TYPE_INVALID);
+ }
+ }
+
if (!isVersion1Key) {
- pinCache.invalidate();
- pinCache.set((const char *)pPin, ulPinLen);
+ if (user == CKU_USER) {
+ pinCache.invalidate();
+ pinCache.set((const char *)pPin, ulPinLen);
+ } else {
+ contextPinCache.invalidate();
+ contextPinCache.set((const char *)pPin, ulPinLen);
+ }
} else if (nonceValid) {
throw PKCS11Exception(CKR_USER_ALREADY_LOGGED_IN);
}
@@ -3205,17 +3683,85 @@ Slot::login(SessionHandleSuffix handleSu
if (state & GOV_CARD) {
selectCACApplet(0, true);
- } else {
+ } else if ((state & P15_CARD)== 0) {
+ /* p15 does the select in attemptLogin */
selectApplet();
}
if (isVersion1Key) {
- attemptLogin((const char *)pPin);
- } else if (state & GOV_CARD) {
+ attemptCoolKeyLogin((const char *)pPin);
+ } else {
+ attemptLogin(user, false);
+ }
+}
+
+void
+Slot::attemptLogin(CK_USER_TYPE user, bool flushPin) {
+ if (state & GOV_CARD) {
attemptCACLogin();
+ } else if (state & P15_CARD) {
+ attemptP15Login(user);
} else {
oldAttemptLogin();
}
+ if (flushPin && (user == CKU_CONTEXT_SPECIFIC)) {
+ contextPinCache.clearPin();
+ }
+}
+void dump(const char *label, const CKYBuffer *buf);
+
+void
+Slot::attemptP15Login(CK_USER_TYPE user)
+{
+ PinCache *pinCachePtr = userPinCache(user);
+ const CKYBuffer *path;
+
+ if (user == CKU_USER) {
+ loggedIn = false;
+ }
+ pinCachePtr->invalidate();
+
+ CKYStatus status;
+ CKYISOStatus result;
+
+ if ((user >= MAX_AUTH_USERS) || (auth[user] == NULL)) {
+ throw PKCS11Exception(CKR_USER_TYPE_INVALID,
+ "No PKCS #15 auth object for user %d\n", user);
+ }
+
+ path = auth[user]->getObjectPath().getPath();
+ status = selectPath(auth[user]->getObjectPath().getPath(), &result);
+ if( status == CKYSCARDERR ) {
+ handleConnectionError();
+ }
+ if (status != CKYSUCCESS) {
+ throw PKCS11Exception(CKR_DEVICE_ERROR, "Applet select return 0x%04x",
+ result);
+ }
+
+ status = P15Applet_VerifyPIN(conn,
+ (const char *)CKYBuffer_Data(pinCachePtr->get()),
+ auth[user]->getPinInfo(), &result);
+ if( status == CKYSCARDERR ) {
+ handleConnectionError();
+ }
+ switch( result ) {
+ case CKYISO_SUCCESS:
+ break;
+ case 0x6983:
+ pinCachePtr->clearPin();
+ throw PKCS11Exception(CKR_PIN_LOCKED);
+ default:
+ pinCachePtr->clearPin();
+ if ((result & 0xff00) == 0x6300) {
+ throw PKCS11Exception(CKR_PIN_INCORRECT);
+ }
+ throw PKCS11Exception(CKR_DEVICE_ERROR, "Applet returned 0x%04x",
+ result);
+ }
+ pinCachePtr->validate();
+ if (user == CKU_USER)
+ loggedIn = true;
}
void
@@ -3252,6 +3798,7 @@ Slot::attemptCACLogin()
loggedIn = true;
}
+
void
Slot::oldAttemptLogin()
{
@@ -3286,7 +3833,7 @@ Slot::oldAttemptLogin()
// should already be in a transaction, and applet selected
void
-Slot::attemptLogin(const char *pin)
+Slot::attemptCoolKeyLogin(const char *pin)
{
CKYStatus status;
CKYISOStatus result;
@@ -3362,7 +3909,7 @@ Slot::logout(SessionHandleSuffix suffix)
throw PKCS11Exception(CKR_SESSION_HANDLE_INVALID);
}
- if (state & GOV_CARD) {
+ if (state & (GOV_CARD|P15_CARD)) {
CACLogout();
return;
}
@@ -3601,31 +4148,26 @@ Slot::ensureValidSession(SessionHandleSu
// from 0-9.
//
CKYByte
-Slot::objectHandleToKeyNum(CK_OBJECT_HANDLE hKey)
+Slot::objectToKeyNum(const PKCS11Object *key)
{
- ObjectConstIter iter = find_if(tokenObjects.begin(), tokenObjects.end(),
- ObjectHandleMatch(hKey));
-
- if( iter == tokenObjects.end() ) {
- // no such object
- throw PKCS11Exception(CKR_KEY_HANDLE_INVALID);
- }
+ unsigned long id = key->getMuscleObjID();
- if( getObjectClass(iter->getMuscleObjID()) != 'k' ) {
+ if( getObjectClass(id) != 'k' ) {
throw PKCS11Exception(CKR_KEY_HANDLE_INVALID);
}
- unsigned short keyNum = getObjectIndex(iter->getMuscleObjID());
+ unsigned short keyNum = getObjectIndex(id);
if( keyNum > 9 ) {
throw PKCS11Exception(CKR_KEY_HANDLE_INVALID);
}
return keyNum & 0xFF;
}
-PKCS11Object::KeyType
-Slot::getKeyTypeFromHandle(CK_OBJECT_HANDLE hKey)
+PKCS11Object *
+Slot::getKeyFromHandle(CK_OBJECT_HANDLE hKey)
{
ObjectConstIter iter = find_if(tokenObjects.begin(), tokenObjects.end(),
ObjectHandleMatch(hKey));
+ PKCS11Object &obj = (PKCS11Object &)*iter;
if( iter == tokenObjects.end() ) {
throw PKCS11Exception(CKR_KEY_HANDLE_INVALID);
@@ -3635,7 +4177,7 @@ Slot::getKeyTypeFromHandle(CK_OBJECT_HAN
throw PKCS11Exception(CKR_KEY_HANDLE_INVALID);
}
- return iter->getKeyType();
+ return &obj;
}
void
@@ -3648,9 +4190,7 @@ Slot::signInit(SessionHandleSuffix suffi
throw PKCS11Exception(CKR_SESSION_HANDLE_INVALID);
}
- PKCS11Object::KeyType keyType = getKeyTypeFromHandle(hKey);
-
- session->signatureState.initialize(objectHandleToKeyNum(hKey), keyType);
+ session->signatureState.initialize(getKeyFromHandle(hKey));
}
void
@@ -3663,9 +4203,7 @@ Slot::decryptInit(SessionHandleSuffix su
throw PKCS11Exception(CKR_SESSION_HANDLE_INVALID);
}
- PKCS11Object::KeyType keyType = getKeyTypeFromHandle(hKey);
-
- session->decryptionState.initialize(objectHandleToKeyNum(hKey), keyType);
+ session->decryptionState.initialize(getKeyFromHandle(hKey));
}
/**
@@ -3935,7 +4473,7 @@ Slot::sign(SessionHandleSuffix suffix, C
CryptOpState sigState = dummyParams.getOpState(*session);
- PKCS11Object::KeyType keyType = sigState.keyType;
+ PKCS11Object::KeyType keyType = sigState.key->getKeyType();
if ( keyType == PKCS11Object::unknown) {
throw PKCS11Exception(CKR_DATA_INVALID);
@@ -3982,9 +4520,9 @@ Slot::cryptRSA(SessionHandleSuffix suffi
}
CryptOpState& opState = params.getOpState(*session);
CKYBuffer *result = &opState.result;
- CKYByte keyNum = opState.keyNum;
+ PKCS11Object *key = opState.key;
- unsigned int keySize = getRSAKeySize(keyNum);
+ unsigned int keySize = getRSAKeySize(key);
if (keySize != CryptParams::DEFAULT_KEY_SIZE)
params.setKeySize(keySize);
@@ -4008,8 +4546,8 @@ Slot::cryptRSA(SessionHandleSuffix suffi
}
try {
params.padInput(&inputPad, &input);
- performRSAOp(&output, &inputPad, params.getKeySize(),
- keyNum, params.getDirection());
+ performRSAOp(&output, &inputPad, params.getKeySize(), key,
+ params.getDirection());
params.unpadOutput(result, &output);
CKYBuffer_FreeData(&input);
CKYBuffer_FreeData(&inputPad);
@@ -4072,9 +4610,9 @@ void Slot::signECC(SessionHandleSuffix s
}
CryptOpState& opState = params.getOpState(*session);
CKYBuffer *result = &opState.result;
- CKYByte keyNum = opState.keyNum;
+ PKCS11Object *key = opState.key;
- unsigned int keySize = getECCKeySize(keyNum);
+ unsigned int keySize = getECCKeySize(key);
if(keySize != CryptParams::ECC_DEFAULT_KEY_SIZE)
params.setKeySize(keySize);
@@ -4100,7 +4638,7 @@ void Slot::signECC(SessionHandleSuffix s
throw PKCS11Exception(CKR_HOST_MEMORY);
}
try {
- performECCSignature(&output, &input, params.getKeySize(), keyNum);
+ performECCSignature(&output, &input, params.getKeySize(), key);
params.unpadOutput(result, &output);
CKYBuffer_FreeData(&input);
CKYBuffer_FreeData(&output);
@@ -4122,8 +4660,26 @@ void Slot::signECC(SessionHandleSuffix s
}
void
+Slot::selectKey(const PKCS11Object *key, bool retry)
+{
+ /* P15 cards need to be reselected on retry because P15 must select
+ * on authentication. PIV, CAC and Coolkeys do not */
+ if (retry && ((state & GOV_CARD) || ((state & P15_CARD) == 0))) {
+ return;
+ }
+ if (state & GOV_CARD) {
+ selectCACApplet(objectToKeyNum(key), true);
+ } else if (state & P15_CARD) {
+ selectPath(key->getObjectPath().getPath(), NULL);
+ } else {
+ selectApplet();
+ }
+ return;
+}
+
+void
Slot::performECCSignature(CKYBuffer *output, const CKYBuffer *input,
- unsigned int keySize, CKYByte keyNum)
+ unsigned int keySize, const PKCS11Object *key)
{
/* establish a transaction */
@@ -4135,22 +4691,23 @@ Slot::performECCSignature(CKYBuffer *out
throw PKCS11Exception(CKR_FUNCTION_NOT_SUPPORTED);
}
- if (state & GOV_CARD) {
- selectCACApplet(keyNum, true);
- } else {
- selectApplet();
- }
-
CKYISOStatus result;
- int loginAttempted = 0;
+ bool loginAttempted = false;
retry:
+ selectKey(key, loginAttempted);
+
if (state & PIV_CARD) {
- status = PIVApplet_SignDecrypt(conn, pivKey, keySize/8, 0, input, output, &result);
+ status = PIVApplet_SignDecrypt(conn, pivKey, keySize/8, 0,
+ input, output, &result);
} else if (state & CAC_CARD) {
status = CACApplet_SignDecrypt(conn, input, output, &result);
+ } else if (state & P15_CARD) {
+ status = P15Applet_SignDecrypt(conn, key->getKeyRef(), keySize/8,
+ CKY_DIR_ENCRYPT, input, output, &result);
+
} else {
- status = CKYApplet_ComputeECCSignature(conn, keyNum, input, NULL, output, getNonce(), &result);
+ status = CKYApplet_ComputeECCSignature(conn, objectToKeyNum(key), input, NULL, output, getNonce(), &result);
}
/* map the ISO not logged in code to the coolkey one */
if ((result == CKYISO_CONDITION_NOT_SATISFIED) ||
@@ -4166,19 +4723,16 @@ retry:
if (result == CKYISO_DATA_INVALID) {
throw PKCS11Exception(CKR_DATA_INVALID);
}
- /* version0 keys could be logged out in the middle by someone else,
- reauthenticate... This code can go away when we depricate.
- version0 applets.
- */
+ /* keys could be logged out in the middle by someone else,
+ * reauthenticate... coolkey version 1 bypasses this issue by
+ * allowing multiple applications separate login states at once.
+ */
if (!isVersion1Key && !loginAttempted &&
+ userPinCache(key->getUser())->isValid() &&
(result == CKYISO_UNAUTHORIZED)) {
/* try to reauthenticate */
try {
- if (state & GOV_CARD) {
- attemptCACLogin();
- } else {
- oldAttemptLogin();
- }
+ attemptLogin(key->getUser(),true);
} catch(PKCS11Exception& ) {
/* attemptLogin can throw things like CKR_PIN_INCORRECT
that don't make sense from a crypto operation. This is
@@ -4199,8 +4753,9 @@ retry:
void
-Slot::performRSAOp(CKYBuffer *output, const CKYBuffer *input, unsigned int keySize,
- CKYByte keyNum, CKYByte direction)
+Slot::performRSAOp(CKYBuffer *output, const CKYBuffer *input,
+ unsigned int keySize, const PKCS11Object *key,
+ CKYByte direction)
{
if ( mECC ) {
throw PKCS11Exception(CKR_FUNCTION_NOT_SUPPORTED);
@@ -4212,26 +4767,25 @@ Slot::performRSAOp(CKYBuffer *output, co
Transaction trans;
CKYStatus status = trans.begin(conn);
if( status != CKYSUCCESS ) handleConnectionError();
-
- //
- // select the applet
- //
- if (state & GOV_CARD) {
- selectCACApplet(keyNum, true);
- } else {
- selectApplet();
- }
-
CKYISOStatus result;
- int loginAttempted = 0;
+ bool loginAttempted = false;
+
retry:
+ selectKey(key, loginAttempted);
+
+
if (state & PIV_CARD) {
- status = PIVApplet_SignDecrypt(conn, pivKey, keySize/8, 0, input, output, &result);
+ status = PIVApplet_SignDecrypt(conn, pivKey, keySize/8, 0,
+ input, output, &result);
} else if (state & CAC_CARD) {
status = CACApplet_SignDecrypt(conn, input, output, &result);
+ } else if (state & P15_CARD) {
+ status = P15Applet_SignDecrypt(conn, key->getKeyRef(), keySize/8,
+ direction, input, output, &result);
} else {
- status = CKYApplet_ComputeCrypt(conn, keyNum, CKY_RSA_NO_PAD, direction,
- input, NULL, output, getNonce(), &result);
+ status = CKYApplet_ComputeCrypt(conn, objectToKeyNum(key),
+ CKY_RSA_NO_PAD, direction, input, NULL, output,
+ getNonce(), &result);
}
/* map the ISO not logged in code to the coolkey one */
@@ -4250,15 +4804,12 @@ retry:
// version0 keys could be logged out in the middle by someone else,
// reauthenticate... This code can go away when we depricate.
// version0 applets.
- if (!isVersion1Key && !loginAttempted && pinCache.isValid() &&
+ if (!isVersion1Key && !loginAttempted &&
+ userPinCache(key->getUser())->isValid() &&
(result == CKYISO_UNAUTHORIZED)) {
// try to reauthenticate
try {
- if (state & GOV_CARD) {
- attemptCACLogin();
- } else {
- oldAttemptLogin();
- }
+ attemptLogin(key->getUser(), true);
} catch(PKCS11Exception& ) {
// attemptLogin can throw things like CKR_PIN_INCORRECT
// that don't make sense from a crypto operation. This is
@@ -4278,7 +4829,7 @@ void
Slot::seedRandom(SessionHandleSuffix suffix, CK_BYTE_PTR pData,
CK_ULONG ulDataLen)
{
- if (state & GOV_CARD) {
+ if (state & (GOV_CARD|P15_CARD)) {
/* should throw unsupported */
throw PKCS11Exception(CKR_DEVICE_ERROR);
}
@@ -4330,7 +4881,7 @@ void
Slot::generateRandom(SessionHandleSuffix suffix, const CK_BYTE_PTR pData,
CK_ULONG ulDataLen)
{
- if (state & GOV_CARD) {
+ if (state & (GOV_CARD|P15_CARD)) {
/* should throw unsupported */
throw PKCS11Exception(CKR_DEVICE_ERROR);
}
@@ -4364,61 +4915,44 @@ Slot::generateRandom(SessionHandleSuffix
#define MAX_NUM_KEYS 8
unsigned int
-Slot::getRSAKeySize(CKYByte keyNum)
+Slot::getRSAKeySize(PKCS11Object *key)
{
unsigned int keySize = CryptParams::DEFAULT_KEY_SIZE;
int modSize = 0;
- if(keyNum >= MAX_NUM_KEYS) {
- return keySize;
- }
-
- ObjectConstIter iter;
- iter = find_if(tokenObjects.begin(), tokenObjects.end(),
- KeyNumMatch(keyNum,*this));
-
- if( iter == tokenObjects.end() ) {
- return keySize;
+ modSize = key->getKeySize();
+ if (modSize != 0) {
+ return modSize;
}
- CKYBuffer const *modulus = iter->getAttribute(CKA_MODULUS);
+ CKYBuffer const *modulus = key->getAttribute(CKA_MODULUS);
if(modulus) {
modSize = CKYBuffer_Size(modulus);
if(CKYBuffer_GetChar(modulus,0) == 0x0) {
modSize--;
}
- if(modSize > 0)
+ if(modSize > 0) {
keySize = modSize * 8;
+ key->setKeySize(keySize);
+ }
}
return keySize;
}
unsigned int
-Slot::getECCKeySize(CKYByte keyNum)
-{
- return calcECCKeySize(keyNum);
-}
-
-unsigned int
-Slot::calcECCKeySize(CKYByte keyNum)
+Slot::getECCKeySize(PKCS11Object *key)
{
unsigned int keySize = CryptParams::ECC_DEFAULT_KEY_SIZE;
+ unsigned int objKeySize = 0;
- if(keyNum >= MAX_NUM_KEYS) {
- return keySize;
- }
-
- ObjectConstIter iter;
- iter = find_if(tokenObjects.begin(), tokenObjects.end(),
- KeyNumMatch(keyNum,*this));
-
- if( iter == tokenObjects.end() ) {
- return keySize;
+ objKeySize = key->getKeySize();
+ if (objKeySize != 0) {
+ return objKeySize;
}
- CKYBuffer const *eccParams = iter->getAttribute(CKA_EC_PARAMS);
+ CKYBuffer const *eccParams = key->getAttribute(CKA_EC_PARAMS);
if (eccParams == NULL) {
return keySize;
@@ -4457,6 +4991,7 @@ Slot::calcECCKeySize(CKYByte keyNum)
if ( match == 1 ) {
keySize = curveBytesNamePair[i].length;
+ key->setKeySize(keySize);
return keySize;
}
@@ -4476,10 +5011,9 @@ Slot::derive(SessionHandleSuffix suffix,
ECCKeyAgreementParams params(CryptParams::ECC_DEFAULT_KEY_SIZE);
SessionIter session = findSession(suffix);
- PKCS11Object::KeyType keyType = getKeyTypeFromHandle(hBaseKey);
-
- session->keyAgreementState.initialize(objectHandleToKeyNum(hBaseKey), keyType);
- deriveECC(suffix, pMechanism, hBaseKey, pTemplate, ulAttributeCount, phKey, params);
+ session->keyAgreementState.initialize(getKeyFromHandle(hBaseKey));
+ deriveECC(suffix, pMechanism, hBaseKey, pTemplate, ulAttributeCount,
+ phKey, params);
}
@@ -4515,9 +5049,8 @@ void Slot::deriveECC(SessionHandleSuffix
CryptOpState& opState = params.getOpState(*session);
CKYBuffer *result = &opState.result;
- CKYByte keyNum = opState.keyNum;
- unsigned int keySize = getECCKeySize(keyNum);
+ unsigned int keySize = getECCKeySize(opState.key);
if(keySize != CryptParams::ECC_DEFAULT_KEY_SIZE)
params.setKeySize(keySize);
@@ -4542,10 +5075,11 @@ void Slot::deriveECC(SessionHandleSuffix
if( CKYBuffer_Size(result) == 0 ) {
try {
- performECCKeyAgreement(deriveMech, &publicDataBuffer, &secretKeyBuffer,
- keyNum, params.getKeySize());
+ performECCKeyAgreement(deriveMech, &publicDataBuffer,
+ &secretKeyBuffer, opState.key, params.getKeySize());
CK_OBJECT_HANDLE keyObjectHandle = generateUnusedObjectHandle();
- secret = createSecretKeyObject(keyObjectHandle, &secretKeyBuffer, pTemplate, ulAttributeCount);
+ secret = createSecretKeyObject(keyObjectHandle, &secretKeyBuffer,
+ pTemplate, ulAttributeCount);
} catch(PKCS11Exception& e) {
CKYBuffer_FreeData(&secretKeyBuffer);
CKYBuffer_FreeData(&publicDataBuffer);
@@ -4557,15 +5091,15 @@ void Slot::deriveECC(SessionHandleSuffix
CKYBuffer_FreeData(&publicDataBuffer);
if ( secret ) {
-
*phKey = secret->getHandle();
delete secret;
}
}
void
-Slot::performECCKeyAgreement(CK_MECHANISM_TYPE deriveMech, CKYBuffer *publicDataBuffer,
- CKYBuffer *secretKeyBuffer, CKYByte keyNum, unsigned int keySize)
+Slot::performECCKeyAgreement(CK_MECHANISM_TYPE deriveMech,
+ CKYBuffer *publicDataBuffer, CKYBuffer *secretKeyBuffer,
+ const PKCS11Object *key, unsigned int keySize)
{
if (!mECC) {
throw PKCS11Exception(CKR_FUNCTION_NOT_SUPPORTED);
@@ -4575,25 +5109,26 @@ Slot::performECCKeyAgreement(CK_MECHANIS
CKYStatus status = trans.begin(conn);
if( status != CKYSUCCESS ) handleConnectionError();
- if (state & GOV_CARD) {
- selectCACApplet(keyNum, true);
- } else {
- selectApplet();
- }
-
CKYISOStatus result;
- int loginAttempted = 0;
+ bool loginAttempted = false;
retry:
+ selectKey(key, loginAttempted);
if (state & PIV_CARD) {
- status = PIVApplet_SignDecrypt(conn, pivKey, keySize/8, 1, publicDataBuffer,
- secretKeyBuffer, &result);
+ status = PIVApplet_SignDecrypt(conn, pivKey, keySize/8, 1,
+ publicDataBuffer, secretKeyBuffer, &result);
} else if (state & CAC_CARD) {
- status = CACApplet_SignDecrypt(conn, publicDataBuffer, secretKeyBuffer, &result);
+ status = CACApplet_SignDecrypt(conn, publicDataBuffer,
+ secretKeyBuffer, &result);
+ } else if (state & P15_CARD) {
+ /*status = P15Applet_SignDecrypt(conn, key->getKeyRef(), keySize/8,
+ publicDataBuffer, secretKeyBuffer, &result); */
+ throw PKCS11Exception(CKR_FUNCTION_NOT_SUPPORTED);
} else {
- status = CKYApplet_ComputeECCKeyAgreement(conn, keyNum,
- publicDataBuffer , NULL, secretKeyBuffer, getNonce(), &result);
+ status = CKYApplet_ComputeECCKeyAgreement(conn, objectToKeyNum(key),
+ publicDataBuffer , NULL, secretKeyBuffer,
+ getNonce(), &result);
}
/* map the ISO not logged in code to the coolkey one */
if ((result == CKYISO_CONDITION_NOT_SATISFIED) ||
@@ -4610,13 +5145,10 @@ retry:
throw PKCS11Exception(CKR_DATA_INVALID);
}
if (!isVersion1Key && !loginAttempted &&
- (result == CKYISO_UNAUTHORIZED)) {
+ userPinCache(key->getUser())->isValid() &&
+ (result == CKYISO_UNAUTHORIZED)) {
try {
- if (state & GOV_CARD) {
- attemptCACLogin();
- } else {
- oldAttemptLogin();
- }
+ attemptLogin(key->getUser(), true);
} catch(PKCS11Exception& ) {
throw PKCS11Exception(CKR_DEVICE_ERROR);
}
diff -up ./src/coolkey/slot.h.p15 ./src/coolkey/slot.h
--- ./src/coolkey/slot.h.p15 2015-07-06 10:27:55.772827229 -0700
+++ ./src/coolkey/slot.h 2015-07-06 10:27:55.786826965 -0700
@@ -183,7 +183,7 @@ struct PinCache {
CKYBuffer_Replace(&cachedPin, 0, (const CKYByte *)newPin, pinLen);
CKYBuffer_AppendChar(&cachedPin, 0);
}
- void clearPin() { CKYBuffer_Zero(&cachedPin); }
+ void clearPin() { CKYBuffer_Zero(&cachedPin); valid = false; }
void invalidate() { valid = false; }
void validate() { valid = true; }
const CKYBuffer *get() const { return &cachedPin; }
@@ -209,29 +209,26 @@ class CryptOpState {
public:
enum State { NOT_INITIALIZED, IN_PROCESS, FINALIZED };
State state;
- CKYByte keyNum;
CKYBuffer result;
- PKCS11Object::KeyType keyType;
+ PKCS11Object *key;
- CryptOpState() : state(NOT_INITIALIZED), keyNum(0), keyType(PKCS11Object::unknown)
+ CryptOpState() : state(NOT_INITIALIZED), key(NULL)
{ CKYBuffer_InitEmpty(&result); }
CryptOpState(const CryptOpState &cpy) :
- state(cpy.state), keyNum(cpy.keyNum), keyType(cpy.keyType) {
+ state(cpy.state), key(cpy.key) {
CKYBuffer_InitFromCopy(&result, &cpy.result);
}
CryptOpState &operator=(const CryptOpState &cpy) {
state = cpy.state,
- keyNum = cpy.keyNum;
- keyType = cpy.keyType;
+ key = cpy.key;
CKYBuffer_Replace(&result, 0, CKYBuffer_Data(&cpy.result),
CKYBuffer_Size(&cpy.result));
return *this;
}
~CryptOpState() { CKYBuffer_FreeData(&result); }
- void initialize(CKYByte keyNum, PKCS11Object::KeyType theKeyType) {
+ void initialize(PKCS11Object *theKey) {
state = IN_PROCESS;
- this->keyNum = keyNum;
- this->keyType = theKeyType;
+ this->key = theKey;
CKYBuffer_Resize(&result, 0);
}
};
@@ -298,6 +295,7 @@ class CryptParams {
};
#define MAX_CERT_SLOTS 3
+#define MAX_AUTH_USERS 3
class Slot {
public:
@@ -308,7 +306,8 @@ class Slot {
APPLET_SELECTABLE = 0x08,
APPLET_PERSONALIZED = 0x10,
CAC_CARD = 0x20,
- PIV_CARD = 0x40
+ PIV_CARD = 0x40,
+ P15_CARD = 0x80
};
enum {
NONCE_SIZE = 8
@@ -321,6 +320,7 @@ class Slot {
char *readerName;
char *personName;
char *manufacturer;
+ char *tokenManufacturer;
//char *model;
CK_VERSION hwVersion;
CK_VERSION tokenFWVersion;
@@ -329,6 +329,7 @@ class Slot {
CKYCardConnection* conn;
unsigned long state; // = UNKNOWN
PinCache pinCache;
+ PinCache contextPinCache;
bool loggedIn;
bool reverify;
bool nonceValid;
@@ -349,6 +350,14 @@ class Slot {
int pivContainer;
int pivKey;
bool mECC;
+ unsigned short p15aid;
+ unsigned short p15odfAddr;
+ unsigned short p15tokenInfoAddr;
+ unsigned int p15Instance;
+ CKYBuffer p15AID;
+ CKYBuffer p15tokenInfo;
+ CKYBuffer p15odf;
+ CKYBuffer p15serialNumber;
//enum { RW_SESSION_HANDLE = 1, RO_SESSION_HANDLE = 2 };
#ifdef USE_SHMEM
@@ -367,6 +376,7 @@ class Slot {
void closeAllSessions();
SessionHandleSuffix generateNewSession(Session::Type type);
+ PK15Object *auth[MAX_AUTH_USERS];
bool cardStateMayHaveChanged();
void connectToToken();
@@ -418,48 +428,63 @@ class Slot {
bool throwException);
CKYStatus readCACCertificateAppend(CKYBuffer *cert, CKYSize nextSize);
+ CKYStatus getP15Params();
void selectApplet();
void selectCACApplet(CKYByte instance,bool do_disconnect);
+ void selectKey(const PKCS11Object *key, bool retry);
+ CKYStatus selectPath(const CKYBuffer *path, CKYISOStatus *adpurc);
+ CKYStatus readFromPath(const PK15ObjectPath &obj, CKYBuffer *file);
void unloadObjects();
void loadCACObjects();
void loadCACCert(CKYByte instance);
void loadObjects();
void loadReaderObject();
- void attemptLogin(const char *pin);
+ void attemptCoolKeyLogin(const char *pin);
+ void attemptLogin(CK_USER_TYPE user, bool flushPin);
+ void attemptP15Login(CK_USER_TYPE user);
void attemptCACLogin();
void oldAttemptLogin();
void oldLogout(void);
void CACLogout(void);
+ PinCache *userPinCache(CK_USER_TYPE user) {
+ return ((user == CKU_CONTEXT_SPECIFIC) && (state & P15_CARD)) ?
+ &contextPinCache : &pinCache; }
+
+ void parseEF_ODF(void);
+ void parseEF_TokenInfo(void);
+ CKYStatus parseEF_Directory(const CKYByte *data, CKYSize size,
+ PK15ObjectType type);
+ unsigned int PK15Instance(void) { return p15Instance++; }
void readMuscleObject(CKYBuffer *obj, unsigned long objID,
unsigned int objSize);
void performSignature(CKYBuffer *sig, const CKYBuffer *unpaddedInput,
- CKYByte keyNum);
- void performDecryption(CKYBuffer *data, const CKYBuffer *input, CKYByte keyNum);
+ const PKCS11Object *key);
+ void performDecryption(CKYBuffer *data, const CKYBuffer *input,
+ const PKCS11Object *key);
void cryptRSA(SessionHandleSuffix suffix, CK_BYTE_PTR pInput,
CK_ULONG ulInputLen, CK_BYTE_PTR pOutput,
CK_ULONG_PTR pulOutputLen, CryptParams& params);
- void performRSAOp(CKYBuffer *out, const CKYBuffer *input, unsigned int keySize,
- CKYByte keyNum, CKYByte direction);
+ void performRSAOp(CKYBuffer *out, const CKYBuffer *input,
+ unsigned int keySize, const PKCS11Object *key, CKYByte direction);
void signECC(SessionHandleSuffix suffix, CK_BYTE_PTR pInput,
CK_ULONG ulInputLen, CK_BYTE_PTR pOutput,
CK_ULONG_PTR pulOutputLen, CryptParams& params);
void performECCSignature(CKYBuffer *out, const CKYBuffer *input,
- unsigned int keySize, CKYByte keyNum);
+ unsigned int keySize, const PKCS11Object *key);
void performECCKeyAgreement(CK_MECHANISM_TYPE deriveMech,
- CKYBuffer *publicDataBuffer,
- CKYBuffer *secretKeyBuffer, CKYByte keyNum, unsigned int keySize);
+ CKYBuffer *publicDataBuffer, CKYBuffer *secretKeyBuffer,
+ const PKCS11Object *key, unsigned int keySize);
void processComputeCrypt(CKYBuffer *result, const CKYAPDU *apdu);
- CKYByte objectHandleToKeyNum(CK_OBJECT_HANDLE hKey);
- unsigned int calcECCKeySize(CKYByte keyNum);
+ CKYByte objectToKeyNum(const PKCS11Object *key);
Slot(const Slot &cpy)
#ifdef USE_SHMEM
: shmem(readerName)
@@ -491,10 +516,10 @@ class Slot {
}
// actually get the size of a key in bits from the card
- unsigned int getRSAKeySize(CKYByte keyNum);
- unsigned int getECCKeySize(CKYByte keyNum);
+ unsigned int getRSAKeySize(PKCS11Object *key);
+ unsigned int getECCKeySize(PKCS11Object *key);
- PKCS11Object::KeyType getKeyTypeFromHandle(CK_OBJECT_HANDLE hKey);
+ PKCS11Object *getKeyFromHandle(CK_OBJECT_HANDLE hKey);
SessionHandleSuffix openSession(Session::Type type);
void closeSession(SessionHandleSuffix handleSuffix);
@@ -504,8 +529,8 @@ class Slot {
void getSessionInfo(SessionHandleSuffix handleSuffix,
CK_SESSION_INFO_PTR pInfo);
- void login(SessionHandleSuffix handleSuffix, CK_UTF8CHAR_PTR pPin,
- CK_ULONG ulPinLen);
+ void login(SessionHandleSuffix handleSuffix, CK_USER_TYPE user,
+ CK_UTF8CHAR_PTR pPin, CK_ULONG ulPinLen);
void logout(SessionHandleSuffix suffix);
@@ -604,8 +629,8 @@ class SlotList {
void getSessionInfo(CK_SESSION_HANDLE sessionHandle,
CK_SESSION_INFO_PTR pInfo);
- void login(CK_SESSION_HANDLE hSession, CK_UTF8CHAR_PTR pPin,
- CK_ULONG ulPinLen);
+ void login(CK_SESSION_HANDLE hSession, CK_USER_TYPE user,
+ CK_UTF8CHAR_PTR pPin, CK_ULONG ulPinLen);
void logout(CK_SESSION_HANDLE hSession);
diff -up ./src/libckyapplet/cky_applet.c.p15 ./src/libckyapplet/cky_applet.c
--- ./src/libckyapplet/cky_applet.c.p15 2015-07-06 10:27:55.775827172 -0700
+++ ./src/libckyapplet/cky_applet.c 2015-07-06 10:27:55.787826946 -0700
@@ -19,6 +19,7 @@
#include <stdio.h>
#include "cky_applet.h"
+#include <string.h>
#define MIN(x, y) ((x) < (y) ? (x) : (y))
@@ -51,6 +52,12 @@ CACAppletFactory_SelectFile(CKYAPDU *apd
}
CKYStatus
+P15AppletFactory_SelectFile(CKYAPDU *apdu, const void *param)
+{
+ return CKYAPDUFactory_SelectFile(apdu, 0, 0, (const CKYBuffer *)param);
+}
+
+CKYStatus
CKYAppletFactory_SelectCardManager(CKYAPDU *apdu, const void *param)
{
return CKYAPDUFactory_SelectCardManager(apdu);
@@ -269,17 +276,10 @@ PIVAppletFactory_SignDecrypt(CKYAPDU *ap
}
CKYStatus
-CACAppletFactory_VerifyPIN(CKYAPDU *apdu, const void *param)
+P15AppletFactory_VerifyPIN(CKYAPDU *apdu, const void *param)
{
- const char *pin=(const char *)param;
- return CACAPDUFactory_VerifyPIN(apdu, CAC_LOGIN_GLOBAL, pin);
-}
-
-CKYStatus
-PIVAppletFactory_VerifyPIN(CKYAPDU *apdu, const void *param)
-{
- const char *pin=(const char *)param;
- return CACAPDUFactory_VerifyPIN(apdu, PIV_LOGIN_LOCAL, pin);
+ const P15AppletArgVerifyPIN *vps = (const P15AppletArgVerifyPIN *)param;
+ return P15APDUFactory_VerifyPIN(apdu, vps->pinRef, vps->pinVal);
}
CKYStatus
@@ -323,6 +323,39 @@ CKYAppletFactory_LogoutAllV0(CKYAPDU *ap
return CKYAPDU_SetSendData(apdu, data, sizeof(data));
}
+CKYStatus
+P15AppletFactory_ReadRecord(CKYAPDU *apdu, const void *param)
+{
+ const P15AppletArgReadRecord *rrs = (const P15AppletArgReadRecord *)param;
+ return P15APDUFactory_ReadRecord(apdu, rrs->record,
+ rrs->short_ef, rrs->flags, rrs->size);
+}
+
+CKYStatus
+P15AppletFactory_ReadBinary(CKYAPDU *apdu, const void *param)
+{
+ const P15AppletArgReadBinary *res = (const P15AppletArgReadBinary *)param;
+ return P15APDUFactory_ReadBinary(apdu, res->offset,
+ res->short_ef, res->flags, res->size);
+}
+
+CKYStatus
+P15AppletFactory_ManageSecurityEnvironment(CKYAPDU *apdu, const void *param)
+{
+ const P15AppletArgManageSecurityEnvironment *mse =
+ (const P15AppletArgManageSecurityEnvironment *)param;
+ return P15APDUFactory_ManageSecurityEnvironment(apdu, mse->p1,
+ mse->p2, mse->keyRef);
+}
+
+CKYStatus
+P15AppletFactory_PerformSecurityOperation(CKYAPDU *apdu, const void *param)
+{
+ const P15AppletArgPerformSecurityOperation *pso =
+ (const P15AppletArgPerformSecurityOperation *)param;
+ return P15APDUFactory_PerformSecurityOperation(apdu, pso->dir, pso->chain,
+ pso->retLen, pso->data);
+}
/*****************************************************************
*
* Generic Fill routines used by several calls in common
@@ -975,9 +1008,6 @@ CKYApplet_ComputeECCSignature(CKYCardCon
const CKYBuffer *data, CKYBuffer *sig,
CKYBuffer *result, const CKYBuffer *nonce, CKYISOStatus *apduRC)
{
- int use2APDUs = 0;
- int use_dl_object = 0;
- short dataSize = 0;
CKYStatus ret = CKYAPDUFAIL;
CKYAppletArgComputeECCSignature ccd;
CKYBuffer empty;
@@ -1052,6 +1082,11 @@ done:
return ret;
}
+const P15PinInfo CACPinInfo =
+ { P15PinInitialized|P15PinNeedsPadding, P15PinUTF8, 0, 8, 8, 0, 0xff };
+const P15PinInfo PIVPinInfo =
+ { P15PinLocal|P15PinInitialized|P15PinNeedsPadding,
+ P15PinUTF8, 0, 8, 8, 0, 0xff };
/*
* do a CAC VerifyPIN
*/
@@ -1059,23 +1094,8 @@ CKYStatus
CACApplet_VerifyPIN(CKYCardConnection *conn, const char *pin, int local,
CKYISOStatus *apduRC)
{
- CKYStatus ret;
- CKYISOStatus status;
- if (apduRC == NULL) {
- apduRC = &status;
- }
-
- ret = CKYApplet_HandleAPDU(conn, local ? PIVAppletFactory_VerifyPIN :
- CACAppletFactory_VerifyPIN, pin, NULL,
- 0, CKYAppletFill_Null,
- NULL, apduRC);
- /* it's unfortunate that the same code that means 'more data to follow' for
- * GetCertificate also means, auth failure, you only have N more attempts
- * left in the verify PIN call */
- if ((*apduRC & CKYISO_MORE_MASK) == CKYISO_MORE) {
- ret = CKYAPDUFAIL;
- }
- return ret;
+ return P15Applet_VerifyPIN(conn, pin,
+ local ? &PIVPinInfo: &CACPinInfo, apduRC);
}
@@ -1165,6 +1185,214 @@ CACApplet_ReadFile(CKYCardConnection *co
return ret;
}
+/*
+ * Select a EF
+ */
+CKYStatus
+P15Applet_SelectFile(CKYCardConnection *conn, unsigned short ef,
+ CKYISOStatus *apduRC)
+{
+ CKYStatus ret;
+ CKYBuffer efBuf;
+ CKYBuffer_InitEmpty(&efBuf);
+ CKYBuffer_AppendShort(&efBuf, ef);
+ ret = CKYApplet_HandleAPDU(conn, P15AppletFactory_SelectFile, &efBuf,
+ NULL, CKY_SIZE_UNKNOWN, CKYAppletFill_Null, NULL, apduRC);
+ CKYBuffer_FreeData(&efBuf);
+ return ret;
+}
+
+CKYStatus
+P15Applet_SelectRootFile(CKYCardConnection *conn, unsigned short ef,
+ CKYISOStatus *apduRC)
+{
+ CKYStatus ret;
+ CKYBuffer efBuf;
+ CKYBuffer_InitEmpty(&efBuf);
+ CKYBuffer_AppendShort(&efBuf, ef);
+ ret = CKYApplet_HandleAPDU(conn, CKYAppletFactory_SelectFile, &efBuf,
+ NULL, CKY_SIZE_UNKNOWN, CKYAppletFill_Null, NULL, apduRC);
+ CKYBuffer_FreeData(&efBuf);
+ return ret;
+}
+
+CKYStatus
+P15Applet_VerifyPIN(CKYCardConnection *conn, const char *pin,
+ const P15PinInfo *pinInfo, CKYISOStatus *apduRC)
+{
+ CKYStatus ret;
+ CKYISOStatus status;
+ CKYSize size;
+ CKYBuffer encodedPin;
+ P15AppletArgVerifyPIN vps;
+
+ CKYBuffer_InitEmpty(&encodedPin);
+
+ if (apduRC == NULL) {
+ apduRC = &status;
+ }
+
+ size = strlen(pin);
+ if (pinInfo->pinFlags & P15PinNeedsPadding) {
+ if (size > pinInfo->storedLength) {
+ size = pinInfo->storedLength;
+ }
+ ret=CKYBuffer_Reserve(&encodedPin, pinInfo->storedLength);
+ if (ret != CKYSUCCESS) { goto fail; }
+ }
+ /* This is where we would do upcase processing for the case insensitive
+ * flag. It's also where we would do mapping for bcd pins */
+ ret = CKYBuffer_Replace(&encodedPin, 0, (const CKYByte *)pin, size);
+ if (ret != CKYSUCCESS) { goto fail; }
+ if (pinInfo->pinFlags & P15PinNeedsPadding) {
+ int i;
+ int padSize = pinInfo->storedLength - size;
+ for (i=0; i < padSize; i++) {
+ CKYBuffer_AppendChar(&encodedPin, pinInfo->padChar);
+ }
+ }
+
+ vps.pinRef = pinInfo->pinRef |
+ ((pinInfo->pinFlags & P15PinLocal) ? ISO_LOGIN_LOCAL : ISO_LOGIN_GLOBAL);
+ vps.pinVal = &encodedPin;
+ ret = CKYApplet_HandleAPDU(conn, P15AppletFactory_VerifyPIN, &vps, NULL,
+ 0, CKYAppletFill_Null,
+ NULL, apduRC);
+ /* it's unfortunate that the same code that means 'more data to follow' for
+ * GetCertificate also means, auth failure, you only have N more attempts
+ * left in the verify PIN call */
+ if ((*apduRC & CKYISO_MORE_MASK) == CKYISO_MORE) {
+ ret = CKYAPDUFAIL;
+ }
+fail:
+ CKYBuffer_FreeData(&encodedPin);
+ return ret;
+}
+
+
+/*
+ * Read Record
+ */
+CKYStatus
+P15Applet_ReadRecord(CKYCardConnection *conn, CKYByte record, CKYByte short_ef,
+ CKYByte flags, CKYByte size, CKYBuffer *data, CKYISOStatus *apduRC)
+{
+ P15AppletArgReadRecord rrd;
+
+ rrd.record = record;
+ rrd.short_ef = short_ef;
+ rrd.flags = flags;
+ rrd.size = size;
+ return CKYApplet_HandleAPDU(conn, P15AppletFactory_ReadRecord, &rrd, NULL,
+ CKY_SIZE_UNKNOWN, CKYAppletFill_ReplaceBuffer, data, apduRC);
+}
+
+static CKYStatus
+P15Applet_ManageSecurityEnvironment(CKYCardConnection *conn, CKYByte key,
+ CKYByte direction, CKYByte p1,
+ CKYISOStatus *apduRC)
+{
+ P15AppletArgManageSecurityEnvironment mse;
+
+ mse.p1 = p1; /* this appears to be where most cards disagree */
+ mse.p2 = (direction == CKY_DIR_DECRYPT) ? ISO_MSE_KEA : ISO_MSE_SIGN;
+ mse.keyRef = key; /* should be CKYBuffer in the future? */
+ return CKYApplet_HandleAPDU(conn,
+ P15AppletFactory_ManageSecurityEnvironment, &mse, NULL,
+ CKY_SIZE_UNKNOWN, CKYAppletFill_Null, NULL, apduRC);
+}
+
+CKYStatus
+P15Applet_SignDecrypt(CKYCardConnection *conn, CKYByte key,
+ unsigned int keySize, CKYByte direction,
+ const CKYBuffer *data, CKYBuffer *result, CKYISOStatus *apduRC)
+{
+ CKYStatus ret;
+ P15AppletArgPerformSecurityOperation pso;
+ CKYSize dataSize = CKYBuffer_Size(data);
+ CKYOffset offset = 0;
+ CKYBuffer tmp;
+ int length = dataSize;
+ int appendLength = length;
+ int hasPad = 0;
+
+ /* Hack, lie and say we are always doing encipherment */
+ direction = CKY_DIR_DECRYPT;
+ CKYBuffer_Resize(result,0);
+ /*
+ * first set the security environment
+ */
+ ret = P15Applet_ManageSecurityEnvironment(conn, key, direction,
+ ISO_MSE_SET|ISO_MSE_QUAL_COMPUTE, apduRC);
+ if (ret != CKYSUCCESS) {
+ return ret;
+ }
+
+ CKYBuffer_InitEmpty(&tmp);
+
+ pso.data = &tmp;
+ pso.dir = direction;
+ if (direction == CKY_DIR_DECRYPT) {
+ length++;
+ CKYBuffer_AppendChar(&tmp, 0x00); /* pad byte */
+ hasPad = 1;
+ }
+ if (CKYCardConnection_GetProtocol(conn) == SCARD_PROTOCOL_T0) {
+ ret = CKYBuffer_Reserve(&tmp, CKY_MAX_WRITE_CHUNK_SIZE);
+ if (ret != CKYSUCCESS) {
+ goto done;
+ }
+ for(offset = 0; length > CKY_MAX_WRITE_CHUNK_SIZE;
+ hasPad = 0,
+ offset += CKY_MAX_WRITE_CHUNK_SIZE,
+ length -= CKY_MAX_WRITE_CHUNK_SIZE) {
+ pso.chain = 1;
+ pso.retLen = 0;
+ CKYBuffer_AppendBuffer(&tmp, data, offset,
+ hasPad ? (CKY_MAX_WRITE_CHUNK_SIZE-1) : CKY_MAX_WRITE_CHUNK_SIZE);
+ ret = CKYApplet_HandleAPDU(conn,
+ P15AppletFactory_PerformSecurityOperation, &pso, NULL,
+ CKY_SIZE_UNKNOWN, CKYAppletFill_Null, NULL, apduRC);
+ if (ret != CKYSUCCESS) {
+ goto done;
+ }
+ CKYBuffer_Resize(&tmp, 0);
+ }
+ appendLength = length;
+ } else {
+ ret = CKYBuffer_Reserve(&tmp, length);
+ }
+ CKYBuffer_AppendBuffer(&tmp, data, offset, appendLength);
+ pso.chain = 0;
+ pso.retLen = dataSize;
+
+ ret = CKYApplet_HandleAPDU(conn,
+ P15AppletFactory_PerformSecurityOperation, &pso, NULL,
+ CKY_SIZE_UNKNOWN, CKYAppletFill_ReplaceBuffer, result, apduRC);
+
+done:
+ CKYBuffer_FreeData(&tmp);
+ return ret;
+}
+
+/*
+ * Read Binary
+ */
+CKYStatus
+P15Applet_ReadBinary(CKYCardConnection *conn, unsigned short offset,
+ CKYByte short_ef, CKYByte flags, CKYByte size,
+ CKYBuffer *data, CKYISOStatus *apduRC)
+{
+ P15AppletArgReadBinary red;
+
+ red.offset = offset;
+ red.short_ef = short_ef;
+ red.flags = flags;
+ red.size = size;
+ return CKYApplet_HandleAPDU(conn, P15AppletFactory_ReadBinary, &red, NULL,
+ CKY_SIZE_UNKNOWN, CKYAppletFill_AppendBuffer, data, apduRC);
+}
+
CKYStatus
CACApplet_GetCertificateFirst(CKYCardConnection *conn, CKYBuffer *cert,
CKYSize *nextSize, CKYISOStatus *apduRC)
@@ -1632,6 +1860,7 @@ CKYApplet_ReadObjectFull(CKYCardConnecti
return ret;
}
+
/*
* Write Object
* This makes multiple APDU calls to write the entire object.
diff -up ./src/libckyapplet/cky_applet.h.p15 ./src/libckyapplet/cky_applet.h
--- ./src/libckyapplet/cky_applet.h.p15 2015-07-06 10:27:55.776827153 -0700
+++ ./src/libckyapplet/cky_applet.h 2015-07-06 10:27:55.788826927 -0700
@@ -204,6 +204,7 @@ typedef struct _CKYAppletArgReadObject {
CKYByte size;
} CKYAppletArgReadObject;
+
typedef struct _CKYAppletArgWriteObject {
unsigned long objectID;
CKYOffset offset;
@@ -262,6 +263,39 @@ typedef struct _PIVAppletRespSignDecrypt
CKYBuffer *buf;
} PIVAppletRespSignDecrypt;
+typedef struct _P15AppletArgReadRecord {
+ CKYByte record;
+ CKYByte short_ef;
+ CKYByte flags;
+ CKYByte size;
+} P15AppletArgReadRecord;
+
+typedef struct _P15AppletArgReadBinary {
+ unsigned short offset;
+ CKYByte short_ef;
+ CKYByte flags;
+ CKYByte size;
+} P15AppletArgReadBinary;
+
+typedef struct _P15AppletArgVerifyPIN {
+ const CKYBuffer *pinVal;
+ CKYByte pinRef;
+} P15AppletArgVerifyPIN;
+
+typedef struct _P15AppletArgManageSecurityEnvironment {
+ CKYByte p1;
+ CKYByte p2;
+ CKYByte keyRef;
+}
+ P15AppletArgManageSecurityEnvironment;
+
+typedef struct _P15AppletArgPerformSecurityOperation {
+ CKYByte dir;
+ int chain;
+ CKYSize retLen;
+ const CKYBuffer *data;
+} P15AppletArgPerformSecurityOperation;
+
/* fills in an APDU from a structure -- form of all the generic factories*/
typedef CKYStatus (*CKYAppletFactory)(CKYAPDU *apdu, const void *param);
/* fills in an a structure from a response -- form of all the fill structures*/
@@ -514,6 +548,7 @@ CKYStatus CACApplet_ReadFile(CKYCardConn
CKYStatus CACApplet_SelectFile(CKYCardConnection *conn, unsigned short ef,
CKYISOStatus *apduRC);
+
/* must happen with PKI applet selected */
CKYStatus CACApplet_SignDecrypt(CKYCardConnection *conn, const CKYBuffer *data,
CKYBuffer *result, CKYISOStatus *apduRC);
@@ -539,6 +574,26 @@ CKYStatus PIVApplet_SignDecrypt(CKYCardC
unsigned int keySize, int derive,
const CKYBuffer *data, CKYBuffer *result,
CKYISOStatus *apduRC);
+
+/* PKCS Commands 15 */
+CKYStatus P15Applet_SelectFile(CKYCardConnection *conn, unsigned short ef,
+ CKYISOStatus *apduRC);
+CKYStatus P15Applet_SelectRootFile(CKYCardConnection *conn, unsigned short ef,
+ CKYISOStatus *apduRC);
+CKYStatus P15Applet_ReadRecord(CKYCardConnection *conn, CKYByte record,
+ CKYByte short_ef, CKYByte flags, CKYByte size, CKYBuffer *data,
+ CKYISOStatus *apduRC);
+CKYStatus P15Applet_ReadBinary(CKYCardConnection *conn, unsigned short offset,
+ CKYByte short_ef, CKYByte flags, CKYByte size, CKYBuffer *data,
+ CKYISOStatus *apduRC);
+CKYStatus P15Applet_VerifyPIN(CKYCardConnection *conn, const char *pin,
+ const P15PinInfo *pinInfo, CKYISOStatus *apduRC);
+
+CKYStatus P15Applet_SignDecrypt(CKYCardConnection *conn, CKYByte key,
+ unsigned int keySize, CKYByte direction,
+ const CKYBuffer *data, CKYBuffer *result,
+ CKYISOStatus *apduRC);
+
/*
* There are 3 read commands:
*
diff -up ./src/libckyapplet/cky_base.c.p15 ./src/libckyapplet/cky_base.c
--- ./src/libckyapplet/cky_base.c.p15 2015-07-06 10:27:55.776827153 -0700
+++ ./src/libckyapplet/cky_base.c 2015-07-06 10:27:55.788826927 -0700
@@ -651,21 +651,38 @@ CKYStatus
CKYAPDU_SetSendData(CKYAPDU *apdu, const CKYByte *data, CKYSize len)
{
CKYStatus ret;
+ CKYOffset offset = 0;
- if (len > CKYAPDU_MAX_DATA_LEN) {
- return CKYDATATOOLONG;
- }
+ /* Encode with T1 if necessary */
- ret = CKYBuffer_Resize(&apdu->apduBuf, len + CKYAPDU_HEADER_LEN);
- if (ret != CKYSUCCESS) {
- return ret;
+ if (len < CKYAPDU_MAX_DATA_LEN) {
+ offset = 0;
+ ret = CKYBuffer_Resize(&apdu->apduBuf, len+offset+CKYAPDU_HEADER_LEN);
+ if (ret != CKYSUCCESS ) {
+ return ret;
+ }
+ ret = CKYBuffer_SetChar(&apdu->apduBuf, CKY_LC_OFFSET, (CKYByte) len);
+ } else if (len < CKYAPDU_MAX_T1_DATA_LEN) {
+ offset = 2;
+ ret = CKYBuffer_Resize(&apdu->apduBuf, len+offset+CKYAPDU_HEADER_LEN);
+ if (ret != CKYSUCCESS ) {
+ return ret;
+ }
+ ret = CKYBuffer_SetChar(&apdu->apduBuf, CKY_LC_OFFSET, (CKYByte) 0);
+ if (ret != CKYSUCCESS) {
+ return ret;
+ }
+ ret = CKYBuffer_SetShort(&apdu->apduBuf,CKY_LC_OFFSET+1,
+ (unsigned short)len);
+ } else {
+ return CKYDATATOOLONG;
}
- ret = CKYBuffer_SetChar(&apdu->apduBuf, CKY_LC_OFFSET,
- len == CKYAPDU_MAX_DATA_LEN ? 0: (CKYByte) len);
+
if (ret != CKYSUCCESS) {
return ret;
}
- return CKYBuffer_Replace(&apdu->apduBuf, CKYAPDU_HEADER_LEN, data, len);
+ return CKYBuffer_Replace(&apdu->apduBuf,
+ CKYAPDU_HEADER_LEN + offset , data, len);
}
CKYStatus
@@ -685,15 +702,15 @@ CKYAPDU_AppendSendData(CKYAPDU *apdu, co
}
dataLen = CKYBuffer_Size(&apdu->apduBuf) + len - CKYAPDU_HEADER_LEN;
- if (dataLen > CKYAPDU_MAX_DATA_LEN) {
+ /* only handles T0 encoding, not T1 encoding */
+ if (dataLen >= CKYAPDU_MAX_DATA_LEN) {
return CKYDATATOOLONG;
}
ret = CKYBuffer_AppendData(&apdu->apduBuf, data, len);
if (ret != CKYSUCCESS) {
return ret;
}
- return CKYBuffer_SetChar(&apdu->apduBuf, CKY_LC_OFFSET,
- dataLen == CKYAPDU_MAX_DATA_LEN ? 0 : (CKYByte) dataLen);
+ return CKYBuffer_SetChar(&apdu->apduBuf, CKY_LC_OFFSET, (CKYByte) dataLen);
}
CKYStatus
@@ -714,11 +731,100 @@ CKYAPDU_SetReceiveLen(CKYAPDU *apdu, CKY
}
CKYStatus
+CKYAPDU_SetShortReceiveLen(CKYAPDU *apdu, unsigned short recvlen)
+{
+ CKYStatus ret;
+
+ if (recvlen <= CKYAPDU_MAX_DATA_LEN) {
+ return APDU_SetReceiveLen(apdu, (CKYByte)(recvlen & 0xff));
+ }
+ ret = CKYBuffer_Resize(&apdu->apduBuf, CKYAPDU_HEADER_LEN+2);
+ if (ret != CKYSUCCESS) {
+ return ret;
+ }
+ ret = CKYBuffer_SetChar(&apdu->apduBuf, CKY_LE_OFFSET, 0);
+ if (ret != CKYSUCCESS) {
+ return ret;
+ }
+ return CKYBuffer_SetShort(&apdu->apduBuf, CKY_LE_OFFSET+1, recvlen);
+}
+
+CKYStatus
+CKYAPDU_SetReceiveLength(CKYAPDU *apdu, CKYSize recvlen)
+{
+ if (recvlen <= CKYAPDU_MAX_T1_DATA_LEN) {
+ return CKYAPDU_SetShortReceiveLen(apdu, (unsigned short)
+ (recvlen & 0xffff));
+ }
+ return CKYDATATOOLONG;
+}
+
+/*
+ * Append Le, If Le=0, treat it as 256 (CKYAPD_MAX_DATA_LEN)
+ */
+CKYStatus
CKYAPDU_AppendReceiveLen(CKYAPDU *apdu, CKYByte recvlen)
{
+ /* If we already have a data buffer, make sure that we aren't already
+ * using T1 encoding */
+ if (CKYBuffer_Size(&apdu->apduBuf) > CKYAPDU_MIN_LEN) {
+ if (CKYBuffer_GetChar(&apdu->apduBuf, CKY_LC_OFFSET) == 0) {
+ /* we are using T1 encoding, use AppendShort*/
+ return CKYBuffer_AppendShort(&apdu->apduBuf,
+ recvlen ? (unsigned short) recvlen: CKYAPDU_MAX_DATA_LEN);
+ }
+ }
return CKYBuffer_AppendChar(&apdu->apduBuf, recvlen);
}
+/*
+ * Append a short Le. If Le be encoded with just T0, do so. If Le=0 treat
+ * it as 65536 (CKYAPDU_MAX_T1_DATA_LEN)
+ */
+CKYStatus
+CKYAPDU_AppendShortReceiveLen(CKYAPDU *apdu, unsigned short recvlen)
+{
+ CKYStatus ret;
+ /* If we already have a data buffer, it's encoding affects ours */
+ if (CKYBuffer_Size(&apdu->apduBuf) > CKYAPDU_MIN_LEN) {
+ /* CKY_LC_OFFSET == 0 means T1, otherwise it's T0 */
+ if (CKYBuffer_GetChar(&apdu->apduBuf, CKY_LC_OFFSET) != 0) {
+ /* remember 0 is 65536 here */
+ if ((recvlen == 0) || (recvlen > CKYAPDU_MAX_DATA_LEN)) {
+ /* we can't a encode T1 receive length if we already have a
+ * T0 encoded buffer data */
+ return CKYDATATOOLONG;
+ }
+ /* T0 encoding */
+ return CKYBuffer_AppendChar(&apdu->apduBuf, (CKYByte)recvlen&0xff);
+ }
+ /* T1 encoding */
+ return CKYBuffer_AppendShort(&apdu->apduBuf, recvlen);
+ }
+ /* if length fits in a bit and we aren't forced into T1 encoding, use
+ * T0 */
+ if ((recvlen != 0) && (recvlen <= CKYAPDU_MAX_DATA_LEN)) {
+ return CKYBuffer_AppendChar(&apdu->apduBuf, (CKYByte)recvlen&0xff);
+ }
+ /* write the T1 encoding marker */
+ ret = CKYBuffer_AppendChar(&apdu->apduBuf, (CKYByte)0);
+ if (ret != CKYSUCCESS) {
+ return ret;
+ }
+ /* T1 encoded length */
+ return CKYBuffer_AppendShort(&apdu->apduBuf, recvlen);
+}
+
+CKYStatus
+CKYAPDU_AppendReceiveLength(CKYAPDU *apdu, CKYSize recvlen)
+{
+ if (recvlen > CKYAPDU_MAX_T1_DATA_LEN) {
+ return CKYDATATOOLONG;
+ }
+ return CKYAPDU_AppendShortReceiveLen(apdu,
+ (unsigned short)(recvlen & 0xffff));
+}
+
void
CKY_SetName(const char *p)
diff -up ./src/libckyapplet/cky_base.h.p15 ./src/libckyapplet/cky_base.h
--- ./src/libckyapplet/cky_base.h.p15 2015-07-06 10:27:55.777827135 -0700
+++ ./src/libckyapplet/cky_base.h 2015-07-06 10:27:55.789826908 -0700
@@ -32,6 +32,8 @@ typedef unsigned char CKYByte;
/* Bool type */
typedef unsigned char CKYBool;
+typedef unsigned long CKYBitFlags;
+
#define CKYBUFFER_PUBLIC \
unsigned long reserved1;\
unsigned long reserved2;\
@@ -93,6 +95,8 @@ typedef enum {
* (command) sent. ADPUIOStatus has more info on
* why the APDU failed */
CKYINVALIDARGS, /* Caller passed in bad args */
+ CKYINVALIDDATA, /* Data supplied was invalid */
+ CKYUNSUPPORTED, /* Requested Operation or feature is not supported */
} CKYStatus;
/*
@@ -107,12 +111,56 @@ typedef enum {
#define CKY_LE_OFFSET 4
#define CKYAPDU_MAX_DATA_LEN 256
+#define CKYAPDU_MAX_T1_DATA_LEN 65536
#define CKYAPDU_MIN_LEN 4
#define CKYAPDU_HEADER_LEN 5
#define CKYAPDU_MAX_LEN (CKYAPDU_HEADER_LEN+CKYAPDU_MAX_DATA_LEN)
#define CKY_MAX_ATR_LEN 32
#define CKY_OUTRAGEOUS_MALLOC_SIZE (1024*1024)
+#define P15FlagsPrivate 0x00000001
+#define P15FlagsModifiable 0x00000002
+
+#define P15UsageEncrypt 0x00000001
+#define P15UsageDecrypt 0x00000002
+#define P15UsageSign 0x00000004
+#define P15UsageSignRecover 0x00000008
+#define P15UsageWrap 0x00000010
+#define P15UsageUnwrap 0x00000020
+#define P15UsageVerify 0x00000040
+#define P15UsageVerifyRecover 0x00000080
+#define P15UsageDerive 0x00000100
+#define P15UsageNonRepudiation 0x00000200
+
+#define P15AccessSensitive 0x00000001
+#define P15AccessExtractable 0x00000002
+#define P15AccessAlwaysSenstive 0x00000004
+#define P15AccessNeverExtractable 0x00000008
+#define P15AccessLocal 0x00000010
+
+#define P15PinCaseSensitive 0x00000001
+#define P15PinLocal 0x00000002
+#define P15PinChangeDisabled 0x00000004
+#define P15PinUnblockDisabled 0x00000008
+#define P15PinInitialized 0x00000010
+#define P15PinNeedsPadding 0x00000020
+#define P15PinUnblockingPin 0x00000040
+#define P15PinSOPin 0x00000080
+#define P15PinDisableAllowed 0x00000100
+
+typedef enum {P15PinBCD=0, P15PinASCIINum=1, P15PinUTF8=2} P15PinType;
+
+typedef struct _P15PinInfo {
+ CKYBitFlags pinFlags;
+ P15PinType pinType;
+ CKYByte minLength;
+ CKYByte storedLength;
+ unsigned long maxLength;
+ CKYByte pinRef;
+ CKYByte padChar;
+} P15PinInfo;
+
+
/*
* allow direct inclusion in C++ files
*/
@@ -278,7 +326,11 @@ CKYStatus CKYAPDU_AppendSendDataBuffer(C
/* set Le in the APDU header to the amount of bytes expected to be
* returned. */
CKYStatus CKYAPDU_SetReceiveLen(CKYAPDU *apdu, CKYByte recvlen);
+CKYStatus CKYAPDU_SetShortReceiveLen(CKYAPDU *apdu, unsigned short recvlen);
+CKYStatus CKYAPDU_SetReceiveLength(CKYAPDU *apdu, CKYSize recvlen);
CKYStatus CKYAPDU_AppendReceiveLen(CKYAPDU *apdu, CKYByte recvlen);
+CKYStatus CKYAPDU_AppendShortReceiveLen(CKYAPDU *apdu, unsigned short recvlen);
+CKYStatus CKYAPDU_AppendReceiveLength(CKYAPDU *apdu, CKYSize recvlen);
/* set the parent loadmodule name */
void CKY_SetName(const char *name);
diff -up ./src/libckyapplet/cky_card.c.p15 ./src/libckyapplet/cky_card.c
--- ./src/libckyapplet/cky_card.c.p15 2015-07-06 10:27:55.778827116 -0700
+++ ./src/libckyapplet/cky_card.c 2015-07-06 10:27:55.790826889 -0700
@@ -910,6 +910,7 @@ ckyCardConnection_init(CKYCardConnection
conn->protocol = SCARD_PROTOCOL_T0;
}
+
CKYCardConnection *
CKYCardConnection_Create(const CKYCardContext *ctx)
{
@@ -984,6 +985,12 @@ CKYCardConnection_IsConnected(const CKYC
return (conn->cardHandle != 0);
}
+unsigned long
+CKYCardConnection_GetProtocol(const CKYCardConnection *conn)
+{
+ return conn->protocol;
+}
+
CKYStatus
ckyCardConnection_reconnectRaw(CKYCardConnection *conn, unsigned long init)
{
@@ -996,6 +1003,7 @@ ckyCardConnection_reconnectRaw(CKYCardCo
conn->lastError = rv;
return CKYSCARDERR;
}
+ conn->protocol = protocol;
return CKYSUCCESS;
}
diff -up ./src/libckyapplet/cky_card.h.p15 ./src/libckyapplet/cky_card.h
--- ./src/libckyapplet/cky_card.h.p15 2015-07-06 10:27:55.766827342 -0700
+++ ./src/libckyapplet/cky_card.h 2015-07-06 10:27:55.790826889 -0700
@@ -116,6 +116,7 @@ CKYStatus CKYCardConnection_ExchangeAPDU
CKYStatus CKYCardConnection_Connect(CKYCardConnection *connection,
const char *readerName);
CKYStatus CKYCardConnection_Disconnect(CKYCardConnection *connection);
+unsigned long CKYCardConnection_GetProtocol(const CKYCardConnection *conn);
CKYBool CKYCardConnection_IsConnected(const CKYCardConnection *connection);
CKYStatus CKYCardConnection_Reconnect(CKYCardConnection *connection);
CKYStatus CKYCardConnection_GetStatus(CKYCardConnection *connection,
diff -up ./src/libckyapplet/cky_factory.c.p15 ./src/libckyapplet/cky_factory.c
--- ./src/libckyapplet/cky_factory.c.p15 2015-07-06 10:27:55.778827116 -0700
+++ ./src/libckyapplet/cky_factory.c 2015-07-06 10:27:55.791826870 -0700
@@ -29,7 +29,7 @@ CKYAPDUFactory_SelectFile(CKYAPDU *apdu,
const CKYBuffer *AID)
{
CKYAPDU_SetCLA(apdu, CKY_CLASS_ISO7816);
- CKYAPDU_SetINS(apdu, CKY_INS_SELECT_FILE);
+ CKYAPDU_SetINS(apdu, ISO_INS_SELECT_FILE);
CKYAPDU_SetP1(apdu, p1);
CKYAPDU_SetP2(apdu, p2);
return CKYAPDU_SetSendDataBuffer(apdu, AID);
@@ -40,7 +40,7 @@ CKYAPDUFactory_SelectCardManager(CKYAPDU
{
CKYByte c = 0;
CKYAPDU_SetCLA(apdu, CKY_CLASS_ISO7816);
- CKYAPDU_SetINS(apdu, CKY_INS_SELECT_FILE);
+ CKYAPDU_SetINS(apdu, ISO_INS_SELECT_FILE);
CKYAPDU_SetP1(apdu, 0x04);
CKYAPDU_SetP2(apdu, 0x00);
/* I can't find the documentation for this, but if you pass an empty
@@ -57,7 +57,7 @@ CKYStatus
CKYAPDUFactory_GetCPLCData(CKYAPDU *apdu)
{
CKYAPDU_SetCLA(apdu, CKY_CLASS_GLOBAL_PLATFORM);
- CKYAPDU_SetINS(apdu, CKY_INS_GET_DATA);
+ CKYAPDU_SetINS(apdu, ISO_INS_GET_DATA);
CKYAPDU_SetP1(apdu, 0x9f);
CKYAPDU_SetP2(apdu, 0x7f);
return CKYAPDU_SetReceiveLen(apdu, CKY_SIZE_GET_CPLCDATA);
@@ -707,6 +707,7 @@ fail:
CKYBuffer_FreeData(&buf);
return ret;
}
+
CKYStatus
CACAPDUFactory_GetProperties(CKYAPDU *apdu)
{
@@ -718,37 +719,6 @@ CACAPDUFactory_GetProperties(CKYAPDU *ap
}
CKYStatus
-CACAPDUFactory_VerifyPIN(CKYAPDU *apdu, CKYByte keyRef, const char *pin)
-{
- CKYStatus ret;
- CKYSize size;
-
- CKYAPDU_SetCLA(apdu, CKY_CLASS_ISO7816);
- CKYAPDU_SetINS(apdu, CAC_INS_VERIFY_PIN);
- CKYAPDU_SetP1(apdu, 0x00);
- CKYAPDU_SetP2(apdu, keyRef);
- /* no pin, send an empty buffer */
- if (!pin) {
- return CKYAPDU_SetReceiveLen(apdu, 0);
- }
-
- /* all CAC pins are 8 bytes exactly. If to long, truncate it */
- size = strlen(pin);
- if (size > 8) {
- size = 8;
- }
- ret = CKYAPDU_SetSendData(apdu, (unsigned char *) pin, size);
- /* if too short, pad it */
- if ((ret == CKYSUCCESS) && (size < 8)) {
- static const unsigned char pad[]= { 0xff , 0xff, 0xff ,0xff,
- 0xff, 0xff, 0xff, 0xff };
- return CKYAPDU_AppendSendData(apdu, pad, 8-size);
- }
- return ret;
-
-}
-
-CKYStatus
PIVAPDUFactory_SignDecrypt(CKYAPDU *apdu, CKYByte chain, CKYByte alg,
CKYByte key, int len, const CKYBuffer *data)
{
@@ -807,3 +777,109 @@ fail:
return ret;
}
+CKYStatus
+P15APDUFactory_VerifyPIN(CKYAPDU *apdu, CKYByte keyRef, const CKYBuffer *pin)
+{
+ CKYStatus ret;
+
+ CKYAPDU_SetCLA(apdu, CKY_CLASS_ISO7816);
+ CKYAPDU_SetINS(apdu, CAC_INS_VERIFY_PIN);
+ CKYAPDU_SetP1(apdu, 0x00);
+ CKYAPDU_SetP2(apdu, keyRef);
+ /* no pin, send an empty buffer */
+ if (CKYBuffer_Size(pin) == 0) {
+ return CKYAPDU_SetReceiveLen(apdu, 0);
+ }
+
+ /* all CAC pins are 8 bytes exactly. If to long, truncate it */
+ ret = CKYAPDU_SetSendDataBuffer(apdu, pin);
+ return ret;
+
+}
+
+CKYStatus
+P15APDUFactory_ReadRecord(CKYAPDU *apdu, CKYByte record, CKYByte short_ef,
+ CKYByte flags, CKYByte count)
+{
+ CKYByte control;
+
+ control = (short_ef << 3) & 0xf8;
+ control |= flags & 0x07;
+
+ CKYAPDU_SetCLA(apdu, CKY_CLASS_ISO7816);
+ CKYAPDU_SetINS(apdu, ISO_INS_READ_RECORD);
+ CKYAPDU_SetP1(apdu, record);
+ CKYAPDU_SetP2(apdu, control);
+ return CKYAPDU_SetReceiveLen(apdu, count);
+}
+
+CKYStatus
+P15APDUFactory_ReadBinary(CKYAPDU *apdu, unsigned short offset,
+ CKYByte short_ef, CKYByte flags, CKYByte count)
+{
+ CKYByte p1 = 0,p2 = 0;
+ unsigned short max_offset = 0;
+
+ if (flags & P15_USE_SHORT_EF) {
+ max_offset = 0xff;
+ p1 = P15_USE_SHORT_EF | (short_ef & 0x7);
+ p2 = offset & 0xff;
+ } else {
+ max_offset = 0x7fff;
+ p1 = (offset >> 8) & 0x7f;
+ p2 = offset & 0xff;
+ }
+ if (offset > max_offset) {
+ return CKYINVALIDARGS;
+ }
+
+ CKYAPDU_SetCLA(apdu, CKY_CLASS_ISO7816);
+ CKYAPDU_SetINS(apdu, ISO_INS_READ_BINARY);
+ CKYAPDU_SetP1(apdu, p1);
+ CKYAPDU_SetP2(apdu, p2);
+ return CKYAPDU_SetReceiveLen(apdu, count);
+}
+
+CKYStatus
+P15APDUFactory_ManageSecurityEnvironment(CKYAPDU *apdu, CKYByte p1, CKYByte p2,
+ CKYByte keyRef)
+{
+ CKYByte param[3];
+
+ CKYAPDU_SetCLA(apdu, CKY_CLASS_ISO7816);
+ CKYAPDU_SetINS(apdu, ISO_INS_MANAGE_SECURITY_ENVIRONMENT);
+ CKYAPDU_SetP1(apdu, p1);
+ CKYAPDU_SetP2(apdu, p2);
+ param[0] = 0x83;
+ param[1] = 1;
+ param[2] = keyRef;
+ return CKYAPDU_SetSendData(apdu, param, sizeof param);
+}
+
+CKYStatus
+P15APDUFactory_PerformSecurityOperation(CKYAPDU *apdu, CKYByte dir,
+ int chain, CKYSize retLen, const CKYBuffer *data)
+{
+ CKYByte p1,p2;
+ CKYStatus ret;
+
+ CKYAPDU_SetCLA(apdu, chain ? CKY_CLASS_ISO7816_CHAIN :
+ CKY_CLASS_ISO7816);
+ CKYAPDU_SetINS(apdu, ISO_INS_PERFORM_SECURITY_OPERATION);
+ if (dir == CKY_DIR_DECRYPT) {
+ p1 = ISO_PSO_DECRYPT_P1;
+ p2 = ISO_PSO_DECRYPT_P2;
+ } else {
+ p1 = ISO_PSO_SIGN_P1;
+ p2 = ISO_PSO_SIGN_P2;
+ }
+ CKYAPDU_SetP1(apdu, p1);
+ CKYAPDU_SetP2(apdu, p2);
+ ret = CKYAPDU_SetSendDataBuffer(apdu, data);
+ if (ret == CKYSUCCESS && (chain == 0) && retLen != 0) {
+ ret = CKYAPDU_AppendReceiveLength(apdu, retLen);
+ }
+ return ret;
+}
+
+
diff -up ./src/libckyapplet/cky_factory.h.p15 ./src/libckyapplet/cky_factory.h
--- ./src/libckyapplet/cky_factory.h.p15 2015-07-06 10:27:55.779827097 -0700
+++ ./src/libckyapplet/cky_factory.h 2015-07-06 10:27:55.791826870 -0700
@@ -35,8 +35,31 @@
* Applet Instruction Bytes
*/
/* Card Manager */
-#define CKY_INS_SELECT_FILE 0xa4
-#define CKY_INS_GET_DATA 0xca
+#define ISO_INS_SELECT_FILE 0xa4
+#define ISO_INS_GET_DATA 0xca
+#define ISO_INS_READ_BINARY 0xb0
+#define ISO_INS_READ_RECORD 0xb2
+#define ISO_INS_MANAGE_SECURITY_ENVIRONMENT 0x22
+#define ISO_INS_PERFORM_SECURITY_OPERATION 0x2a
+
+/* ISO Parameters: */
+#define ISO_LOGIN_LOCAL 0x80
+#define ISO_LOGIN_GLOBAL 0x00
+#define ISO_MSE_SET 0x01
+#define ISO_MSE_STORE 0xf2
+#define ISO_MSE_RESTORE 0xf3
+#define ISO_MSE_ERASE 0xf4
+#define ISO_MSE_QUAL_VERIFY 0x80
+#define ISO_MSE_QUAL_COMPUTE 0x40
+#define ISO_MSE_AUTH 0xa4
+#define ISO_MSE_SIGN 0xb6
+#define ISO_MSE_KEA 0xb8
+#define ISO_PSO_SIGN_P1 0x9e
+#define ISO_PSO_SIGN_P2 0x9a
+#define ISO_PSO_ENCRYPT_P1 0x86
+#define ISO_PSO_ENCRYPT_P2 0x80
+#define ISO_PSO_DECRYPT_P1 0x80
+#define ISO_PSO_DECRYPT_P2 0x86
/* deprecated */
#define CKY_INS_SETUP 0x2A
@@ -84,6 +107,7 @@
#define CKY_INS_SEC_READ_IOBUF 0x08
#define CKY_INS_SEC_START_ENROLLMENT 0x0C
+
/* CAC */
#define CAC_INS_GET_CERTIFICATE 0x36
#define CAC_INS_SIGN_DECRYPT 0x42
@@ -94,11 +118,8 @@
#define CAC_SIZE_GET_PROPERTIES 48
#define CAC_P1_STEP 0x80
#define CAC_P1_FINAL 0x00
-#define CAC_LOGIN_GLOBAL 0x00
/* PIV */
-#define PIV_LOGIN_LOCAL 0x80
-#define PIV_LOGIN_GLOBAL CAC_LOGIN_GLOBAL
#define PIV_INS_GEN_AUTHENTICATE 0x87
/*
@@ -121,7 +142,7 @@
/* functions */
#define CKY_CIPHER_INIT 1
#define CKY_CIPHER_PROCESS 2
-#define CKY_CIPHER_FINAL 3
+#define CKY_CIPHER_FINAL 3
#define CKY_CIPHER_ONE_STEP 4 /* init and final in one APDU */
/* modes */
@@ -173,6 +194,18 @@
#define CKY_CARDM_MANAGER_LOCKED 0x7f
#define CKY_CARDM_MANAGER_TERMINATED 0xff
+/* Read Record Flags */
+#define P15_READ_P1 0x4
+#define P15_READ_P1_TO_LAST 0x5
+#define P15_READ_LAST_TO_P1 0x6
+#define P15_READ_FIRST 0x0
+#define P15_READ_LAST 0x1
+#define P15_READ_NEXT 0x2
+#define P15_READ_PREV 0x3
+
+/* Read Binary Flags */
+#define P15_USE_SHORT_EF 0x80
+
/*
* The following factories 'Fill in' APDUs for each of the
* functions described below. Nonces are not automatically added.
@@ -234,17 +267,28 @@ CKYStatus CKYAPDUFactory_GetBuiltinACL(C
CKYStatus CACAPDUFactory_SignDecrypt(CKYAPDU *apdu, CKYByte type,
const CKYBuffer *data);
-CKYStatus CACAPDUFactory_VerifyPIN(CKYAPDU *apdu, CKYByte keyRef,
- const char *pin);
CKYStatus CACAPDUFactory_GetCertificate(CKYAPDU *apdu, CKYSize size);
CKYStatus CACAPDUFactory_ReadFile(CKYAPDU *apdu, unsigned short offset,
CKYByte type, CKYByte count);
CKYStatus CACAPDUFactory_GetProperties(CKYAPDU *apdu);
+
CKYStatus PIVAPDUFactory_GetData(CKYAPDU *apdu, const CKYBuffer *object,
CKYByte count);
CKYStatus PIVAPDUFactory_SignDecrypt(CKYAPDU *apdu, CKYByte chain, CKYByte alg,
CKYByte key, int len, const CKYBuffer *data);
+CKYStatus P15APDUFactory_VerifyPIN(CKYAPDU *apdu, CKYByte keyRef,
+ const CKYBuffer *pin);
+CKYStatus P15APDUFactory_ReadRecord(CKYAPDU *apdu, CKYByte record,
+ CKYByte short_ef, CKYByte flags, CKYByte count);
+CKYStatus P15APDUFactory_ReadBinary(CKYAPDU *apdu, unsigned short offset,
+ CKYByte short_ef, CKYByte flags, CKYByte count);
+CKYStatus P15APDUFactory_ManageSecurityEnvironment(CKYAPDU *apdu,
+ CKYByte p1, CKYByte p2, CKYByte key);
+CKYStatus P15APDUFactory_PerformSecurityOperation(CKYAPDU *apdu, CKYByte dir,
+ int chain, CKYSize retLen, const CKYBuffer *data);
+
+
CKY_END_PROTOS
#endif /* CKY_FACTORY_H */
Reference in New Issue View Git Blame Copy Permalink