ismacryplib.c

完整的RTP RTSP代码库

  err_status_t rc;
#endif
  ismacryp_rc_t irc;
  ismacryp_session_t *sp;

  // get sp by session ID
  irc = findInSessionList (session, &sp); 
  if (irc != ismacryp_rc_ok)
	return irc;

  if (sp == NULL) {
    fprintf(stdout, "Error. Try to uninit NULL session.\n");
    return ismacryp_rc_sessid_error;
  }

#ifdef HAVE_SRTP
  rc = err_status_ok;
  rc=aes_icm_dealloc(sp->cp);
#endif

  return ismacryp_rc_ok;
}

//
// init ismacryp lib
//
ismacryp_rc_t ismacrypInitLib (void)
{
  return ismacryp_rc_ok;
}

//
// init ismacryp session
//
ismacryp_rc_t ismacrypInitSession (ismacryp_session_id_t *session,
                                   ismacryp_keytype_t keytype )
{
  ismacryp_session_t *sp = NULL;
  ismacryp_rc_t  rc;
  int len;
  char *temp;

  sp = malloc(sizeof(ismacryp_session_t));
  if ( sp == NULL ) {
     fprintf(stdout, "Init Session: %d malloc FAILED keytype %c\n", *session, 
                                                         ismacryp_keytypeStr[keytype][7]);
     *session = 0;
     return ismacryp_rc_memory_error;
  }
  memset(sp,0,sizeof(*sp));

  // critical section
  *session = session_g++;
  // critical section

  #if defined(ISMACRYP_ENC_DEBUG) || defined(ISMACRYP_DEC_DEBUG)
  fprintf(stdout, "Init Session: %d with keytype %c\n", *session, 
                                                         ismacryp_keytypeStr[keytype][7]);
  #endif // ISMACRYP_ENC_DEBUG || ISMACRYP_DEC_DEBUG 

  sp->sessid = *session;
  sp->next = NULL;
  sp->prev = NULL;

  // load default keys from file
  rc =  loadKeyFromFile(sp, keytype, 0);
  if( rc != ismacryp_rc_ok ) {
     fprintf(stdout, "Init Session: %d WARNING keytype %c default keys file\n",
		*session, ismacryp_keytypeStr[keytype][7]);
  }

  sp->keycount      = 1;
  sp->sample_count  = 0;
  sp->BSO           = 0;
  sp->IV_len        = ISMACRYP_DEFAULT_IV_LENGTH;
  sp->deltaIV_len   = ISMACRYP_DEFAULT_DELTA_IV_LENGTH;
  sp->key_type      = keytype;
  sp->selective_enc = FALSE;

  // store default kms_uri
  len = strlen(KMS_URI_STR) + 1; // add 1 for null char
  temp = malloc(len); 
  if ( temp == NULL ) {
      fprintf(stderr, "save kms_uri: FAILED for session %d\n", *session);
      *session = 0;
      free (sp);
      return ismacryp_rc_memory_error;
  }
  strncpy(temp, KMS_URI_STR, len);
  sp->kms_uri = temp;

  addToSessionList(sp); 
  #if defined(ISMACRYP_ENC_DEBUG) || defined(ISMACRYP_DEC_DEBUG)
  printSessionList();
  #endif // ISMACRYP_ENC_DEBUG || ISMACRYP_DEC_DEBUG

  // init cipher context
  return initSessionData(*session);

}

ismacryp_rc_t ismacrypEndSession (ismacryp_session_id_t session)
{
  ismacryp_session_t *sp;  

  if( findInSessionList(session, &sp) ) {
     fprintf(stderr, "\nEnd Session: %d FAILED\n", session);
     return ismacryp_rc_sessid_error;
  }

  unInitSessionData(session);
  removeFromSessionList(session); 
  #if defined(ISMACRYP_ENC_DEBUG) || defined(ISMACRYP_DEC_DEBUG)
  printSessionList();
  #endif // ISMACRYP_ENC_DEBUG || ISMACRYP_DEC_DEBUG
  return ismacryp_rc_ok;
}

ismacryp_rc_t ismacrypSetScheme (ismacryp_session_id_t session,
                                 ismacryp_scheme_t scheme)
{
  return ismacryp_rc_ok;
}

ismacryp_rc_t ismacrypGetScheme (ismacryp_session_id_t session,
                                 ismacryp_scheme_t *scheme)
{
  *scheme = FOUR_CHAR_CODE(ISMACRYP_DEFAULT_SCHEME);
  return ismacryp_rc_ok;
}

ismacryp_rc_t ismacrypSetSchemeVersion (ismacryp_session_id_t session,
                                        ismacryp_schemeversion_t schemeversion)
{
  return ismacryp_rc_ok;
}

ismacryp_rc_t ismacrypGetSchemeVersion (ismacryp_session_id_t session,
                                        ismacryp_schemeversion_t *schemeversion)
{
  *schemeversion = ISMACRYP_DEFAULT_SCHEME_VERSION;
  return ismacryp_rc_ok;
}

//
// unload current cipher if it exists, 
// load new cipher from file referenced by kms_uri
//
// save kms_uri associated with this session
//
ismacryp_rc_t ismacrypSetKMSUri (ismacryp_session_id_t session,
                                 char *kms_uri )
{
  ismacryp_rc_t rc;
  ismacryp_session_t *sp;
  int len;
  char *temp;

  if (!session)
     return ismacryp_rc_sessid_error;

  // get sp by session ID
  rc = findInSessionList (session, &sp); 
  if (rc != ismacryp_rc_ok)
	return rc;

  // deallocate current cipher
  rc = unInitSessionData(session);

  // load new key from file
  rc = loadKeyFromFile (sp,	
                      sp->key_type,	
                      kms_uri);

  // update cipher context
  rc = initSessionData(session);

  // store kms_uri
  len = strlen(kms_uri) + 1; // add 1 for null char
  temp = malloc(len); 
  if ( temp == NULL ) {
      fprintf(stderr, "save kms_uri: FAILED for session %d\n", session);
      return ismacryp_rc_memory_error;
  }
  strncpy(temp, kms_uri, len);
  sp->kms_uri = temp;

  #if defined(ISMACRYP_ENC_DEBUG) || defined(ISMACRYP_DEC_DEBUG)
  printSessionList();
  #endif // ISMACRYP_ENC_DEBUG || ISMACRYP_DEC_DEBUG

  return rc;

}

//
//  retrieve kms_uri associated with this session
// 
ismacryp_rc_t ismacrypGetKMSUri (ismacryp_session_id_t session,
                                 const char **kms_uri )
{

ismacryp_session_t *sp;
int len;
char *temp;
ismacryp_rc_t rc;

  // get sp from session
  if (!session)
     return ismacryp_rc_sessid_error;

  // get sp by session ID
  rc = findInSessionList (session, &sp); 
  if (rc != ismacryp_rc_ok)
	return rc;

  len = strlen(sp->kms_uri); 
  temp = malloc(len); 
  if ( temp == NULL ) {
      fprintf(stderr, "get kms uri: FAILED for session %d\n", session);
      return ismacryp_rc_memory_error;
  }
  strncpy(temp, sp->kms_uri, len);
  *kms_uri = temp;
  return ismacryp_rc_ok;
}

ismacryp_rc_t ismacrypSetSelectiveEncryption (ismacryp_session_id_t session,
                                              uint8_t selective_is_on )
{
  ismacryp_session_t *sp;

  if (findInSessionList(session, &sp)) {
     fprintf(stderr, "\nFailed to set selective encryption. Unknown session %d\n", session);
     return ismacryp_rc_sessid_error;
  }

  sp->selective_enc = selective_is_on;
  return ismacryp_rc_ok;
}

ismacryp_rc_t ismacrypGetSelectiveEncryption (ismacryp_session_id_t session,
                                              uint8_t *selective_is_on )
{
  ismacryp_session_t *sp;

  if (findInSessionList(session, &sp)) {
    fprintf(stderr, "\nFailed to get selective encryption. Unknown session %d\n", session);
    return ismacryp_rc_sessid_error;
  }

  *selective_is_on = sp->selective_enc;
  return ismacryp_rc_ok;

}

ismacryp_rc_t ismacrypSetKeyIndicatorLength (ismacryp_session_id_t session,
                                              uint8_t key_indicator_len)
{
  return ismacryp_rc_ok;
}

ismacryp_rc_t ismacrypGetKeyIndicatorLength (ismacryp_session_id_t session,
                                              uint8_t *key_indicator_len)
{
  *key_indicator_len = ISMACRYP_DEFAULT_KEYINDICATOR_LENGTH;
  return ismacryp_rc_ok;
}

ismacryp_rc_t ismacrypGetKeyIndPerAU (ismacryp_session_id_t session,
                                      uint8_t *key_ind_per_au)
{
  *key_ind_per_au = ISMACRYP_DEFAULT_KEYINDICATOR_PER_AU;
  return ismacryp_rc_ok;
}

ismacryp_rc_t ismacrypGetKeyCount (ismacryp_session_id_t session,
                                   uint8_t *keycount)
{
  ismacryp_session_t *sp;

  if (findInSessionList(session, &sp)) {
    fprintf(stderr, "\nFailed to get key count. Unknown session %d\n", session);
    return ismacryp_rc_sessid_error;
  }

  *keycount = sp->keycount;
  return ismacryp_rc_ok;
}

//
//	This API copies key and salt to malloc buffer.
//      the key and salt pointers are updated to 
// 	point at the malloc buffers. the application
// 	must free these buffers when no longer needed.
// 
ismacryp_rc_t ismacrypGetKey (ismacryp_session_id_t session,
                              uint8_t key_num,
                              uint8_t *key_len,
                              uint8_t *salt_len,
                              uint8_t **key,
                              uint8_t **salt,
                              uint8_t *lifetime_exp)
{
 
  int i;
  ismacryp_session_t *sp;
  uint8_t *tempk, *temps;
  // only support one key for now so key_num is irrelevant
  if (findInSessionList(session, &sp)) {
    fprintf(stderr, "\nFailed to get key. Unknown session %d\n", session);
    return ismacryp_rc_sessid_error;
  }

  *key_len      = AES_KEY_LEN;
  *salt_len     = AES_SALT_LEN;
  *lifetime_exp = ISMACRYP_DEFAULT_KEY_LIFETIME_EXP;

  tempk = (uint8_t *) malloc((size_t) *key_len);
  temps = (uint8_t *) malloc((size_t) *salt_len);
   
  if ( tempk == NULL || temps == NULL ) {
     CHECK_AND_FREE(tempk);
     CHECK_AND_FREE(temps);
     fprintf(stdout, "\nFailed to get key mem error. Session %d\n", session);
     return ismacryp_rc_memory_error;
  }

  for (i=0; i<*key_len; i++ ) {
    tempk[i] = sp->kk.ksc.key[i];
  }
  *key = tempk;

  for (i=0; i<*salt_len; i++ ) {
    temps[i] = sp->kk.ksc.salt[i];
  }
  *salt = temps;

  return ismacryp_rc_ok;

}
                            
//
//	This API has the same invocation signature
//	as ismacrypGetKey, but instead of making
//	copies of key and salt to malloc buffers,
//	this API instead updates key and salt pointers to the 
//	live key and salt buffers.  The application must NOT 
//	attempt to free the key and salt pointers!
// 
ismacryp_rc_t ismacrypGetKey2 (ismacryp_session_id_t session,
                              uint8_t key_num,
                              uint8_t *key_len,
                              uint8_t *salt_len,
                              uint8_t **key,
                              uint8_t **salt,
                              uint8_t *lifetime_exp)
{
 
  ismacryp_session_t *sp;
  // only support one key for now so key_num is irrelevant
  if (findInSessionList(session, &sp)) {
    fprintf(stderr, "\nFailed to get key. Unknown session %d\n", session);
    return ismacryp_rc_sessid_error;
  }

  *key_len      = AES_KEY_LEN;
  *salt_len     = AES_SALT_LEN;
  *lifetime_exp = ISMACRYP_DEFAULT_KEY_LIFETIME_EXP;

  *key = sp->kk.ksc.key;
  *salt = sp->kk.ksc.salt;