Не могу разобраться с авторизацией для IP камеры по ONVIF

    // hardcoded nonce
    char caNonceTest[20] = { 0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,
        0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38 };
    caNonceTest[19] = '\0';
    
    // Random generaterd nonce
    //char caNonceTest[SHA_DIGEST_LENGTH];
    //int nonceInt = rand();
    
    //memset(caNonceTest, 1, SHA_DIGEST_LENGTH);
    //memcpy(caNonceTest, &nonceInt, sizeof(nonceInt));
 
 
    // Get data/time
    string sDataUTC = currentISO8601TimeUTC();
 
    // non-crypted password. Make function to get password from user
    string sPass = "admin";
    string sName = "default";
    
    string sNonce(caNonceTest);
    
    // temp string for SHA1
    string sTempSumBin = (sNonce) + /*string2bin*/(sDataUTC)+ /*string2bin*/(sPass); // with string2bin it is also not working
    
    
    unsigned char digest[SHA_DIGEST_LENGTH];
 
    char cstr[sTempSumBin.size() + 1];
    strcpy(cstr, sTempSumBin.c_str());
 
    SHA1((unsigned char*)&cstr, strlen(cstr), (unsigned char*)&digest);
 
    char cSHA1Pass[SHA_DIGEST_LENGTH * 2 + 1];
 
    for (int i = 0; i < SHA_DIGEST_LENGTH; i++)
        sprintf(&cSHA1Pass[i * 2], "%02x", (unsigned int)digest[i]);
    printf("SHA1 string before : %s \n", cSHA1Pass);
    
    string strTob64(cSHA1Pass);
    string strFinishedPAss = base64_encode(strTOb64); // this is the final result of the password

static const std::string base64_chars =
             "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
             "abcdefghijklmnopqrstuvwxyz"
             "0123456789+/";
 
static std::string base64_encode(unsigned char const* bytes_to_encode, unsigned int in_len) {
  std::string ret;
  int i = 0;
  int j = 0;
  unsigned char char_array_3[3];
  unsigned char char_array_4[4];
 
  while (in_len--) {
    char_array_3[i++] = *(bytes_to_encode++);
    if (i == 3) {
      char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
      char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
      char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
      char_array_4[3] = char_array_3[2] & 0x3f;
 
      for(i = 0; (i <4) ; i++)
        ret += base64_chars[char_array_4[i]];
      i = 0;
    }
  }
 
  if (i)
  {
    for(j = i; j < 3; j++)
      char_array_3[j] = '\0';
 
    char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
    char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
    char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
    char_array_4[3] = char_array_3[2] & 0x3f;
 
    for (j = 0; (j < i + 1); j++)
      ret += base64_chars[char_array_4[j]];
 
    while((i++ < 3))
      ret += '=';
 
  }
 
  return ret;
 
}
 
std::string get_onvif_time_str(void)
{
    static char buffer[26];
 
    std::time_t t = std::time(0);
    std::tm *_t = std::gmtime(&t);
 
    sprintf
    (
        buffer,
        "%04u-%02u-%02uT%02u:%02u:%02uZ",
        unsigned(_t->tm_year + 1900), unsigned(_t->tm_mon + 1), (unsigned)_t->tm_mday,
        (unsigned)_t->tm_hour, (unsigned)_t->tm_min, (unsigned)_t->tm_sec
    );
 
    return buffer;
}
 
std::string GetNonce(void)
{
    std::string res;
    res.resize(20);
    for (int i = 0; i < 20; i++)
        res[i] = rand() % 256;
    return res;
}
 
bool get_sig(const char *hex_sig, char *sig, const int sig_bytes, const bool uppercase)
{
    int d = uppercase? 7 : 39;
 
    for (int i = 0; i < sig_bytes; i++)
    {
        unsigned char hi = hex_sig[i * 2];
        hi -= 48;
        if (hi > 9) hi -= d;
        if (hi > 15)
        {
            return false;
        }
 
        unsigned char lo = hex_sig[i * 2 + 1];
        lo -= 48;
        if (lo > 9) lo -= d;
        if (lo > 15)
        {
            return false;
        }
 
        sig[i] = (hi << 4) | lo;
    }
 
    return true;
}
 
...
 
    std::string time = get_onvif_time_str();
    std::string nonce = GetNonce();
    std::string nonce_enc = base64_encode(nonce.c_str(), nonce.size());
    std::string nonce_time_password_enc = sha1(nonce + time + password);
    std::string digest;
    digest.resize(nonce_time_password_enc.size() / 2);
    get_sig(nonce_time_password_enc.c_str(), (char *)digest.c_str(), digest.size(), false);
    digest = base64_encode(digest.c_str(), digest.size());
 
    std::string data =
    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
    "<SOAP-ENV:Envelope xmlns:SOAP-ENV=\"http://www.w3.org/2003/05/soap-envelope\""
    "xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\""
    "xmlns:wsu=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd\""
    "xmlns:tds=\"http://www.onvif.org/ver10/device/wsdl\">"
    + (!name.size()? std::string("") : (
    "<SOAP-ENV:Header>"
    "<wsse:Security>"
    "<wsse:UsernameToken>"
    "<wsse:Username>" + name + "</wsse:Username>"
    "<wsse:Password Type=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-username-token-profile-1.0#PasswordDigest\">" + digest + "</wsse:Password>"
    "<wsse:Nonce EncodingType=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-soap-message-security-1.0#Base64Binary\">" + nonce_enc + "</wsse:Nonce>"
    "<wsu:Created>" + time + "</wsu:Created>"
    "</wsse:UsernameToken>"
    "</wsse:Security>"
    "</SOAP-ENV:Header>"
    )) +
    "<SOAP-ENV:Body>"
    "<tds:GetDeviceInformation/>"
    "</SOAP-ENV:Body>"
    "</SOAP-ENV:Envelope>";