int main() { struct soap soap; double a, b, result; /* Init SSL */ soap_ssl_init(); if (CRYPTO_thread_setup()) { fprintf(stderr, "Cannot setup thread mutex for OpenSSL\n"); exit(1); } a = 10.0; b = 20.0; /* Init gSOAP context */ soap_init(&soap); /* The supplied server certificate "server.pem" assumes that the server is running on 'localhost', so clients can only connect from the same host when verifying the server's certificate. Use SOAP_SSL_NO_AUTHENTICATION to omit the authentication of the server and use encryption directly from any site. To verify the certificates of third-party services, they must provide a certificate issued by Verisign or another trusted CA. At the client-side, the capath parameter should point to a directory that contains these trusted (root) certificates or the cafile parameter should refer to one file will all certificates. To help you out, the supplied "cacerts.pem" file contains the certificates issued by various CAs. You should use this file for the cafile parameter instead of "cacert.pem" to connect to trusted servers. Note that the client may fail to connect if the server's credentials have problems (e.g. expired). Use SOAP_SSL_NO_AUTHENTICATION and set cacert to NULL to encrypt messages if you don't care about the trustworthyness of the server. Note: setting capath may not work on Windows. */ if (soap_ssl_client_context(&soap, /* SOAP_SSL_NO_AUTHENTICATION, */ /* for encryption w/o authentication */ /* SOAP_SSL_DEFAULT | SOAP_SSL_SKIP_HOST_CHECK, */ /* if we don't want the host name checks since these will change from machine to machine */ SOAP_SSL_DEFAULT, /* use SOAP_SSL_DEFAULT in production code */ NULL, /* keyfile (cert+key): required only when client must authenticate to server (see SSL docs to create this file) */ NULL, /* password to read the keyfile */ "cacert.pem", /* optional cacert file to store trusted certificates, use cacerts.pem for all public certificates issued by common CAs */ NULL, /* optional capath to directory with trusted certificates */ NULL /* if randfile!=NULL: use a file with random data to seed randomness */ )) { soap_print_fault(&soap, stderr); exit(1); } soap.connect_timeout = 60; /* try to connect for 1 minute */ soap.send_timeout = soap.recv_timeout = 30; /* if I/O stalls, then timeout after 30 seconds */ if (soap_call_ns__add(&soap, server, "", a, b, &result) == SOAP_OK) fprintf(stdout, "Result: %f + %f = %f\n", a, b, result); else soap_print_fault(&soap, stderr); soap_destroy(&soap); /* C++ */ soap_end(&soap); soap_done(&soap); CRYPTO_thread_cleanup(); return 0; }
struct soap* init_soap(void) { FILE *fd = NULL; struct soap* soap = NULL; char passwd[10] = {'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0'}; soap = soap_new1(SOAP_XML_CANONICAL | SOAP_XML_INDENT); soap_ssl_init(); // soap_register_plugin(soap, plugin); // register plugin soap_register_plugin(soap, soap_wsse); fd = fopen("secrets", "r"); if (fd) { fgets(passwd, 10, fd); fclose(fd); if (passwd == NULL) { perror("Unable to read password for X509 certificate."); return NULL; } } else { perror("Unable to open secrets file"); return NULL; } fd = fopen("DMOPEN_100014_PRIVATE.pem", "r"); if (fd) { rsa_private_key = PEM_read_PrivateKey(fd, NULL, NULL, passwd); fclose(fd); if (rsa_private_key == NULL) { perror("Error reading private key"); return NULL; } } else { perror("Unable to open Private X509 .pem file"); return NULL; } fd = fopen("DMOPEN_100014.pem", "r"); if (fd) { cert = PEM_read_X509(fd, NULL, NULL, NULL); fclose(fd); if (cert == NULL) { perror("Error reading certificate file"); return NULL; } } else { perror("Unable to open publix X509 .pem file"); return NULL; } return soap; }
void *CbirGVT::GetGvtImagesCommon(string& access_token) const { string msg = "CbirGVT::GetGvtImagesCommon() : "; GetDataBase()->WriteLog(msg+"starting"); string endpoint, username; // Get access_token access_token = getAccessToken(username); static bool first = true; if (first) { soap_ssl_init(); // init OpenSSL (just once) first = false; } // Create the soap client ImageCollectionServiceSoapBindingProxy *imageCollection = new ImageCollectionServiceSoapBindingProxy; if (imageCollection == NULL) { cerr << "Cannot connect to Web Service. Exiting." << endl; return NULL; } if (!endpoint.empty()) { // User gave an alternate endpoint, use it imageCollection->soap_endpoint = endpoint.c_str(); } // Set the alternate cacert if needed if (!OpenXerox::GSoap::setCacert(imageCollection)) { return NULL; } // Set the proxy from the https_proxy environment variable OpenXerox::GSoap::setHttpsProxy(imageCollection); // Set authentication before each call setAuthorization(imageCollection, access_token); gvt__getLoginName loginname_payload; gvt__getLoginNameResponse loginname_response; if (imageCollection->getLoginName(&loginname_payload, &loginname_response) == SOAP_OK) { // cerr << "Your login name is: " << *loginname_response.return_ << endl; } else { soap_print_fault(imageCollection, stderr); } setAuthorization(imageCollection, access_token); return imageCollection; }
void AmazonSimpleStorageService::initializeService() { if ( m_initialized ) { return; } m_initialized = true; // Hier müssen Sie Ihre eigenen Daten eintragen. std::ifstream input("/home/eternus/PROG3Projekt/AmazonS3.data"); input >> m_key; input >> m_value; input.close(); soap_ssl_init(); }
int md5_handler(struct soap *soap, void **context, enum md5_action action, char *buf, size_t len) { EVP_MD_CTX *ctx; unsigned char hash[EVP_MAX_MD_SIZE]; unsigned int size; switch (action) { case MD5_INIT: soap_ssl_init(); if (!*context) { *context = (void*)SOAP_MALLOC(soap, sizeof(EVP_MD_CTX)); EVP_MD_CTX_init((EVP_MD_CTX*)*context); } ctx = (EVP_MD_CTX*)*context; DBGLOG(TEST, SOAP_MESSAGE(fdebug, "-- MD5 Init %p\n", ctx)); EVP_DigestInit_ex(ctx, EVP_md5(), NULL); break; case MD5_UPDATE: ctx = (EVP_MD_CTX*)*context; DBGLOG(TEST, SOAP_MESSAGE(fdebug, "-- MD5 Update %p (%lu) --\n", ctx, (unsigned long)len)); DBGMSG(TEST, buf, len); DBGLOG(TEST, SOAP_MESSAGE(fdebug, "\n--")); EVP_DigestUpdate(ctx, (const void*)buf, (unsigned int)len); break; case MD5_FINAL: ctx = (EVP_MD_CTX*)*context; EVP_DigestFinal_ex(ctx, (unsigned char*)hash, &size); DBGLOG(TEST, SOAP_MESSAGE(fdebug, "-- MD5 Final %p --\n", ctx)); DBGHEX(TEST, hash, size); DBGLOG(TEST, SOAP_MESSAGE(fdebug, "\n--")); soap_memcpy((void*)buf, 16, (const void*)hash, 16); break; case MD5_DELETE: ctx = (EVP_MD_CTX*)*context; DBGLOG(TEST, SOAP_MESSAGE(fdebug, "-- MD5 Delete %p --\n", ctx)); if (ctx) { EVP_MD_CTX_cleanup(ctx); SOAP_FREE(soap, ctx); } *context = NULL; } return SOAP_OK; }
int main(int argc, char **argv) { static const int count = 10; pthread_t thread[count]; soap_ssl_init(); if (CRYPTO_thread_setup()) { fprintf(stderr, "Cannot setup thread mutex for OpenSSL\n"); exit(1); } /*for (int i = 0; i < count; ++i) { pthread_create(&thread[i], NULL, thread_func, NULL); }*/ pthread_create(&thread[0], NULL, thread_func, NULL); pthread_create(&thread[1], NULL, thread_func_1, NULL); pthread_create(&thread[2], NULL, thread_func_2, NULL); pthread_create(&thread[3], NULL, thread_func_3, NULL); pthread_create(&thread[4], NULL, thread_func_4, NULL); pthread_create(&thread[5], NULL, thread_func_5, NULL); pthread_create(&thread[6], NULL, thread_func_6, NULL); pthread_create(&thread[7], NULL, thread_func_7, NULL); pthread_create(&thread[8], NULL, thread_func_8, NULL); pthread_create(&thread[9], NULL, thread_func_9, NULL); while (1) { sleep(1); } CRYPTO_thread_cleanup(); return 0; }
int main() { wsHttpWellthServiceProxy service; //char request[64]; std::string request = "*****@*****.**"; char response[64]; _ns3__GetNameByEmailID soapRequest; _ns3__GetNameByEmailIDResponse soapResponse; struct soap *pSoap = NULL; pSoap = soap_new(); soap_set_namespaces(pSoap,namespaces); soap_ssl_init(); if (soap_ssl_client_context(pSoap, SOAP_SSL_NO_AUTHENTICATION, NULL,NULL,NULL,NULL,NULL) == SOAP_OK) std::cout << "Client COntext set OK " << std::endl; /** strcpy(request,"*****@*****.**"); soapRequest.emailID = (std::string *)&request; **/ pSoap->ssl_flags = SOAP_SSL_NO_AUTHENTICATION | SOAP_SSL_NO_DEFAULT_CA_PATH; soapRequest.emailID = &request; soapRequest.soap = pSoap; // if (service.GetNameByEmailID((_ns3__GetNameByEmailID*)request,(_ns3__GetNameByEmailIDResponse*)response) == SOAP_OK) //soap_call___ns1__GetNameByEmailID(pSoap,NULL,NULL,&soapRequest,&soapResponse); if (service.GetNameByEmailID(&soapRequest,&soapResponse) == SOAP_OK) std::cout << "The response is " << response << std::endl; else service.soap_stream_fault(std::cerr); service.destroy(); // delete data and release memory }
void initialize_soap_client( const char *_merchant_id, const char *_transaction_key, const char *_cacerts_file, const char *_server_url, const bool _soap_debugging_mode) { if (MERCHANT_ID == NULL) { printf("setting MERCHANT_ID..\n"); MERCHANT_ID = strdup(_merchant_id); TRANSACTION_KEY = strdup(_transaction_key); CACERTS_FILE = strdup(_cacerts_file); SERVER_URL = strdup(_server_url); if (!soap_client_initialized) { // one-time initializations printf("initialize_soap_client..\n"); signal(SIGPIPE, sigpipe_handle); soap_ssl_init(); soap_client_initialized = true; } } soap_debugging_mode = _soap_debugging_mode; }
int bes_init(struct bes_context **context) { struct bes_context *ctx; struct soap *soap; if (context == NULL) { return BESE_BAD_ARG; } ctx = (struct bes_context *)malloc(sizeof(struct bes_context)); if (ctx == NULL) { // fprintf (stderr, "err 1\n"); return BESE_SYS_ERR; } memset(ctx, 0, sizeof(struct bes_context)); soap_ssl_init(); soap = soap_new1(SOAP_C_UTFSTRING); if (soap == NULL) { free(ctx); // fprintf (stderr, "err 2\n"); return BESE_SYS_ERR; } soap_set_recv_logfile(soap, NULL); soap_set_sent_logfile(soap, NULL); soap_set_test_logfile(soap, NULL); soap_register_plugin(soap, soap_wsse); soap_set_namespaces(soap, default_namespaces); soap_header(soap); ctx->soap = soap; *context = ctx; return BESE_OK; }
/** * * @param argc * @param argv[] * @return */ int main(int argc, char* argv[]) { bool fSSL = false; const char *pcszArgEndpoint = "http://localhost:18083/"; int ap; for (ap = 1; ap < argc; ap++) { if (argv[ap][0] == '-') { if (!strcmp(argv[ap], "-h")) usage(0); else if (!strcmp(argv[ap], "-c")) { ap++; if (ap >= argc) usage(1); pcszArgEndpoint = argv[ap]; fSSL = !strncmp(pcszArgEndpoint, "https://", 8); } else usage(1); } else break; } if (argc < 1 + ap) usage(1); #ifdef WITH_OPENSSL if (fSSL) soap_ssl_init(); #endif /* WITH_OPENSSL */ struct soap soap; // gSOAP runtime environment soap_init(&soap); // initialize runtime environment (only once) #ifdef WITH_OPENSSL // Use SOAP_SSL_NO_AUTHENTICATION here to accept broken server configs. // In a real world setup please use at least SOAP_SSL_DEFAULT and provide // the necessary CA certificate for validating the server's certificate. if (fSSL && soap_ssl_client_context(&soap, SOAP_SSL_NO_AUTHENTICATION, NULL /*clientkey*/, NULL /*password*/, NULL /*cacert*/, NULL /*capath*/, NULL /*randfile*/)) { soap_print_fault(&soap, stderr); exit(1); } #endif /* WITH_OPENSSL */ const char *pcszMode = argv[ap]; int soaprc = SOAP_SVR_FAULT; if (!strcmp(pcszMode, "logon")) { if (argc < 3 + ap) std::cout << "Not enough arguments for \"" << pcszMode << "\" mode.\n"; else { _vbox__IWebsessionManager_USCORElogon req; req.username = argv[ap + 1]; req.password = argv[ap + 2]; _vbox__IWebsessionManager_USCORElogonResponse resp; if (!(soaprc = soap_call___vbox__IWebsessionManager_USCORElogon(&soap, pcszArgEndpoint, NULL, &req, &resp))) std::cout << "VirtualBox objref: \"" << resp.returnval << "\"\n"; } } else if (!strcmp(pcszMode, "getsession")) { if (argc < 2 + ap) std::cout << "Not enough arguments for \"" << pcszMode << "\" mode.\n"; else { _vbox__IWebsessionManager_USCOREgetSessionObject req; req.refIVirtualBox = argv[ap + 1]; _vbox__IWebsessionManager_USCOREgetSessionObjectResponse resp; if (!(soaprc = soap_call___vbox__IWebsessionManager_USCOREgetSessionObject(&soap, pcszArgEndpoint, NULL, &req, &resp))) std::cout << "session: \"" << resp.returnval << "\"\n"; } } else if (!strcmp(pcszMode, "logoff")) { if (argc < 2 + ap) std::cout << "Not enough arguments for \"" << pcszMode << "\" mode.\n"; else { _vbox__IWebsessionManager_USCORElogoff req; req.refIVirtualBox = argv[ap + 1]; _vbox__IWebsessionManager_USCORElogoffResponse resp; if (!(soaprc = soap_call___vbox__IWebsessionManager_USCORElogoff(&soap, pcszArgEndpoint, NULL, &req, &resp))) { ; } } } else if (!strcmp(pcszMode, "version")) { if (argc < 2 + ap) std::cout << "Not enough arguments for \"" << pcszMode << "\" mode.\n"; else { _vbox__IVirtualBox_USCOREgetVersion req; req._USCOREthis = argv[ap + 1]; _vbox__IVirtualBox_USCOREgetVersionResponse resp; if (!(soaprc = soap_call___vbox__IVirtualBox_USCOREgetVersion(&soap, pcszArgEndpoint, NULL, &req, &resp))) std::cout << "version: \"" << resp.returnval << "\"\n"; } } else if (!strcmp(pcszMode, "gethost")) { if (argc < 2 + ap) std::cout << "Not enough arguments for \"" << pcszMode << "\" mode.\n"; else { _vbox__IVirtualBox_USCOREgetHost req; req._USCOREthis = argv[ap + 1]; _vbox__IVirtualBox_USCOREgetHostResponse resp; if (!(soaprc = soap_call___vbox__IVirtualBox_USCOREgetHost(&soap, pcszArgEndpoint, NULL, &req, &resp))) { std::cout << "Host objref " << resp.returnval << "\n"; } } } else if (!strcmp(pcszMode, "getpc")) { if (argc < 2 + ap) std::cout << "Not enough arguments for \"" << pcszMode << "\" mode.\n"; else { _vbox__IVirtualBox_USCOREgetPerformanceCollector req; req._USCOREthis = argv[ap + 1]; _vbox__IVirtualBox_USCOREgetPerformanceCollectorResponse resp; if (!(soaprc = soap_call___vbox__IVirtualBox_USCOREgetPerformanceCollector(&soap, pcszArgEndpoint, NULL, &req, &resp))) { std::cout << "Performance collector objref " << resp.returnval << "\n"; } } } else if (!strcmp(pcszMode, "getmachines")) { if (argc < 2 + ap) std::cout << "Not enough arguments for \"" << pcszMode << "\" mode.\n"; else { _vbox__IVirtualBox_USCOREgetMachines req; req._USCOREthis = argv[ap + 1]; _vbox__IVirtualBox_USCOREgetMachinesResponse resp; if (!(soaprc = soap_call___vbox__IVirtualBox_USCOREgetMachines(&soap, pcszArgEndpoint, NULL, &req, &resp))) { size_t c = resp.returnval.size(); for (size_t i = 0; i < c; ++i) { std::cout << "Machine " << i << ": objref " << resp.returnval[i] << "\n"; } } } } else if (!strcmp(pcszMode, "createmachine")) { if (argc < 4 + ap) std::cout << "Not enough arguments for \"" << pcszMode << "\" mode.\n"; else { _vbox__IVirtualBox_USCOREcreateMachine req; req._USCOREthis = argv[ap + 1]; req.settingsFile = argv[ap + 2]; req.name = argv[ap + 3]; std::cout << "createmachine: settingsFile = \"" << req.settingsFile << "\", name = \"" << req.name << "\"\n"; _vbox__IVirtualBox_USCOREcreateMachineResponse resp; if (!(soaprc = soap_call___vbox__IVirtualBox_USCOREcreateMachine(&soap, pcszArgEndpoint, NULL, &req, &resp))) std::cout << "Machine created: managed object reference ID is " << resp.returnval << "\n"; } } else if (!strcmp(pcszMode, "registermachine")) { if (argc < 3 + ap) std::cout << "Not enough arguments for \"" << pcszMode << "\" mode.\n"; else { _vbox__IVirtualBox_USCOREregisterMachine req; req._USCOREthis = argv[ap + 1]; req.machine = argv[ap + 2]; _vbox__IVirtualBox_USCOREregisterMachineResponse resp; if (!(soaprc = soap_call___vbox__IVirtualBox_USCOREregisterMachine(&soap, pcszArgEndpoint, NULL, &req, &resp))) std::cout << "Machine registered.\n"; } } else if (!strcmp(pcszMode, "getdvddrives")) { if (argc < 2 + ap) std::cout << "Not enough arguments for \"" << pcszMode << "\" mode.\n"; else { _vbox__IHost_USCOREgetDVDDrives req; req._USCOREthis = argv[ap + 1]; _vbox__IHost_USCOREgetDVDDrivesResponse resp; if (!(soaprc = soap_call___vbox__IHost_USCOREgetDVDDrives(&soap, pcszArgEndpoint, NULL, &req, &resp))) { size_t c = resp.returnval.size(); for (size_t i = 0; i < c; ++i) { std::cout << "DVD drive " << i << ": objref " << resp.returnval[i] << "\n"; } } } } else if (!strcmp(pcszMode, "getname")) { if (argc < 2 + ap) std::cout << "Not enough arguments for \"" << pcszMode << "\" mode.\n"; else { _vbox__IMachine_USCOREgetName req; req._USCOREthis = argv[ap + 1]; _vbox__IMachine_USCOREgetNameResponse resp; if (!(soaprc = soap_call___vbox__IMachine_USCOREgetName(&soap, pcszArgEndpoint, NULL, &req, &resp))) printf("Name is: %s\n", resp.returnval.c_str()); } } else if (!strcmp(pcszMode, "getid")) { if (argc < 2 + ap) std::cout << "Not enough arguments for \"" << pcszMode << "\" mode.\n"; else { _vbox__IMachine_USCOREgetId req; req._USCOREthis = argv[ap + 1]; _vbox__IMachine_USCOREgetIdResponse resp; if (!(soaprc = soap_call___vbox__IMachine_USCOREgetId(&soap, pcszArgEndpoint, NULL, &req, &resp))) std::cout << "UUID is: " << resp.returnval << "\n";; } } else if (!strcmp(pcszMode, "getostypeid")) { if (argc < 2 + ap) std::cout << "Not enough arguments for \"" << pcszMode << "\" mode.\n"; else { _vbox__IMachine_USCOREgetOSTypeId req; req._USCOREthis = argv[ap + 1]; _vbox__IMachine_USCOREgetOSTypeIdResponse resp; if (!(soaprc = soap_call___vbox__IMachine_USCOREgetOSTypeId(&soap, pcszArgEndpoint, NULL, &req, &resp))) std::cout << "Guest OS type is: " << resp.returnval << "\n"; } } else if (!strcmp(pcszMode, "savesettings")) { if (argc < 2 + ap) std::cout << "Not enough arguments for \"" << pcszMode << "\" mode.\n"; else { _vbox__IMachine_USCOREsaveSettings req; req._USCOREthis = argv[ap + 1]; _vbox__IMachine_USCOREsaveSettingsResponse resp; if (!(soaprc = soap_call___vbox__IMachine_USCOREsaveSettings(&soap, pcszArgEndpoint, NULL, &req, &resp))) std::cout << "Settings saved\n"; } } else if (!strcmp(pcszMode, "setupmetrics")) { if (argc < 2 + ap) std::cout << "Not enough arguments for \"" << pcszMode << "\" mode.\n"; else { _vbox__IPerformanceCollector_USCOREsetupMetrics req; req._USCOREthis = argv[ap + 1]; // req.metricNames[0] = "*"; // req.objects req.period = 1; // seconds req.count = 100; _vbox__IPerformanceCollector_USCOREsetupMetricsResponse resp; if (!(soaprc = soap_call___vbox__IPerformanceCollector_USCOREsetupMetrics(&soap, pcszArgEndpoint, NULL, &req, &resp))) { size_t c = resp.returnval.size(); for (size_t i = 0; i < c; ++i) { std::cout << "Metric " << i << ": objref " << resp.returnval[i] << "\n"; } } } } else if (!strcmp(pcszMode, "querymetricsdata")) { if (argc < 2 + ap) std::cout << "Not enough arguments for \"" << pcszMode << "\" mode.\n"; else { _vbox__IPerformanceCollector_USCOREqueryMetricsData req; req._USCOREthis = argv[ap + 1]; // req.metricNames[0] = "*"; // req.objects _vbox__IPerformanceCollector_USCOREqueryMetricsDataResponse resp; if (!(soaprc = soap_call___vbox__IPerformanceCollector_USCOREqueryMetricsData(&soap, pcszArgEndpoint, NULL, &req, &resp))) { size_t c = resp.returnval.size(); for (size_t i = 0; i < c; ++i) { std::cout << "long " << i << ": " << resp.returnval[i] << "\n"; } } } } else if (!strcmp(pcszMode, "errorinfo")) { if (argc < 2 + ap) std::cout << "Not enough arguments for \"" << pcszMode << "\" mode.\n"; else { _vbox__IVirtualBoxErrorInfo_USCOREgetResultCode req; req._USCOREthis = argv[ap + 1]; _vbox__IVirtualBoxErrorInfo_USCOREgetResultCodeResponse resp; if (!(soaprc = soap_call___vbox__IVirtualBoxErrorInfo_USCOREgetResultCode(&soap, pcszArgEndpoint, NULL, &req, &resp))) { std::cout << "ErrorInfo ResultCode: " << std::hex << resp.returnval << "\n"; _vbox__IVirtualBoxErrorInfo_USCOREgetText req2; req2._USCOREthis = argv[ap + 1]; _vbox__IVirtualBoxErrorInfo_USCOREgetTextResponse resp2; if (!(soaprc = soap_call___vbox__IVirtualBoxErrorInfo_USCOREgetText(&soap, pcszArgEndpoint, NULL, &req2, &resp2))) { std::cout << "ErrorInfo Text: " << resp2.returnval << "\n"; _vbox__IVirtualBoxErrorInfo_USCOREgetNext req3; req3._USCOREthis = argv[ap + 1]; _vbox__IVirtualBoxErrorInfo_USCOREgetNextResponse resp3; if (!(soaprc = soap_call___vbox__IVirtualBoxErrorInfo_USCOREgetNext(&soap, pcszArgEndpoint, NULL, &req3, &resp3))) std::cout << "Next ErrorInfo: " << resp3.returnval << "\n"; } } } } else if (!strcmp(pcszMode, "release")) { if (argc < 2 + ap) std::cout << "Not enough arguments for \"" << pcszMode << "\" mode.\n"; else { _vbox__IManagedObjectRef_USCORErelease req; req._USCOREthis = argv[ap + 1]; _vbox__IManagedObjectRef_USCOREreleaseResponse resp; if (!(soaprc = soap_call___vbox__IManagedObjectRef_USCORErelease(&soap, pcszArgEndpoint, NULL, &req, &resp))) std::cout << "Managed object reference " << req._USCOREthis << " released.\n"; } } else std::cout << "Unknown mode parameter \"" << pcszMode << "\".\n"; if (soaprc) { if ( (soap.fault) && (soap.fault->detail) ) { // generic fault message whether the fault is known or not std::cerr << "Generic fault message:\n"; soap_print_fault(&soap, stderr); // display the SOAP fault message on the stderr stream if (soap.fault->detail->vbox__InvalidObjectFault) { std::cerr << "Bad object ID: " << soap.fault->detail->vbox__InvalidObjectFault->badObjectID << "\n"; } else if (soap.fault->detail->vbox__RuntimeFault) { std::cerr << "Result code: 0x" << std::hex << soap.fault->detail->vbox__RuntimeFault->resultCode << "\n"; std::cerr << "ErrorInfo: " << soap.fault->detail->vbox__RuntimeFault->returnval << "\n"; } } else { std::cerr << "Invalid fault data, fault message:\n"; soap_print_fault(&soap, stderr); // display the SOAP fault message on the stderr stream } } soap_destroy(&soap); // delete deserialized class instances (for C++ only) soap_end(&soap); // remove deserialized data and clean up soap_done(&soap); // detach the gSOAP environment return soaprc; }
/** @fn int soap_mec_init(struct soap *soap, struct soap_mec_data *data, int alg, SOAP_MEC_KEY_TYPE *pkey, unsigned char *key, int *keylen) @brief Initialize mecevp engine state and create context for encryption/decryption algorithm using a private/public key or symmetric secret key. @param soap context @param[in,out] data mecevp engine context @param[in] alg encryption/decryption algorithm @param[in] pkey public/private key or NULL @param[in,out] key secret key or encrypted ephemeral secret key set with envelope encryption, or NULL @param[in,out] keylen secret key length @return SOAP_OK or SOAP_SSL_ERROR */ int soap_mec_init(struct soap *soap, struct soap_mec_data *data, int alg, SOAP_MEC_KEY_TYPE *pkey, unsigned char *key, int *keylen) { int ok = 1; DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_mec_init()\n")); soap_ssl_init(); data->ctx = (EVP_CIPHER_CTX*)SOAP_MALLOC(soap, sizeof(EVP_CIPHER_CTX)); if (!data->ctx) return soap->error = SOAP_EOM; EVP_CIPHER_CTX_init(data->ctx); data->alg = alg; data->state = SOAP_MEC_STATE_NONE; if (alg & SOAP_MEC_DES_CBC) data->type = EVP_des_ede3_cbc(); /* triple DES CBC */ else if (alg & SOAP_MEC_AES128_CBC) data->type = EVP_get_cipherbyname("AES128"); else if (alg & SOAP_MEC_AES192_CBC) data->type = EVP_get_cipherbyname("AES192"); else if (alg & SOAP_MEC_AES256_CBC) data->type = EVP_get_cipherbyname("AES256"); else if (alg & SOAP_MEC_AES512_CBC) data->type = EVP_get_cipherbyname("AES512"); else data->type = EVP_enc_null(); data->buf = NULL; data->rest = NULL; data->restlen = 0; if (alg & SOAP_MEC_ENC) { if (!data->type) return soap_mec_check(soap, data, 0, "soap_mec_init() failed: cannot load cipher"); EVP_EncryptInit_ex(data->ctx, data->type, NULL, NULL, NULL); } if (alg & SOAP_MEC_OAEP) EVP_CIPHER_CTX_set_padding(data->ctx, RSA_PKCS1_OAEP_PADDING); else EVP_CIPHER_CTX_set_padding(data->ctx, RSA_PKCS1_PADDING); switch (alg & SOAP_MEC_MASK) { case SOAP_MEC_ENV_ENC_AES128_CBC: case SOAP_MEC_ENV_ENC_AES192_CBC: case SOAP_MEC_ENV_ENC_AES256_CBC: case SOAP_MEC_ENV_ENC_AES512_CBC: case SOAP_MEC_ENV_ENC_DES_CBC: ok = EVP_CIPHER_CTX_rand_key(data->ctx, data->ekey); /* generate ephemeral secret key */ #if (OPENSSL_VERSION_NUMBER >= 0x01000000L) *keylen = EVP_PKEY_encrypt_old(key, data->ekey, EVP_CIPHER_CTX_key_length(data->ctx), pkey); #else *keylen = EVP_PKEY_encrypt(key, data->ekey, EVP_CIPHER_CTX_key_length(data->ctx), pkey); #endif key = data->ekey; /* fall through to next arm */ case SOAP_MEC_ENC_DES_CBC: case SOAP_MEC_ENC_AES128_CBC: case SOAP_MEC_ENC_AES192_CBC: case SOAP_MEC_ENC_AES256_CBC: case SOAP_MEC_ENC_AES512_CBC: data->bufidx = 0; data->buflen = 1024; /* > iv in base64 must fit */ data->buf = (char*)SOAP_MALLOC(soap, data->buflen); data->key = key; break; case SOAP_MEC_ENV_DEC_AES128_CBC: case SOAP_MEC_ENV_DEC_AES192_CBC: case SOAP_MEC_ENV_DEC_AES256_CBC: case SOAP_MEC_ENV_DEC_AES512_CBC: case SOAP_MEC_ENV_DEC_DES_CBC: case SOAP_MEC_DEC_DES_CBC: case SOAP_MEC_DEC_AES128_CBC: case SOAP_MEC_DEC_AES192_CBC: case SOAP_MEC_DEC_AES256_CBC: case SOAP_MEC_DEC_AES512_CBC: data->pkey = pkey; data->key = key; data->keylen = *keylen; break; default: return soap_set_receiver_error(soap, "Unsupported encryption algorithm", NULL, SOAP_SSL_ERROR); } return soap_mec_check(soap, data, ok, "soap_mec_init() failed"); }
/** @fn int soap_smd_init(struct soap *soap, struct soap_smd_data *data, int alg, const void *key, int keylen) @brief Initiates a (signed) digest computation. @param soap context @param[in,out] data smdevp engine context @param[in] alg is algorithm to use @param[in] key is key to use or NULL for digests @param[in] keylen is length of HMAC key (when provided) @return SOAP_OK or SOAP_SSL_ERROR */ int soap_smd_init(struct soap *soap, struct soap_smd_data *data, int alg, const void *key, int keylen) { int ok = 1; const EVP_MD *type; soap_ssl_init(); /* the algorithm to use */ data->alg = alg; /* the key to use */ data->key = key; /* allocate and init the OpenSSL HMAC or EVP_MD context */ if ((alg & SOAP_SMD_ALGO) == SOAP_SMD_HMAC) { data->ctx = (void*)SOAP_MALLOC(soap, sizeof(HMAC_CTX)); if (!data->ctx) return soap_set_receiver_error(soap, "soap_smd_init() failed", "No context", SOAP_SSL_ERROR); HMAC_CTX_init((HMAC_CTX*)data->ctx); } else { data->ctx = (void*)SOAP_MALLOC(soap, sizeof(EVP_MD_CTX)); if (!data->ctx) return soap_set_receiver_error(soap, "soap_smd_init() failed", "No context", SOAP_SSL_ERROR); EVP_MD_CTX_init((EVP_MD_CTX*)data->ctx); } DBGLOG(TEST, SOAP_MESSAGE(fdebug, "-- SMD Init alg=%x (%p) --\n", alg, data->ctx)); /* init the digest or signature computations */ switch (alg & SOAP_SMD_HASH) { case SOAP_SMD_MD5: type = EVP_md5(); break; case SOAP_SMD_SHA1: type = EVP_sha1(); break; #if (OPENSSL_VERSION_NUMBER >= 0x0090800fL) case SOAP_SMD_SHA224: type = EVP_sha224(); break; case SOAP_SMD_SHA256: type = EVP_sha256(); break; case SOAP_SMD_SHA384: type = EVP_sha384(); break; case SOAP_SMD_SHA512: type = EVP_sha512(); break; #endif default: return soap_smd_check(soap, data, 0, "soap_smd_init() failed: cannot load digest"); } switch (alg & SOAP_SMD_ALGO) { case SOAP_SMD_HMAC: HMAC_Init((HMAC_CTX*)data->ctx, key, keylen, type); break; case SOAP_SMD_DGST: EVP_DigestInit((EVP_MD_CTX*)data->ctx, type); break; case SOAP_SMD_SIGN: ok = EVP_SignInit((EVP_MD_CTX*)data->ctx, type); break; case SOAP_SMD_VRFY: ok = EVP_VerifyInit((EVP_MD_CTX*)data->ctx, type); break; default: return soap_set_receiver_error(soap, "Unsupported digest algorithm", NULL, SOAP_SSL_ERROR); } /* check and return */ return soap_smd_check(soap, data, ok, "soap_smd_init() failed"); }
int main(int argc, char **argv) { if (argc < 4) { fprintf(stderr, "Usage: [add|sub|mul|div|pow] num num\n"); exit(0); } double a, b, result; a = strtod(argv[2], NULL); b = strtod(argv[3], NULL); calcProxy calc; calc.soap_endpoint = server; #ifdef WITH_OPENSSL soap_ssl_init(); if (soap_ssl_client_context(&calc, //SOAP_SSL_DEFAULT, /* use SOAP_SSL_DEFAULT in production code, we don't want the host name checks since these will change from machine to machine */ SOAP_SSL_DEFAULT | SOAP_SSL_SKIP_HOST_CHECK, /* use SOAP_SSL_DEFAULT in production code, we don't want the host name checks since these will change from machine to machine */ NULL, /* keyfile: required only when client must authenticate to server (see SSL docs on how to obtain this file) */ NULL, /* password to read the keyfile */ "cacert.pem", /* optional cacert file to store trusted certificates, use cacerts.pem for all public certificates issued by common CAs */ NULL, /* optional capath to directory with trusted certificates */ NULL /* if randfile!=NULL: use a file with random data to seed randomness */ )) { soap_print_fault(&calc, stderr); exit(1); } calc.connect_timeout = 60; /* try to connect for 1 minute */ calc.send_timeout = calc.recv_timeout = 30; /* if I/O stalls, then timeout after 30 seconds */ #endif switch (*argv[1]) { case 'a': printf("start add \n"); calc.add(a, b, &result); printf("stop add \n"); break; case 's': calc.sub(a, b, &result); break; case 'm': calc.mul(a, b, &result); break; case 'd': calc.div(a, b, &result); break; case 'p': calc.pow(a, b, &result); break; default: fprintf(stderr, "Unknown command\n"); exit(0); } if (calc.error){ printf("soap_stream_fault \n", result); calc.soap_stream_fault(std::cerr); } else{ printf("result = %g\n", result); } return 0; }
int main(int argc, char **argv) { FILE *fd; BIGNUM *bn = BN_new(); /* init OpenSSL before any OpenSSL and crypto operations */ soap_ssl_init(); /* server's RSA private key for signing */ if ((fd = fopen("serverWCF.pem", "r"))) { srv_privk = PEM_read_PrivateKey(fd, NULL, NULL, (void*)"password"); fclose(fd); if (!srv_privk) { fprintf(stderr, "Could not read private RSA key from server.pem\n"); exit(1); } } else fprintf(stderr, "Could not read server.pem\n"); /* server's certificate with public key for encryption and signature verification */ if ((fd = fopen("servercertWCF.pem", "r"))) { srv_cert = PEM_read_X509(fd, NULL, NULL, NULL); fclose(fd); if (!srv_cert) { fprintf(stderr, "Could not read certificate from clientcert.pem\n"); exit(1); } } else fprintf(stderr, "Could not read server.pem\n"); /* server's RSA public key from the certificate */ srv_pubk = X509_get_pubkey(srv_cert); if (!srv_pubk) { fprintf(stderr, "Could not get public key from certificate\n"); exit(1); } /* server's certificate subject, issuer and serial number */ X509_NAME_oneline(X509_get_subject_name(srv_cert), srv_subject, sizeof(srv_subject)); X509_NAME_oneline(X509_get_issuer_name(srv_cert), srv_issuer, sizeof(srv_issuer)); ASN1_INTEGER_to_BN(X509_get_serialNumber(srv_cert), bn); srv_serial = BN_bn2dec(bn); fprintf(stderr, "Server certificate issuer = \"%s\"\n", srv_issuer); fprintf(stderr, "Server certificate serial = %s (%s)\n", BN_bn2hex(bn), srv_serial); /* client's RSA private key for signing */ if ((fd = fopen("clientWCF.pem", "r"))) { clt_privk = PEM_read_PrivateKey(fd, NULL, NULL, (void*)"password"); fclose(fd); if (!clt_privk) { fprintf(stderr, "Could not read private RSA key from server.pem\n"); exit(1); } } else fprintf(stderr, "Could not read server.pem\n"); /* client's certificate with public key for encryption and signature verification */ if ((fd = fopen("clientcertWCF.pem", "r"))) { clt_cert = PEM_read_X509(fd, NULL, NULL, NULL); fclose(fd); if (!clt_cert) { fprintf(stderr, "Could not read certificate from clientcert.pem\n"); exit(1); } } else fprintf(stderr, "Could not read server.pem\n"); /* client's RSA public key from the certificate */ clt_pubk = X509_get_pubkey(clt_cert); if (!clt_pubk) { fprintf(stderr, "Could not get public key from certificate\n"); exit(1); } /* client's certificate subject, issuer and serial number */ X509_NAME_oneline(X509_get_subject_name(clt_cert), clt_subject, sizeof(clt_subject)); X509_NAME_oneline(X509_get_issuer_name(clt_cert), clt_issuer, sizeof(clt_issuer)); ASN1_INTEGER_to_BN(X509_get_serialNumber(clt_cert), bn); clt_serial = BN_bn2dec(bn); fprintf(stderr, "Client certificate issuer = \"%s\"\n", clt_issuer); fprintf(stderr, "Client certificate serial = %s (%s)\n", BN_bn2hex(bn), clt_serial); OPENSSL_free(bn); if (argc >= 2) { // Service sample application int port = atoi(argv[1]); BasicHttpBinding_USCOREICalculatorService service(SOAP_XML_INDENT | SOAP_XML_CANONICAL); soap_register_plugin_arg(service.soap, soap_wsse, (void*)token_handler); service.soap->send_timeout = service.soap->recv_timeout = 10; // 10 sec /* need cacert to verify certificates */ service.soap->cafile = "clientcertWCF.pem"; service.soap->fsslverify = ssl_verify; if (!soap_valid_socket(service.bind(NULL, port, 100))) { service.soap_stream_fault(std::cerr); exit(1); } std::cerr << "Server running" << std::endl; for (;;) { soap_wsse_verify_auto(service.soap, SOAP_WSSE_IGNORE_EXTRA_REFS, NULL, 0); soap_wsse_decrypt_auto(service.soap, SOAP_MEC_ENV_DEC_AES256_CBC, srv_privk, 0); if (!soap_valid_socket(service.accept()) || service.serve()) service.soap_stream_fault(std::cerr); service.destroy(); } } else { // Client sample application BasicHttpBinding_USCOREICalculatorProxy proxy(endpoint, SOAP_XML_INDENT | SOAP_XML_CANONICAL); soap_register_plugin_arg(proxy.soap, soap_wsse, (void*)token_handler); proxy.soap->send_timeout = proxy.soap->recv_timeout = 10; // 10 sec /* need cacert to verify certificates */ proxy.soap->cafile = "servercertWCF.pem"; proxy.soap->fsslverify = ssl_verify; double n1 = 3.14, n2 = 1.41; if (set_clt_security(proxy.soap)) proxy.soap_stream_fault(std::cerr); else { _mssamm__Add areq; _mssamm__AddResponse ares; areq.n1 = &n1; areq.n2 = &n2; if (proxy.Add(&areq, &ares) == SOAP_OK && ares.AddResult && chk_security(proxy.soap) == SOAP_OK) printf("Add(%g, %g) = %g\n", *areq.n1, *areq.n2, *ares.AddResult); else proxy.soap_stream_fault(std::cerr); proxy.destroy(); } if (set_clt_security(proxy.soap)) proxy.soap_stream_fault(std::cerr); else { _mssamm__Subtract sreq; _mssamm__SubtractResponse sres; sreq.n1 = &n1; sreq.n2 = &n2; if (proxy.Subtract(&sreq, &sres) == SOAP_OK && sres.SubtractResult && chk_security(proxy.soap) == SOAP_OK) printf("Subtract(%g, %g) = %g\n", *sreq.n1, *sreq.n2, *sres.SubtractResult); else proxy.soap_stream_fault(std::cerr); proxy.destroy(); } if (set_clt_security(proxy.soap)) proxy.soap_stream_fault(std::cerr); else { _mssamm__Multiply mreq; _mssamm__MultiplyResponse mres; mreq.n1 = &n1; mreq.n2 = &n2; if (proxy.Multiply(&mreq, &mres) == SOAP_OK && mres.MultiplyResult && chk_security(proxy.soap) == SOAP_OK) printf("Multiply(%g, %g) = %g\n", *mreq.n1, *mreq.n2, *mres.MultiplyResult); else proxy.soap_stream_fault(std::cerr); proxy.destroy(); } if (set_clt_security(proxy.soap)) proxy.soap_stream_fault(std::cerr); else { _mssamm__Divide dreq; _mssamm__DivideResponse dres; dreq.n1 = &n1; dreq.n2 = &n2; if (proxy.Divide(&dreq, &dres) == SOAP_OK && dres.DivideResult && chk_security(proxy.soap) == SOAP_OK) printf("Divide(%g, %g) = %g\n", *dreq.n1, *dreq.n2, *dres.DivideResult); else proxy.soap_stream_fault(std::cerr); proxy.destroy(); } } OPENSSL_free(clt_serial); OPENSSL_free(srv_serial); return 0; }