360 lines
14 KiB
C
360 lines
14 KiB
C
/*
|
|
* The contents of this file are subject to the Mozilla Public
|
|
* License Version 1.1 (the "License"); you may not use this file
|
|
* except in compliance with the License. You may obtain a copy of
|
|
* the License at http://www.mozilla.org/MPL/
|
|
*
|
|
* Software distributed under the License is distributed on an "AS
|
|
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
|
* implied. See the License for the specific language governing
|
|
* rights and limitations under the License.
|
|
*
|
|
* The Original Code is the Netscape security libraries.
|
|
*
|
|
* The Initial Developer of the Original Code is Netscape
|
|
* Communications Corporation. Portions created by Netscape are
|
|
* Copyright (C) 1994-2000 Netscape Communications Corporation. All
|
|
* Rights Reserved.
|
|
*
|
|
* Contributor(s):
|
|
*
|
|
* Alternatively, the contents of this file may be used under the
|
|
* terms of the GNU General Public License Version 2 or later (the
|
|
* "GPL"), in which case the provisions of the GPL are applicable
|
|
* instead of those above. If you wish to allow use of your
|
|
* version of this file only under the terms of the GPL and not to
|
|
* allow others to use your version of this file under the MPL,
|
|
* indicate your decision by deleting the provisions above and
|
|
* replace them with the notice and other provisions required by
|
|
* the GPL. If you do not delete the provisions above, a recipient
|
|
* may use your version of this file under either the MPL or the
|
|
* GPL.
|
|
*/
|
|
#ifndef __PROTOCOLF_H__
|
|
#define __PROTOCOLF_H__
|
|
/*************************************************************************
|
|
* For each type of message, parse and pack function is provided.
|
|
*
|
|
* Parse functions accept a ptr to the "blob" of data received from the
|
|
* network and fill in fields of the message, numbers in host-order, strings
|
|
* as C-style NULL-terminated strings. Return SSMPRStatus.
|
|
*
|
|
* Pack functions take all the info to construct a message and fill in a
|
|
* ptr to the "blob" of data to be sent. Return length of the data blob, or
|
|
* a zero in case of an error
|
|
*
|
|
* All functions set NSPR errors when necessary.
|
|
************************************************************************/
|
|
#include "protocol.h"
|
|
#include "cert.h"
|
|
|
|
SSMPRStatus SSM_ParseHelloRequest(void * helloRequest,
|
|
SSMPRUint32 * version,
|
|
PRBool * doesUI,
|
|
PRInt32 * policyType,
|
|
SSMPRUint32 * profileLen,
|
|
char ** profile);
|
|
SSMPRInt32 SSM_PackHelloReply(void ** helloReply, SSMPRInt32 result,
|
|
SSMPRUint32 sessionID, SSMPRUint32 version,
|
|
SSMPRUint32 httpPort, SSMPRUint32 nonceLen,
|
|
char * nonce, SSMPolicyType policy);
|
|
|
|
/* Parse data connections requests */
|
|
SSMPRStatus SSM_ParseSSLDataConnectionRequest(void *sslRequest,
|
|
SSMPRUint32 * flags,
|
|
SSMPRUint32 * port,
|
|
SSMPRUint32 * hostIPLen,
|
|
char ** hostIP,
|
|
SSMPRUint32 * hostNameLen,
|
|
char ** hostName);
|
|
SSMPRStatus SSM_ParseHashStreamRequest(void * hashStreamRequest,
|
|
SSMPRUint32 * type);
|
|
SSMPRStatus SSM_ParseP7EncodeConnectionRequest(void *request,
|
|
SSMPRUint32 *ciRID);
|
|
/* Messages to initiate PKCS7 data connection */
|
|
/* PKCS7DecodeRequest message has no data */
|
|
|
|
/* Single data connection reply */
|
|
SSMPRInt32 SSM_PackDataConnectionReply(void ** sslReply,
|
|
SSMPRInt32 result,
|
|
SSMPRUint32 connID,
|
|
SSMPRUint32 port);
|
|
|
|
SSMPRStatus SSM_ParseSSLSocketStatusRequest(void * statusRequest,
|
|
SSMPRUint32 * connID);
|
|
SSMPRInt32 SSM_PackSSLSocketStatusReply(void ** statusReply,
|
|
SSMPRInt32 result,
|
|
SSMPRUint32 resourceID);
|
|
|
|
/*
|
|
* UI event is an asynchroneous message sent from PSM server to the client
|
|
* NOTE: (context) is the actual context pointer, it is NOT a ptr-to-ptr.
|
|
* The value of (context) is copied into the packet.
|
|
*/
|
|
SSMPRInt32 SSM_PackUIEvent(void ** eventRequest, SSMPRUint32 resourceID,
|
|
SSMPRUint32 width, SSMPRUint32 height,
|
|
SSMPRUint32 urlLen, char * url);
|
|
|
|
SSMPRInt32 SSM_PackTaskCompletedEvent(void **event, SSMPRUint32 resourceID,
|
|
SSMPRUint32 numTasks, SSMPRUint32 result);
|
|
|
|
/* Verify raw signature */
|
|
|
|
SSMPRStatus SSM_ParseVerifyRawSigRequest(void * verifyRawSigRequest,
|
|
SSMPRUint32 * algorithmID,
|
|
SSMPRUint32 * paramsLen,
|
|
unsigned char ** params,
|
|
SSMPRUint32 * pubKeyLen,
|
|
unsigned char ** pubKey,
|
|
SSMPRUint32 * hashLen,
|
|
unsigned char ** hash,
|
|
SSMPRUint32 * signatureLen,
|
|
unsigned char ** signature);
|
|
SSMPRInt32 SSM_PackVerifyRawSigReply(void ** verifyRawSigReply,
|
|
SSMPRInt32 result);
|
|
|
|
/* Verify detached signature */
|
|
SSMPRStatus SSM_ParseVerifyDetachedSigRequest(void * request,
|
|
SSMPRInt32 * pkcs7ContentID,
|
|
SSMPRInt32 * certUsage,
|
|
SSMPRInt32 * hashAlgID,
|
|
SSMPRUint32 * keepCert,
|
|
SSMPRUint32 * digestLen,
|
|
unsigned char ** hash);
|
|
|
|
SSMPRInt32 SSM_PackVerifyDetachedSigReply(void ** verifyDetachedSigReply,
|
|
SSMPRInt32 result);
|
|
|
|
/* PKCS#7 functions */
|
|
SSMPRStatus SSM_ParseCreateSignedRequest(void *request,
|
|
SSMPRInt32 *scertRID,
|
|
SSMPRInt32 *ecertRID,
|
|
SSMPRUint32 *dig_alg,
|
|
SECItem **digest);
|
|
|
|
SSMPRInt32 SSM_PackCreateSignedReply(void **reply, SSMPRInt32 ciRID,
|
|
SSMPRUint32 result);
|
|
|
|
SSMPRStatus SSM_ParseCreateEncryptedRequest(void *request,
|
|
SSMPRInt32 *scertRID,
|
|
SSMPRInt32 *nrcerts,
|
|
SSMPRInt32 **rcertRIDs);
|
|
|
|
SSMPRInt32 SSM_PackCreateEncryptedReply(void **reply, SSMPRInt32 ciRID,
|
|
SSMPRUint32 result);
|
|
|
|
/* Resource functions */
|
|
SSMPRStatus SSM_ParseCreateResourceRequest(void *request,
|
|
SSMPRUint32 *type,
|
|
unsigned char **params,
|
|
SSMPRUint32 *paramLen);
|
|
|
|
SSMPRStatus SSM_PackCreateResourceReply(void **reply, SSMPRStatus rv,
|
|
SSMPRUint32 resID);
|
|
|
|
SSMPRStatus SSM_ParseGetAttribRequest(void * getAttribRequest,
|
|
SSMPRUint32 * resourceID,
|
|
SSMPRUint32 * fieldID);
|
|
|
|
void SSM_DestroyAttrValue(SSMAttributeValue *value, PRBool freeit);
|
|
|
|
SSMPRInt32 SSM_PackGetAttribReply(void **getAttribReply,
|
|
SSMPRInt32 result,
|
|
SSMAttributeValue *value);
|
|
SSMPRStatus SSM_ParseSetAttribRequest(SECItem *msg,
|
|
SSMPRInt32 *resourceID,
|
|
SSMPRInt32 *fieldID,
|
|
SSMAttributeValue *value);
|
|
/* Currently, there is no need for a pack version. There is nothing to send
|
|
* back except for the notice that the operation was successful.
|
|
*/
|
|
|
|
|
|
|
|
/* Pickle and unpickle resources. */
|
|
SSMPRStatus SSM_ParsePickleResourceRequest(void * pickleResourceRequest,
|
|
SSMPRUint32 * resourceID);
|
|
SSMPRInt32 SSM_PackPickleResourceReply(void ** pickleResourceReply,
|
|
SSMPRInt32 result,
|
|
SSMPRUint32 resourceLen,
|
|
void * resource);
|
|
SSMPRStatus SSM_ParseUnpickleResourceRequest(void * unpickleResourceRequest,
|
|
SSMPRUint32 blobSize,
|
|
SSMPRUint32 * resourceType,
|
|
SSMPRUint32 * resourceLen,
|
|
void ** resource);
|
|
SSMPRInt32 SSM_PackUnpickleResourceReply(void ** unpickleResourceReply,
|
|
SSMPRInt32 result,
|
|
SSMPRUint32 resourceID);
|
|
|
|
/* Destroy resource */
|
|
SSMPRStatus SSM_ParseDestroyResourceRequest(void * destroyResourceRequest,
|
|
SSMPRUint32 * resourceID,
|
|
SSMPRUint32 * resourceType);
|
|
SSMPRInt32 SSM_PackDestroyResourceReply(void ** destroyResourceReply,
|
|
SSMPRInt32 result);
|
|
|
|
/* Duplicate resource */
|
|
SSMPRStatus SSM_ParseDuplicateResourceRequest(void * request,
|
|
SSMPRUint32 * resourceID);
|
|
SSMPRInt32 SSM_PackDuplicateResourceReply(void ** reply, SSMPRInt32 result,
|
|
SSMPRUint32 resID);
|
|
|
|
/* Cert actions */
|
|
typedef struct MatchUserCertRequestData {
|
|
PRUint32 certType;
|
|
PRInt32 numCANames;
|
|
char ** caNames;
|
|
} MatchUserCertRequestData;
|
|
|
|
typedef struct SSMCertList {
|
|
PRCList certs;
|
|
PRInt32 count;
|
|
} SSMCertList;
|
|
|
|
typedef struct SSMCertListElement {
|
|
PRCList links;
|
|
PRUint32 certResID;
|
|
} SSMCertListElement;
|
|
|
|
#define SSM_CERT_LIST_ELEMENT_PTR(_q) (SSMCertListElement*)(_q);
|
|
|
|
SSMPRStatus SSM_ParseVerifyCertRequest(void * verifyCertRequest,
|
|
SSMPRUint32 * resourceID,
|
|
SSMPRInt32 * certUsage);
|
|
SSMPRInt32 SSM_PackVerifyCertReply(void ** verifyCertReply,
|
|
SSMPRInt32 result);
|
|
|
|
SSMPRStatus SSM_ParseImportCertRequest(void * importCertRequest,
|
|
SSMPRUint32 * blobLen,
|
|
void ** certBlob);
|
|
SSMPRInt32 SSM_PackImportCertReply(void ** importCertReply, SSMPRInt32 result,
|
|
SSMPRUint32 resourceID);
|
|
PRStatus SSM_ParseFindCertByNicknameRequest(void *request, char ** nickname);
|
|
PRInt32 SSM_PackFindCertByNicknameReply(void ** reply, PRUint32 resourceID);
|
|
PRStatus SSM_ParseFindCertByKeyRequest(void *request, SECItem ** key);
|
|
PRInt32 SSM_PackFindCertByKeyReply(void ** reply, PRUint32 resourceID);
|
|
PRStatus SSM_ParseFindCertByEmailAddrRequest(void *request, char ** emailAddr);
|
|
PRInt32 SSM_PackFindCertByEmailAddrReply(void ** reply, PRUint32 resourceID);
|
|
PRStatus SSM_ParseAddTempCertToDBRequest(void *request, PRUint32 *resourceID, char ** nickname, PRInt32 *ssl, PRInt32 *email, PRInt32 *objectSigning);
|
|
PRInt32 SSM_PackAddTempCertToDBReply(void ** reply);
|
|
PRStatus SSM_ParseMatchUserCertRequest(void *request, MatchUserCertRequestData** data);
|
|
PRInt32 SSM_PackMatchUserCertReply(void **reply, SSMCertList * certList);
|
|
|
|
SSMPRInt32 SSM_PackErrorMessage(void ** errorReply, SSMPRInt32 result);
|
|
|
|
|
|
/* PKCS11 actions */
|
|
SSMPRStatus SSM_ParseKeyPairGenRequest(void *keyPairGenRequest,
|
|
SSMPRInt32 requestLen,
|
|
SSMPRUint32 *keyPairCtxtID,
|
|
SSMPRUint32 *genMechanism,
|
|
SSMPRUint32 *keySize,
|
|
unsigned char **params,
|
|
SSMPRUint32 *paramLen);
|
|
|
|
SSMPRInt32 SSM_PackKeyPairGenResponse(void ** keyPairGenResponse,
|
|
SSMPRUint32 keyPairId);
|
|
|
|
PRStatus
|
|
SSM_ParseFinishKeyGenRequest(void *finishKeyGenRequest,
|
|
PRInt32 requestLen,
|
|
PRInt32 *keyGenContext);
|
|
|
|
/* CMMF/CRMF Actions */
|
|
SSMPRStatus SSM_ParseCreateCRMFReqRequest(void *crmfReqRequest,
|
|
SSMPRInt32 requestLen,
|
|
SSMPRUint32 *keyPairId);
|
|
|
|
SSMPRInt32 SSM_PackCreateCRMFReqReply(void **crmfReqReply,
|
|
SSMPRUint32 crmfReqId);
|
|
|
|
SSMPRStatus SSM_ParseEncodeCRMFReqRequest(void *encodeReq,
|
|
SSMPRInt32 requestLen,
|
|
SSMPRUint32 **crmfReqId,
|
|
SSMPRInt32 *numRequests);
|
|
|
|
SSMPRInt32 SSM_PackEncodeCRMFReqReply(void **encodeReply,
|
|
char *crmfDER,
|
|
SSMPRUint32 derLen);
|
|
|
|
SSMPRStatus SSM_ParseCMMFCertResponse(void *encodedRes,
|
|
SSMPRInt32 encodeLen,
|
|
char **nickname,
|
|
char **base64Der,
|
|
PRBool *doBackup);
|
|
|
|
PRStatus SSM_ParsePOPChallengeRequest(void *challenge,
|
|
PRInt32 len,
|
|
char **responseString);
|
|
PRInt32 SSM_PackPOPChallengeResponse(void **response,
|
|
char *responseString,
|
|
PRInt32 responseStringLen);
|
|
|
|
PRInt32 SSM_PackPasswdRequest(void ** passwdRequest, PRInt32 tokenID,
|
|
char * prompt, PRInt32 promptLen);
|
|
PRStatus SSM_ParsePasswordReply(void * passwdReply, PRInt32 * result,
|
|
PRInt32 * tokenID,
|
|
char ** passwd, PRInt32 * passwdLen);
|
|
|
|
/* Sign Text Actions */
|
|
typedef struct {
|
|
char *stringToSign;
|
|
char *hostName;
|
|
char *caOption;
|
|
PRInt32 numCAs;
|
|
char **caNames;
|
|
} signTextRequestData;
|
|
|
|
PRStatus SSM_ParseSignTextRequest(void* signTextRequest, PRInt32 len, PRUint32* resID, signTextRequestData ** data);
|
|
|
|
PRStatus SSM_ParseGetLocalizedTextRequest(void *data,
|
|
SSMLocalizedString *whichString);
|
|
|
|
PRInt32 SSM_PackGetLocalizedTextResponse(void **data,
|
|
SSMLocalizedString whichString,
|
|
char *retString);
|
|
|
|
PRStatus SSM_ParseAddNewSecurityModuleRequest(void *data,
|
|
char **moduleName,
|
|
char **libraryPath,
|
|
unsigned long *pubMechFlags,
|
|
unsigned long *pubCipherFlags);
|
|
|
|
PRInt32 SSM_PackAddNewModuleResponse(void **data, PRInt32 rv);
|
|
|
|
PRStatus SSM_ParseDeleteSecurityModuleRequest(void *data, char **moduleName);
|
|
|
|
PRInt32 SSM_PackDeleteModuleResponse(void **data, PRInt32 moduleType);
|
|
|
|
PRInt32 SSM_PackFilePathRequest(void **data, PRInt32 resID, char *prompt,
|
|
PRBool shouldFileExist, char *fileSuffix);
|
|
|
|
PRStatus SSM_ParseFilePathReply(void *message, char **filePath,
|
|
PRInt32 *rid);
|
|
|
|
PRInt32 SSM_PackPromptRequestEvent(void **data, PRInt32 resID, char *prompt);
|
|
PRStatus SSM_ParsePasswordPromptReply(void *data, PRInt32 *resID,
|
|
char **reply);
|
|
|
|
/* messages for importing certs *the traditional way* */
|
|
PRInt32 SSM_PackDecodeCertReply(void ** data, PRInt32 certID);
|
|
PRStatus SSM_ParseDecodeCertRequest(void * data, PRInt32 * len,
|
|
char ** buffer);
|
|
PRStatus SSM_ParseGetKeyChoiceListRequest(void * data, PRUint32 dataLen,
|
|
char ** type, PRUint32 *typeLen,
|
|
char ** pqgString, PRUint32 *pqgLen);
|
|
PRInt32 SSM_PackGetKeyChoiceListReply(void **data, char ** list);
|
|
|
|
PRStatus SSM_ParseGenKeyOldStyleRequest(void * data, PRUint32 datalen,
|
|
char ** choiceString,
|
|
char ** challenge,
|
|
char ** typeString,
|
|
char ** pqgString);
|
|
PRInt32 SSM_PackGenKeyOldStyleReply(void ** data, char * keydata);
|
|
|
|
PRStatus SSM_ParseDecodeAndCreateTempCertRequest(void * data,
|
|
char ** certbuf, PRUint32 * certlen, int * certClass);
|
|
|
|
#endif /*PROTOCOLF_H_*/
|