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;
}
