static void frame_callback(const char *frame_data, size_t len, void *userdata) { size_t image_len; char *image; struct json_internal *json = userdata; if (!json) return; if (frame_data && len) { /* 'image' should be freed by the client */ image_len = modp_b64_decode_len(len); image = ec_malloc(image_len); image_len = modp_b64_decode(image, frame_data, len); if (image_len != -1) json->frame_callback(image, image_len, json->userdata); else goto fail; /* Success! */ return; } fail: /* * Failure * If image decoding failed, call frame_callback() with a NULL argument, * to let the client know about the error. */ json->frame_callback(NULL, 0, json->userdata); }
static bool Base64Decode(const std::string& input, std::string* output) { std::string temp; temp.resize(modp_b64_decode_len(input.size())); int input_size = static_cast<int>(input.size()); int output_size = modp_b64_decode(&(temp[0]), input.data(), input_size); if (output_size < 0) return false; temp.resize(output_size); output->swap(temp); return true; }
bool Base64Decode(const std::string& input, std::string* output) { std::string temp; temp.resize(modp_b64_decode_len(input.size())); // does not null terminate result since result is binary data! int input_size = static_cast<int>(input.size()); int output_size = modp_b64_decode(&(temp[0]), input.data(), input_size); if (output_size < 0) return false; temp.resize(output_size); output->swap(temp); return true; }
string EasyUtil::Base64Decode(const string &sInput) { std::string temp; temp.resize(modp_b64_decode_len(sInput.size())); // does not null terminate result since result is binary data! int input_size = static_cast<int>(sInput.size()); int output_size = modp_b64_decode(&(temp[0]), sInput.data(), input_size); if (output_size < 0) return false; temp.resize(output_size); return temp; }
std::string& Base64::Decode(std::string &s) { std::string x(modp_b64_decode_len(s.size()), '\0'); size_t d = b64_stuff::modp_b64_decode(const_cast<char*>(x.data()), s.data(), (int)s.size()); if (d == MODP_B64_ERROR) { x.clear(); } else { x.erase(d, std::string::npos); } s.swap(x); return s; }
int VerifyDataSignWithHashAlg(const char * userData, const char * hashAlg, const char * certDataB64, const char * signatureDataB64) { int rv = -1; int ulHashAlg = 0; HCRYPTHASH hHash = NULL; char * pbCert = NULL; char * pbSignature = NULL; unsigned int ulCert = 0; unsigned int ulSignature = 0; PCCERT_CONTEXT pCertContext = NULL; HCRYPTPROV hProv = NULL; HCRYPTKEY hPubKey = NULL; { ulCert = modp_b64_decode_len(strlen(certDataB64)); ulSignature = modp_b64_decode_len(strlen(signatureDataB64)); pbCert = (char *)malloc(ulCert); pbSignature = (char *) malloc(ulSignature); if (NULL == pbCert || NULL == pbSignature) { sprintf(m_errMsg, "%s","memroy less.\n" ); goto err; } ulCert = modp_b64_decode(pbCert, certDataB64,strlen(certDataB64)); ulSignature = modp_b64_decode(pbSignature, signatureDataB64,strlen(signatureDataB64)); } if (0 == strcmp(hashAlg, "MD5")) { ulHashAlg = CALG_MD5; } else if (0 == strcmp(hashAlg, "SHA")) { ulHashAlg = CALG_SHA; } else if (0 == strcmp(hashAlg, "SHA1")) { ulHashAlg = CALG_SHA1; } else if (0 == strcmp(hashAlg, "SHA_256")) { ulHashAlg = CALG_SHA_256; } else if (0 == strcmp(hashAlg, "SHA_384")) { ulHashAlg = CALG_SHA_384; } pCertContext = CertCreateCertificateContext(X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, (BYTE *)pbCert,ulCert); if (!pCertContext) { sprintf(m_errMsg, "%s","Select Certificate UI failed.\n" ); goto err; } //Ò»¡¢»ñµÃÒ»¸öCSP¾ä±ú if(!CryptAcquireContext( &hProv, NULL, //ÃÜÔ¿ÈÝÆ÷Ãû£¬NULL±íʾʹÓÃĬÈÏÈÝÆ÷ NULL, //CSP_NAME PROV_RSA_FULL, 0 )) { if(!CryptAcquireContext( &hProv, NULL, //ÃÜÔ¿ÈÝÆ÷Ãû£¬NULL±íʾʹÓÃĬÈÏÈÝÆ÷ NULL, //CSP_NAME PROV_RSA_FULL, CRYPT_NEWKEYSET //´´½¨ÃÜÔ¿ÈÝÆ÷ )) { sprintf(m_errMsg, "%s","CryptAcquireContext fail.\n"); goto err; } } if(CryptImportPublicKeyInfo( hProv, X509_ASN_ENCODING, &(pCertContext->pCertInfo->SubjectPublicKeyInfo), &hPubKey )) { sprintf(m_errMsg,"CryptImportPublicKeyInfo OK. \n"); } else { sprintf(m_errMsg,"Error CryptImportPublicKeyInfo.\n"); goto err; } //if(CryptImportKey(hProv,pCertContext->pCertInfo->SubjectPublicKeyInfo.PublicKey.pbData, pCertContext->pCertInfo->SubjectPublicKeyInfo.PublicKey.cbData, NULL, 0, &hPubKey)) //{ // sprintf(m_errMsg,"CryptImportKey OK. \n"); //} //else //{ // sprintf(m_errMsg,"Error CryptImportKey.\n"); // goto err; //} if(CryptCreateHash( hProv, ulHashAlg, 0, 0, &hHash)) { sprintf(m_errMsg, "%s","An empty hash object has been created. \n"); } else { sprintf(m_errMsg, "%s","Error during CryptBeginHash!\n"); goto err; } //-------------------------------------------------------------------- // This code assumes that the handle of a cryptographic context // has been acquired and that a hash object has been created // and its handle (hHash) is available. if(CryptHashData( hHash, (unsigned char *)userData, strlen(userData), 0)) { sprintf(m_errMsg, "%s","The data buffer has been added to the hash.\n"); } else { sprintf(m_errMsg, "%s","Error during CryptHashData.\n"); goto err; } if(CryptVerifySignature(hHash, (const BYTE *)pbSignature, ulSignature,hPubKey,NULL,0)) { sprintf(m_errMsg,"verify OK.\n"); } else { sprintf(m_errMsg,"Error during CryptVerifySignature.\n"); goto err; } rv = 0; err: if(hHash) { CryptDestroyHash(hHash); } if (pbSignature) { free(pbSignature); } if (pbCert) { free(pbCert); } if (pCertContext) { CertFreeCertificateContext(pCertContext); } if(hProv) { CryptReleaseContext(hProv,0); } return rv; }
unsigned int Controller::determineHeaderSizeForSessionProtocol(Request *req, SessionProtocolWorkingState &state, string delta_monotonic) { unsigned int dataSize = sizeof(boost::uint32_t); state.path = req->getPathWithoutQueryString(); state.hasBaseURI = req->options.baseURI != P_STATIC_STRING("/") && startsWith(state.path, req->options.baseURI); if (state.hasBaseURI) { state.path = state.path.substr(req->options.baseURI.size()); if (state.path.empty()) { state.path = P_STATIC_STRING("/"); } } state.queryString = req->getQueryString(); state.methodStr = StaticString(http_method_str(req->method)); state.remoteAddr = req->secureHeaders.lookup(REMOTE_ADDR); state.remotePort = req->secureHeaders.lookup(REMOTE_PORT); state.remoteUser = req->secureHeaders.lookup(REMOTE_USER); state.contentType = req->headers.lookup(HTTP_CONTENT_TYPE); if (req->hasBody()) { state.contentLength = req->headers.lookup(HTTP_CONTENT_LENGTH); } else { state.contentLength = NULL; } if (req->envvars != NULL) { size_t len = modp_b64_decode_len(req->envvars->size); state.environmentVariablesData = (char *) malloc(len); if (state.environmentVariablesData == NULL) { throw RuntimeException("Unable to allocate memory for base64 " "decoding of environment variables"); } len = modp_b64_decode(state.environmentVariablesData, req->envvars->start->data, req->envvars->size); if (len == (size_t) -1) { throw RuntimeException("Unable to base64 decode environment variables"); } state.environmentVariablesSize = len; } dataSize += sizeof("REQUEST_URI"); dataSize += req->path.size + 1; dataSize += sizeof("PATH_INFO"); dataSize += state.path.size() + 1; dataSize += sizeof("SCRIPT_NAME"); if (state.hasBaseURI) { dataSize += req->options.baseURI.size(); } else { dataSize += sizeof(""); } dataSize += sizeof("QUERY_STRING"); dataSize += state.queryString.size() + 1; dataSize += sizeof("REQUEST_METHOD"); dataSize += state.methodStr.size() + 1; if (req->host != NULL && req->host->size > 0) { const LString *host = psg_lstr_make_contiguous(req->host, req->pool); const char *sep = (const char *) memchr(host->start->data, ':', host->size); if (sep != NULL) { state.serverName = StaticString(host->start->data, sep - host->start->data); state.serverPort = StaticString(sep + 1, host->start->data + host->size - sep - 1); } else { state.serverName = StaticString(host->start->data, host->size); if (req->https) { state.serverPort = P_STATIC_STRING("443"); } else { state.serverPort = P_STATIC_STRING("80"); } } } else { state.serverName = defaultServerName; state.serverPort = defaultServerPort; } dataSize += sizeof("SERVER_NAME"); dataSize += state.serverName.size() + 1; dataSize += sizeof("SERVER_PORT"); dataSize += state.serverPort.size() + 1; dataSize += sizeof("SERVER_SOFTWARE"); dataSize += serverSoftware.size() + 1; dataSize += sizeof("SERVER_PROTOCOL"); dataSize += sizeof("HTTP/1.1"); dataSize += sizeof("REMOTE_ADDR"); if (state.remoteAddr != NULL) { dataSize += state.remoteAddr->size + 1; } else { dataSize += sizeof("127.0.0.1"); } dataSize += sizeof("REMOTE_PORT"); if (state.remotePort != NULL) { dataSize += state.remotePort->size + 1; } else { dataSize += sizeof("0"); } if (state.remoteUser != NULL) { dataSize += sizeof("REMOTE_USER"); dataSize += state.remoteUser->size + 1; } if (state.contentType != NULL) { dataSize += sizeof("CONTENT_TYPE"); dataSize += state.contentType->size + 1; } if (state.contentLength != NULL) { dataSize += sizeof("CONTENT_LENGTH"); dataSize += state.contentLength->size + 1; } dataSize += sizeof("PASSENGER_CONNECT_PASSWORD"); dataSize += ApplicationPool2::ApiKey::SIZE + 1; if (req->https) { dataSize += sizeof("HTTPS"); dataSize += sizeof("on"); } if (req->options.analytics) { dataSize += sizeof("PASSENGER_TXN_ID"); dataSize += req->options.transaction->getTxnId().size() + 1; dataSize += sizeof("PASSENGER_DELTA_MONOTONIC"); dataSize += delta_monotonic.size() + 1; } if (req->upgraded()) { dataSize += sizeof("HTTP_CONNECTION"); dataSize += sizeof("upgrade"); } ServerKit::HeaderTable::Iterator it(req->headers); while (*it != NULL) { dataSize += sizeof("HTTP_") - 1 + it->header->key.size + 1; dataSize += it->header->val.size + 1; it.next(); } if (state.environmentVariablesData != NULL) { dataSize += state.environmentVariablesSize; } return dataSize + 1; }