static void
xmitFile(char *filename) //IN : file to be transmitted.
{
FILE *fp;
size_t readLen;
char buf[BUF_BASE64_SIZE];
/*
* We have a unique identifier saying that this is guest dumping the
* output of logs and not any other logging information from the guest.
*/
char base64B[BUF_BASE64_SIZE * 2] = ">";
char *base64Buf = base64B + 1;
if (!(fp = fopen(filename, "rb"))) {
Warning("Unable to open file %s with errno %d\n", filename, errno);
exit(-1);
}
//XXX the format below is hardcoded and used by extractFile
RpcVMX_Log("%s: %s: ver - %d", LOG_START_MARK, filename, LOG_VERSION);
while ((readLen = fread(buf, 1, sizeof buf, fp)) > 0 ) {
if (Base64_Encode(buf, readLen, base64Buf, sizeof base64B - 1, NULL)) {
RpcVMX_Log("%s", base64B);
} else {
Warning("Error in Base64_Encode\n");
goto exit;
}
}
exit:
RpcVMX_Log(LOG_END_MARK);
fclose(fp);
}
int Encrypt_Ex(const char *Key, const char *AppIP, const char *pInput3DES, char *pOutputCGIParameter, int iOutputLen, char *pErrMsg)
{
char szKey[MAX_CGIPARA_LEN];
int iRet, iLen, iInputLen, iLenAfterEncrypt;
char szOutTmp[iOutputLen];
char szOutTmp2[iOutputLen];
char szInputBuf[iOutputLen];
memset(pOutputCGIParameter, 0x0, iOutputLen);
memset(szOutTmp, 0x0, sizeof(szOutTmp));
memset(szOutTmp2, 0x0, sizeof(szOutTmp2));
memset(szInputBuf, 0x0, sizeof(szInputBuf));
//pre operator
char sKey[MAX_CGIPARA_LEN]={0};
strncpy(sKey, Key, MAX_CGIPARA_LEN);
if ((iLen = strlen(sKey)) < 24)
{
for (int i = iLen;i < 24;i++)
sKey[i] = '0';
}
if ((iRet = Create3DesKey(sKey, szKey, sizeof(szKey), pErrMsg)) != PAYPORTAL_OK)
{
sprintf(pErrMsg, "Create3DesKey fail [key=%s]", sKey);
return iRet;
}
iInputLen =strlen(pInput3DES) + strlen("&AppIP=") + strlen(AppIP);
if (iInputLen> iOutputLen)
{
strcpy(pErrMsg, "require more output buffer");
return ENCRYPE_FAIL;
}
strcpy(szInputBuf, pInput3DES);
strcat(szInputBuf, "&AppIP=");
strcat(szInputBuf, AppIP);
if ((iRet = Portal_des_encrypt(szKey, (unsigned char *)szInputBuf, (unsigned char *)szOutTmp, iInputLen, iOutputLen, &iLenAfterEncrypt, DES_ENCRYPT,pErrMsg)) != PAYPORTAL_OK)
{
strcat(pErrMsg, "Portal_des_encrypt err");
return iRet;
}
if ((iRet = Base64_Encode((const unsigned char *)szOutTmp, iLenAfterEncrypt, szOutTmp2, iOutputLen, &iLenAfterEncrypt))!= 0)
{
sprintf(pErrMsg, "Base64_Encode err [Ret=%d]", iRet);
return ENCRYPE_FAIL;
}
encode_hexstring(szOutTmp2, strlen(szOutTmp2), pOutputCGIParameter);
return PAYPORTAL_OK;
}
static void create_tpm_enrollment_device()
{
INDIVIDUAL_ENROLLMENT_HANDLE indiv_enrollment = NULL;
PROVISIONING_SERVICE_CLIENT_HANDLE prov_sc_handle = prov_sc_create_from_connection_string(g_prov_conn_string);
ASSERT_IS_NOT_NULL(prov_sc_handle, "Failure creating provisioning service client");
prov_sc_set_trace(prov_sc_handle, TRACING_STATUS_ON);
PROV_AUTH_HANDLE auth_handle = prov_auth_create();
ASSERT_IS_NOT_NULL(auth_handle, "Failure creating auth client");
char* registration_id = prov_auth_get_registration_id(auth_handle);
ASSERT_IS_NOT_NULL(registration_id, "Failure prov_auth_get_common_name");
if (prov_sc_get_individual_enrollment(prov_sc_handle, registration_id, &indiv_enrollment) != 0)
{
BUFFER_HANDLE ek_handle = prov_auth_get_endorsement_key(auth_handle);
ASSERT_IS_NOT_NULL(ek_handle, "Failure prov_auth_get_endorsement_key");
STRING_HANDLE ek_value = Base64_Encode(ek_handle);
ASSERT_IS_NOT_NULL(ek_value, "Failure Base64_Encode Endorsement key");
ATTESTATION_MECHANISM_HANDLE attest_handle = attestationMechanism_createWithTpm(STRING_c_str(ek_value), NULL);
ASSERT_IS_NOT_NULL(attest_handle, "Failure attestationMechanism_createWithTpm");
indiv_enrollment = individualEnrollment_create(registration_id, attest_handle);
ASSERT_IS_NOT_NULL(indiv_enrollment, "Failure hsm_client_riot_get_certificate ");
BUFFER_delete(ek_handle);
STRING_delete(ek_value);
}
free(registration_id);
individualEnrollment_destroy(indiv_enrollment);
prov_auth_destroy(auth_handle);
prov_sc_destroy(prov_sc_handle);
}
gboolean
FoundryToolsDaemonGetToolsProperties(RpcInData *data) // IN
{
VixError err = VIX_OK;
int additionalError = 0;
static char resultBuffer[DEFAULT_RESULT_MSG_MAX_LENGTH];
char *serializedBuffer = NULL;
size_t serializedBufferLength = 0;
char *base64Buffer = NULL;
size_t base64BufferLength = 0;
Bool success;
char *returnBuffer = NULL;
GKeyFile *confDictRef;
/*
* Collect some values about the host.
*/
confDictRef = data->clientData;
err = VixTools_GetToolsPropertiesImpl(confDictRef,
&serializedBuffer,
&serializedBufferLength);
if (VIX_OK == err) {
base64BufferLength = Base64_EncodedLength(serializedBuffer, serializedBufferLength) + 1;
base64Buffer = Util_SafeMalloc(base64BufferLength);
success = Base64_Encode(serializedBuffer,
serializedBufferLength,
base64Buffer,
base64BufferLength,
&base64BufferLength);
if (!success) {
base64Buffer[0] = 0;
err = VIX_E_FAIL;
goto abort;
}
base64Buffer[base64BufferLength] = 0;
}
abort:
returnBuffer = base64Buffer;
if (NULL == base64Buffer) {
returnBuffer = "";
}
if (VIX_OK != err) {
additionalError = Err_Errno();
}
/*
* All VMXI tools commands return results that start with a VMXI error
* and a guest-OS-specific error.
*/
Str_Sprintf(resultBuffer,
sizeof(resultBuffer),
"%"FMT64"d %d %s",
err,
additionalError,
returnBuffer);
RPCIN_SETRETVALS(data, resultBuffer, TRUE);
free(serializedBuffer);
free(base64Buffer);
return TRUE;
} // FoundryToolsDaemonGetToolsProperties
static int Probe(TProxy *pProxy)
{
if (pProxy->m_status == PROXY_STATUS_CONNECTING)
{
int rv;
rv = XOS_TCPConnectProbe(pProxy->m_sock);
if (rv == -1)
{
printf("proxy probe select failed.\r\n");
return PROXY_PROBE_ERROR;
}
else if (rv == 0)
{
//连接成功,根据不同的代理类型进入不同的状态
pProxy->m_uiOperationBeginTime = XOS_GetTickCount();
switch (pProxy->m_iProxyType)
{
case PROXY_TYPE_HTTP:
sprintf(pProxy->m_sendbuf, "%s:%s", pProxy->m_szUserName, pProxy->m_szPassword);
Base64_Encode(pProxy->m_tmpbuf, pProxy->m_sendbuf, strlen(pProxy->m_sendbuf));
sprintf(pProxy->m_sendbuf, "CONNECT %s HTTP/1.0\r\nProxy-Connection: Keep-Alive\r\nProxy-Authorization: Basic %s\r\nPragma: no-cache\r\n\r\n",
pProxy->m_szDestAddr, pProxy->m_tmpbuf);
pProxy->m_ihaveSendLen = 0;
pProxy->m_isendbufLen = strlen(pProxy->m_sendbuf);
pProxy->m_status = PROXY_STATUS_CONNECTION_REQUEST;
break;
case PROXY_TYPE_SOCKET4:
pProxy->m_sendbuf[0] = 0x04;
pProxy->m_sendbuf[1] = 0x01;
*(XOS_U16*)(&pProxy->m_sendbuf[2]) = htons(pProxy->m_usDestPort);
*(XOS_U32*)(&pProxy->m_sendbuf[4]) = pProxy->m_uiDestIP;
strcat(&pProxy->m_sendbuf[8], pProxy->m_szUserName);
pProxy->m_isendbufLen = (int)(8+strlen(pProxy->m_szUserName)+1);
//??????这个地方的发送假设可以一次发完
pProxy->m_status = PROXY_STATUS_CONNECTION_REQUEST;
break;
case PROXY_TYPE_SOCKET5:
if(strcmp(pProxy->m_szUserName, "") != 0)
{
memcpy(pProxy->m_sendbuf, "\005\002\002\000", 4);
}
else
{
memcpy(pProxy->m_sendbuf, "\005\001\000", 3);
}
pProxy->m_ihaveSendLen = 0;
pProxy->m_isendbufLen = strlen(pProxy->m_sendbuf);
pProxy->m_status = PROXY_STATUS_NEGOTIATION_REQUEST;
break;
default:
return PROXY_PROBE_ERROR;
}
}
else //rv == 1
{
return PROXY_PROBE_WOULDBLOCK;
}
}
switch (pProxy->m_iProxyType)
{
case PROXY_TYPE_HTTP:
return pProxy->ProbeHttp(pProxy);
case PROXY_TYPE_SOCKET4:
return pProxy->ProbeSocket4(pProxy);
case PROXY_TYPE_SOCKET5:
return pProxy->ProbeSocket5(pProxy);
default:
return PROXY_PROBE_ERROR;
}
}
STRING_HANDLE SASToken_Create(STRING_HANDLE key, STRING_HANDLE scope, STRING_HANDLE keyName, size_t expiry)
{
STRING_HANDLE result = NULL;
char tokenExpirationTime[32] = { 0 };
/*Codes_SRS_SASTOKEN_06_001: [If key is NULL then SASToken_Create shall return NULL.]*/
/*Codes_SRS_SASTOKEN_06_003: [If scope is NULL then SASToken_Create shall return NULL.]*/
/*Codes_SRS_SASTOKEN_06_007: [If keyName is NULL then SASToken_Create shall return NULL.]*/
if ((key == NULL) ||
(scope == NULL) ||
(keyName == NULL))
{
LogError("Invalid Parameter to SASToken_Create. handle key: %p, handle scope: %p, handle keyName: %p\r\n", key, scope, keyName);
}
else
{
BUFFER_HANDLE decodedKey;
/*Codes_SRS_SASTOKEN_06_029: [The key parameter is decoded from base64.]*/
if ((decodedKey = Base64_Decoder(STRING_c_str(key))) == NULL)
{
/*Codes_SRS_SASTOKEN_06_030: [If there is an error in the decoding then SASToken_Create shall return NULL.]*/
LogError("Unable to decode the key for generating the SAS.\r\n");
}
else
{
/*Codes_SRS_SASTOKEN_06_026: [If the conversion to string form fails for any reason then SASToken_Create shall return NULL.]*/
if (size_tToString(tokenExpirationTime, sizeof(tokenExpirationTime), expiry) != 0)
{
LogError("For some reason converting seconds to a string failed. No SAS can be generated.\r\n");
}
else
{
STRING_HANDLE toBeHashed = NULL;
BUFFER_HANDLE hash = NULL;
if (((hash = BUFFER_new()) == NULL) ||
((toBeHashed = STRING_new()) == NULL) ||
((result = STRING_new()) == NULL))
{
LogError("Unable to allocate memory to prepare SAS token.\r\n")
}
else
{
/*Codes_SRS_SASTOKEN_06_009: [The scope is the basis for creating a STRING_HANDLE.]*/
/*Codes_SRS_SASTOKEN_06_010: [A "\n" is appended to that string.]*/
/*Codes_SRS_SASTOKEN_06_011: [tokenExpirationTime is appended to that string.]*/
if ((STRING_concat_with_STRING(toBeHashed, scope) != 0) ||
(STRING_concat(toBeHashed, "\n") != 0) ||
(STRING_concat(toBeHashed, tokenExpirationTime) != 0))
{
LogError("Unable to build the input to the HMAC to prepare SAS token.\r\n");
STRING_delete(result);
result = NULL;
}
else
{
STRING_HANDLE base64Signature = NULL;
STRING_HANDLE urlEncodedSignature = NULL;
/*Codes_SRS_SASTOKEN_06_013: [If an error is returned from the HMAC256 function then NULL is returned from SASToken_Create.]*/
/*Codes_SRS_SASTOKEN_06_012: [An HMAC256 hash is calculated using the decodedKey, over toBeHashed.]*/
/*Codes_SRS_SASTOKEN_06_014: [If there are any errors from the following operations then NULL shall be returned.]*/
/*Codes_SRS_SASTOKEN_06_015: [The hash is base 64 encoded.]*/
/*Codes_SRS_SASTOKEN_06_028: [base64Signature shall be url encoded.]*/
/*Codes_SRS_SASTOKEN_06_016: [The string "SharedAccessSignature sr=" is the first part of the result of SASToken_Create.]*/
/*Codes_SRS_SASTOKEN_06_017: [The scope parameter is appended to result.]*/
/*Codes_SRS_SASTOKEN_06_018: [The string "&sig=" is appended to result.]*/
/*Codes_SRS_SASTOKEN_06_019: [The string urlEncodedSignature shall be appended to result.]*/
/*Codes_SRS_SASTOKEN_06_020: [The string "&se=" shall be appended to result.]*/
/*Codes_SRS_SASTOKEN_06_021: [tokenExpirationTime is appended to result.]*/
/*Codes_SRS_SASTOKEN_06_022: [The string "&skn=" is appended to result.]*/
/*Codes_SRS_SASTOKEN_06_023: [The argument keyName is appended to result.]*/
if ((HMACSHA256_ComputeHash(BUFFER_u_char(decodedKey), BUFFER_length(decodedKey), (const unsigned char*)STRING_c_str(toBeHashed), STRING_length(toBeHashed), hash) != HMACSHA256_OK) ||
((base64Signature = Base64_Encode(hash)) == NULL) ||
((urlEncodedSignature = URL_Encode(base64Signature)) == NULL) ||
(STRING_copy(result, "SharedAccessSignature sr=") != 0) ||
(STRING_concat_with_STRING(result, scope) != 0) ||
(STRING_concat(result, "&sig=") != 0) ||
(STRING_concat_with_STRING(result, urlEncodedSignature) != 0) ||
(STRING_concat(result, "&se=") != 0) ||
(STRING_concat(result, tokenExpirationTime) != 0) ||
(STRING_concat(result, "&skn=") != 0) ||
(STRING_concat_with_STRING(result, keyName) != 0))
{
LogError("Unable to build the SAS token.\r\n");
STRING_delete(result);
result = NULL;
}
else
{
/* everything OK */
}
STRING_delete(base64Signature);
STRING_delete(urlEncodedSignature);
}
}
STRING_delete(toBeHashed);
BUFFER_delete(hash);
}
BUFFER_delete(decodedKey);
}
}
return result;
}
