protocolf.c

安全开发库。含客户端建立ssl连接、签名、证书验证、证书发布和撤销等。编译用到nss

  return blobSize;
}

PRInt32 SSM_PackPasswdRequest(void ** passwdRequest, PRInt32 tokenID, 
			      char * prompt, PRInt32 promptLen)
{
  void * curptr, * tmpStr = NULL;
  PRInt32 blobSize;
  PRStatus rv = PR_SUCCESS;

  if (!passwdRequest || !prompt || tokenID == 0 || promptLen == 0)
    {
      SSMPORT_SetError(SSMPR_INVALID_ARGUMENT_ERROR);
      goto loser;
    }
  *passwdRequest = NULL; /* in case we fail */

  blobSize = sizeof(PRInt32)*2 + SSMSTRING_PADDED_LENGTH(promptLen);
  curptr = *passwdRequest = PORT_ZAlloc(blobSize);
  if (!*passwdRequest) {
    SSMPORT_SetError(SSMPR_OUT_OF_MEMORY_ERROR);
    goto loser;
  }
    
  *(PRInt32 *)curptr = PR_htonl(tokenID);
  curptr = (PRInt32 *)curptr + 1;
  
  rv = SSM_StringToSSMString((SSMString **)&tmpStr, promptLen, prompt);
  if (rv != PR_SUCCESS) 
    goto loser;
  memcpy(curptr, tmpStr, SSM_SIZEOF_STRING(*(SSMString *)tmpStr));
  goto done;

loser:
  if (passwdRequest && *passwdRequest) 
    PR_Free(passwdRequest);

done:
  if (tmpStr) 
    PR_Free(tmpStr);
  return blobSize;
}

PRStatus SSM_ParsePasswordReply(void * passwdReply, PRInt32 * result, 
                                PRInt32 * tokenID,
				char ** passwd, PRInt32 * passwdLen)
{
  PRStatus rv = PR_SUCCESS;
  void * curptr = passwdReply; 
  
  if (!passwdReply) { 
    rv = PR_INVALID_ARGUMENT_ERROR;
    goto loser;
  }
 
  if (result) 
    *result = PR_ntohl(*(PRInt32 *)curptr);
  curptr = (PRInt32 *)curptr + 1;
   
  if (tokenID) 
    *tokenID = PR_ntohl(*(PRInt32 *)curptr);
  curptr = (PRInt32 *)curptr + 1;
  
  if (passwd) {
    *passwd = NULL;
    rv = SSM_SSMStringToString(passwd, passwdLen, (SSMString *)curptr);
    if (rv != PR_SUCCESS && *passwd) {
      PR_Free(*passwd);
      *passwd = NULL;
      passwdLen = 0;
      goto loser;
    }
  }
  goto done;
loser:
  if (rv == PR_SUCCESS) 
    rv = PR_FAILURE;
  if (passwd && *passwd) {
    PR_Free(*passwd);
    *passwd = NULL;
  }
  if (tokenID) 
    *tokenID = 0;
  if (passwdLen)
    *passwdLen = 0;

done: 
  return rv;
}

void SSM_DestroyAttrValue(SSMAttributeValue *value, PRBool freeit)
{
  if (value->type == SSM_STRING_ATTRIBUTE)
    PR_Free(value->u.string);
  value->type = 0;
  if (freeit)
    PR_Free(value);
}

/* Sign Text functions */

PRStatus SSM_ParseSignTextRequest(void* signTextRequest, PRInt32 len, PRUint32* resID, signTextRequestData ** data)
{
    unsigned char *curPtr = (unsigned char*)signTextRequest;
    signTextRequestData *signTextData = NULL;
    PRStatus rv;
    int i;

    /* Do some basic parameter checking */
    if (!signTextRequest || !resID || !data) {
        goto loser;
    }

    /* Allocate the reply structure */
    signTextData = PR_NEWZAP(signTextRequestData);
    if (NULL == signTextData) {
        goto loser;
    }

    /* Resource ID */
    *resID = PR_ntohl(*(PRInt32*)curPtr);
    curPtr += sizeof(PRInt32);

    /* String to sign */
    rv = SSM_SSMStringToString(&(signTextData->stringToSign), NULL, (SSMString*)curPtr);
    if (rv != PR_SUCCESS) {
        goto loser;
    }
    curPtr += SSM_SIZEOF_STRING(*(SSMString*)curPtr);

    /* Host name */
    rv = SSM_SSMStringToString(&(signTextData->hostName), NULL, (SSMString*)curPtr);
    if (rv != PR_SUCCESS) {
        goto loser;
    }
    curPtr += SSM_SIZEOF_STRING(*(SSMString*)curPtr);

    /* CA option */
    rv = SSM_SSMStringToString(&(signTextData->caOption), NULL, (SSMString*)curPtr);
    if (rv != PR_SUCCESS) {
        goto loser;
    }
    curPtr += SSM_SIZEOF_STRING(*(SSMString*)curPtr);

    /* Number of CAs */
    signTextData->numCAs = PR_ntohl(*(PRInt32*)curPtr);
    curPtr += sizeof(PRInt32);

    signTextData->caNames = PR_Malloc(sizeof(char*)*(signTextData->numCAs));

    for (i = 0; i < signTextData->numCAs; i++) {
        rv = SSM_SSMStringToString(&(signTextData->caNames[i]), NULL, (SSMString*)curPtr);
        if (rv != PR_SUCCESS) {
            goto loser;
        }
        curPtr += SSM_SIZEOF_STRING(*(SSMString*)curPtr);
    }

    *data = signTextData;

    /* Free the incoming data buffer */
    PR_Free(signTextRequest);
    
    return PR_SUCCESS;
loser:
    if (signTextData) {
        if (signTextData->stringToSign) {
            PR_Free(signTextData->stringToSign);
        }
        if (signTextData->hostName) {
            PR_Free(signTextData->hostName);
        }
        if (signTextData->numCAs) {
            /* XXX Free the CA Names */
        }
        PR_Free(signTextData);
    }
    return PR_FAILURE;
}

PRStatus SSM_ParseGetLocalizedTextRequest(void               *data,
                                          SSMLocalizedString *whichString)
{
    return SSM_ParseSingleNumRequest(data, (SSMPRUint32*)whichString);
} 

PRInt32 SSM_PackGetLocalizedTextResponse(void               **data,
					 SSMLocalizedString   whichString,
					 char                *retString)
{
    char *tmpPtr;
    PRInt32 replyLen;
    int retStrLen;

    retStrLen = strlen(retString);
    replyLen = SSMSTRING_PADDED_LENGTH(retStrLen)+(2*sizeof(PRInt32));
    
    tmpPtr = SSMPORT_ZNewArray(char, replyLen);
    if (tmpPtr == NULL) {
      *data = NULL;
      return 0;
    }
    *data = tmpPtr;
    *(PRUint32*)tmpPtr = PR_htonl(whichString);
    tmpPtr += sizeof(PRUint32);
    *(PRUint32*)tmpPtr = PR_htonl(retStrLen);
    tmpPtr += sizeof(PRUint32);
    memcpy(tmpPtr, retString, retStrLen);
    return replyLen;
}

PRStatus SSM_ParseAddNewSecurityModuleRequest(void          *data, 
					      char         **moduleName,
					      char         **libraryPath, 
					      unsigned long *pubMechFlags,
					      unsigned long *pubCipherFlags)
{
    char *tmpPtr;
    PRStatus rv;

    if (data == NULL) {
       return PR_FAILURE;
    }
    if (moduleName != NULL) {
        *moduleName = NULL;
    }
    if (libraryPath != NULL) {
        *libraryPath = NULL;
    }
    tmpPtr = data;
    if (moduleName) {
      rv = SSM_SSMStringToString(moduleName, NULL, (SSMString*)tmpPtr);
      if (rv != PR_SUCCESS) {
	  goto loser;
      }
    }
    tmpPtr += SSM_SIZEOF_STRING(*(SSMString*)tmpPtr);
    if (libraryPath) {
      rv =SSM_SSMStringToString(libraryPath, NULL, (SSMString*)tmpPtr);
      if (rv != PR_SUCCESS) {
	  goto loser;
      }
    }
    tmpPtr += SSM_SIZEOF_STRING(*(SSMString*)tmpPtr);
    *pubMechFlags = PR_ntohl(*(unsigned long*)tmpPtr);
    tmpPtr += sizeof(unsigned long);
    *pubCipherFlags = PR_ntohl(*(unsigned long*)tmpPtr);
    return PR_SUCCESS;
 loser:
    if (moduleName && *moduleName) {
        PR_Free(moduleName);
    }
    if (libraryPath && *libraryPath) {
        PR_Free(libraryPath);
    }
    return PR_FAILURE;
}

PRInt32 SSM_PackAddNewModuleResponse(void **data, PRInt32 rv)
{
    return SSM_PackSingleNumReply(data, rv);
}

PRStatus SSM_ParseDeleteSecurityModuleRequest(void *data, char **moduleName)
{
    PRStatus rv = PR_FAILURE;

    if (data == NULL) {
        goto done;
    }
    if (moduleName) {
        *moduleName = NULL;
	rv = SSM_SSMStringToString(moduleName, NULL, (SSMString*)data);
    }
 done:
    return rv;
}

PRInt32 SSM_PackDeleteModuleResponse(void **data, PRInt32 moduleType)
{
    return SSM_PackSingleNumReply(data, moduleType);
}

/* messages for importing certs *the traditional way* */
PRInt32 SSM_PackDecodeCertReply(void ** data, PRInt32 certID)
{
 return SSM_PackSingleNumReply(data, certID);
}

PRStatus SSM_ParseDecodeCertRequest(void * data, PRInt32 * len,
                                        char ** buffer)
{
  if (!data) 
    goto loser;

  if (buffer) {
    return SSM_SSMStringToString(buffer, len, (SSMString*)data); 
  }
loser:
  return PR_FAILURE;
}

PRStatus SSM_ParseDecodeAndCreateTempCertRequest(void * data,
                        char ** certbuf, PRUint32 * certlen, int * certClass)
{
  PRStatus rv = PR_FAILURE;

  if (!data) 
    goto loser;

  *certClass = PR_ntohl(*(int *)data);
  rv = SSM_SSMStringToString(certbuf, certlen, (SSMString *)((char *)data + sizeof(int)));
  if (rv != PR_SUCCESS)
    goto loser;

loser:  
  if (data)
    PR_Free(data);
  return rv;
} 
  

PRStatus SSM_ParseGetKeyChoiceListRequest(void * data, PRUint32 dataLen,
                                          char ** type, PRUint32 *typeLen,
                                          char ** pqgString, PRUint32 * pqgLen)
{
  PRStatus  rv = PR_SUCCESS;
  void * curptr = data;
  char * field = NULL, * value;
  PRUint32 len;

  /* in fact, this is perfectly OK, loser is just an exit tag */
  if (!data)
    goto loser;

  if (type) *type = NULL;
  if (pqgString) *pqgString = NULL;
  
  while  ((long)curptr < (long)data + dataLen)  {
    rv = SSM_SSMStringToString(&field, &len, (SSMString *)curptr);
    if (rv != PR_SUCCESS)
      goto loser;
    curptr = (char *)curptr + SSMSTRING_PADDED_LENGTH(len) + sizeof(PRInt32);
    rv = SSM_SSMStringToString(&value, &len, (SSMString *)curptr);
    if (rv != PR_SUCCESS)
      goto loser;
    curptr = (char *)curptr + SSMSTRING_PADDED_LENGTH(len) + sizeof(PRInt32);

    if (type &&  PORT_Strcmp(field, "type")==0) {
      *type = value;
      if (typeLen) *typeLen = len;
    } else if (pqgString && PORT_Strcmp(field, "pqg")==0) {
      *pqgString = value;
      if (pqgLen) *pqgLen = len;
    }
    if (field) PR_Free(field);
  } 

loser:
  if (data)
    PR_Free(data);
  return rv;
} 
  

PRInt32 SSM_PackGetKeyChoiceListReply(void ** data, char ** list)
{
  PRInt32 len = 0, i=0, oldlen;
  char * tmpString = NULL, * tmp = NULL;
  PRStatus rv = PR_FAILURE;

  *data = NULL;

  while (list[i] != 0) {
    oldlen = len;
    len = len + SSMSTRING_PADDED_LENGTH(strlen(list[i])) + sizeof(PRInt32);
    if (tmp)  
      tmp = PR_REALLOC(tmp, len);
    else 
      tmp = PORT_ZAlloc(len);
    if (!tmp)
      goto loser;
    rv = SSM_StringToSSMString((SSMString **)&tmpString, 0, list[i]); 
    if (rv != PR_SUCCESS)  
      goto loser;
    memcpy(tmp+oldlen, tmpString, len-oldlen);
    i++;
  }

  *data = PORT_ZAlloc(len + sizeof(i));
  oldlen = PR_htonl(i);
  *(PRInt32 *)*data = oldlen; /* number of strings */
  memcpy((char *)*data + sizeof(i), tmp, len);

  return len+sizeof(i);

loser:
   /* scream out loud, should not be breaking here 
   SSM_DEBUG("Error in packGetKeyChoiceListReply!\n");
   */
   *data = NULL;
   return 0;
}


PRStatus SSM_ParseGenKeyOldStyleRequest(void * data, PRUint32 datalen,
                                        char ** choiceString,
                                        char ** challenge,
                                        char ** typeString,
                                        char ** pqgString)
{
  char * curptr = (char *)data;
  PRStatus rv; 
   
  if (!data)
    goto loser;
  
  if (choiceString) {
    rv = SSM_SSMStringToString(choiceString, NULL, (SSMString *)curptr);
    if (rv != PR_SUCCESS)
      goto loser;
  }
  curptr = (char *)curptr + SSM_SIZEOF_STRING(*(SSMString *)curptr);

  if (challenge) {
    rv = SSM_SSMStringToString(challenge, NULL, (SSMString *)curptr);
    if (rv != PR_SUCCESS)
      goto loser;
  }
  curptr = (char *)curptr + SSM_SIZEOF_STRING(*(SSMString *)curptr); 

  if (typeString) {
    rv = SSM_SSMStringToString(typeString, NULL, (SSMString *)curptr);
    if (rv != PR_SUCCESS)
      goto loser;
  }
  curptr = (char *)curptr + SSM_SIZEOF_STRING(*(SSMString *)curptr);

  if (pqgString) {
    rv = SSM_SSMStringToString(pqgString, NULL, (SSMString *)curptr);
    if (rv != PR_SUCCESS)
      goto loser;
  }
  curptr = (char *)curptr + SSM_SIZEOF_STRING(*(SSMString *)curptr);
  goto done;

loser:
  if (pqgString && *pqgString) {
    PR_Free(*pqgString);
    *pqgString = NULL;
  }
  if (typeString && *typeString) {
    PR_Free(*typeString);
    *typeString = NULL;
  }
  if (challenge && *challenge) {
    PR_Free(*challenge);
    *challenge = NULL;
  }
  if (choiceString && *choiceString) {
    PR_Free(*choiceString);
    *choiceString = NULL;
  }
  if (rv == PR_SUCCESS)
    rv = PR_FAILURE;
done:
  if (data) 
    PR_Free(data);
  return rv;
}

 
PRInt32 SSM_PackGenKeyOldStyleReply(void ** data, char * keydata)
{
  PRStatus rv;
  char * curptr;

  if (!data)
    return 0;

  rv = SSM_StringToSSMString((SSMString **)&curptr, 0, keydata);
  if (rv != PR_SUCCESS)
    return 0;
   
  *data = curptr;
  return SSM_SIZEOF_STRING(*(SSMString *)curptr);
}


PRInt32 SSM_PackFilePathRequest(void **data, PRInt32 resID, char *prompt,
                                PRBool shouldFileExist, char *fileSuffix)
{
    PRInt32 reqLen;
    char *request;
    PRInt32 promptLen, fileSufLen;

    promptLen = strlen(prompt);
    fileSufLen = strlen(fileSuffix);
    reqLen = SSMSTRING_PADDED_LENGTH(promptLen) + 
             SSMSTRING_PADDED_LENGTH(fileSufLen) + (4*sizeof(PRInt32));
    request = SSMPORT_ZNewArray(char, reqLen);
    if (request == NULL) {
        *data = NULL;
        return 0;
    }
    *data = request;
    *(PRInt32*)request = PR_htonl(resID);
    request += sizeof(PRInt32);
    *(PRInt32*)request = PR_htonl(shouldFileExist);
    request += sizeof(PRInt32);
    *(PRInt32*)request = PR_htonl(promptLen);
    request += sizeof(PRInt32);
    memcpy(request, prompt, promptLen);
    request += SSMSTRING_PADDED_LENGTH(promptLen);
    *(PRInt32*)request = PR_htonl(fileSufLen);
    request += sizeof(PRInt32);
    memcpy(request, fileSuffix, fileSufLen);
    return reqLen;
}

PRStatus SSM_ParseFilePathReply(void *message, char **filePath,
                                PRInt32 *rid)
{
    unsigned char *curPtr = message;

    *rid = PR_ntohl(*(PRInt32*)curPtr);
    curPtr += sizeof(PRInt32);
    if (filePath != NULL) {
        *filePath = NULL;
        SSM_SSMStringToString(filePath, NULL, (SSMString*)curPtr);
    }
    curPtr += SSM_SIZEOF_STRING(*(SSMString*)curPtr);
    return PR_SUCCESS;
}

PRInt32 SSM_PackPromptRequestEvent(void **data, PRInt32 resID, char *prompt)
{
    PRInt32 promptLen;
    PRInt32 reqLen;
    char *request;

    promptLen = strlen(prompt);
    reqLen = SSMSTRING_PADDED_LENGTH(promptLen) + (2*sizeof(PRInt32));
    *data = request = SSMPORT_ZNewArray(char, reqLen);
    if (request == NULL) {
        *data = NULL;
        return 0;
    }
    *(PRInt32*)request = PR_htonl(resID);
    request += sizeof(PRInt32); 
    *(PRInt32*)request = PR_htonl(promptLen);
    request += sizeof(PRInt32);
    memcpy(request, prompt, promptLen);
    return reqLen;
}

PRStatus 
SSM_ParsePasswordPromptReply(void *data, PRInt32 *resID, char **reply)
{
    /* The Message formats are the same, so I can do this. */
    return SSM_ParseFilePathReply(data, reply, resID);
}