void *getNativeWindowHandle(PluginInstance *obj) {
	void *nativeWindowHandle = obj->nativeWindowHandle;
#ifdef _WIN32
	EstEID_log("_WIN32 detected, forcing nativeWindowHandle query from browser");
	nativeWindowHandle = 0;
#endif
	if (!nativeWindowHandle) {
		browserFunctions->getvalue(obj->npp, NPNVnetscapeWindow, &nativeWindowHandle);
		EstEID_log("reading nativeWindowHandle=%p from browserFunctions", nativeWindowHandle);
	}
	else {
		EstEID_log("reading nativeWindowHandle=%p from PluginInstance", nativeWindowHandle);
	}
	return nativeWindowHandle;
}
예제 #2
0
int EstEID_getSlotId(char* certId, CK_SLOT_ID* slotId) {
	int certIndex;
	EstEID_Certs *certs = EstEID_loadCerts();
	EstEID_log("certs loaded");
	if (!certs) {
		EstEID_log("%s", EstEID_error);
		return FALSE;
	}
	else if ((certIndex = EstEID_findNonRepuditionCert(certs, certId)) == NOT_FOUND) {
		EstEID_log("card is changed");
		return FALSE;
	}
	*slotId = certs->slotIDs[certIndex];
	return TRUE;
}
void CEstEIDCertificate::readFromCertContext() {
	LOG_LOCATION;
	PCCERT_CONTEXT pCertContext = NULL;
	HCERTSTORE hCertStore = NULL;
	CRYPTUI_SELECTCERTIFICATE_STRUCT sel = {sizeof(sel)};
	int counter = 0;

	hCertStore = CertOpenStore(CERT_STORE_PROV_SYSTEM, 0, NULL, CERT_SYSTEM_STORE_CURRENT_USER | CERT_STORE_READONLY_FLAG, L"MY");
	if(!hCertStore){
		throw CryptoException();
	}
	sel.pvCallbackData = &counter;
	sel.pFilterCallback = filter_proc;
	sel.rghDisplayStores = &hCertStore;
	sel.cDisplayStores = 1;
	
#ifdef _SEB_BUILD	
	EstEID_log("SEB build");
	PCCERT_CONTEXT pCertContextForEnumeration = NULL;
	int certificatesCount = 0;
	while(pCertContextForEnumeration = CertEnumCertificatesInStore(hCertStore, pCertContextForEnumeration)) {
		if(isValidForSigning(pCertContextForEnumeration)) {
			certificatesCount++;	
			pCertContext = pCertContextForEnumeration;
		}
	}

	EstEID_log("Certificates count %i", certificatesCount);

	if(certificatesCount != 1) {
		pCertContext = CryptUIDlgSelectCertificate(&sel);
	}
#else
	pCertContext = CryptUIDlgSelectCertificate(&sel);
#endif
	if(!pCertContext) {
		EstEID_log("User didn't select sertificate");
		throw CryptoException(ESTEID_USER_CANCEL);
	}

	loadCertContexts(pCertContext);
	if(pCertContext){
		CertFreeCertificateContext(pCertContext);
	}
	if(hCertStore) {
		CertCloseStore(hCertStore, CERT_CLOSE_STORE_FORCE_FLAG);
	}
}
예제 #4
0
void EstEID_logInitInfo(CK_INFO info) {
	char *libraryDescription = EstEID_createString(info.libraryDescription, 32);
	char *manufacturerID = EstEID_createString(info.manufacturerID, 32);
	EstEID_log("cryptoki %i.%i, library %i.%i %s, %s", info.cryptokiVersion.major, info.cryptokiVersion.minor, info.libraryVersion.major, info.libraryVersion.minor, libraryDescription, manufacturerID);
	free(libraryDescription);
	free(manufacturerID);
}
예제 #5
0
int EstEID_isPinPad(CK_SLOT_ID slotID) {
	CK_TOKEN_INFO tokenInfo;
	if (EstEID_CK_failure("C_GetTokenInfo", fl->C_GetTokenInfo(slotID, &tokenInfo))) return 0;
	EstEID_log("flags: %li (%lx)", tokenInfo.flags, tokenInfo.flags);
	if (tokenInfo.flags & CKF_PROTECTED_AUTHENTICATION_PATH) return 1;
	else return 0;
}
예제 #6
0
THREAD_RETURN_TYPE EstEID_pinPadLogin(void* threadData) {
#ifndef _WIN32
	LOG_LOCATION;
	pthread_mutex_lock(&pinpad_thread_mutex);
	CK_SESSION_HANDLE session = ((EstEID_PINPadThreadData*)threadData)->session;
	CK_RV loginResult = fl->C_Login(session, CKU_USER, NULL, 0);		
	((EstEID_PINPadThreadData*)threadData)->result = loginResult;

	closePinPadModalSheet();
	EstEID_log("modal sheet/dialog destroyed");

	pinpad_thread_completed = TRUE;
	pthread_cond_broadcast(&pinpad_thread_condition);

	pthread_mutex_unlock(&pinpad_thread_mutex);
	pthread_exit(NULL);
#else
	EstEID_PINPromptDataEx* pinPromptDataEx;
	LOG_LOCATION;
	WaitForSingleObject(pinpad_thread_mutex, INFINITE);
	pinPromptDataEx = (EstEID_PINPromptDataEx*)threadData;
	pinPromptDataEx->pinPromptData.promptFunction(NULL, pinPromptDataEx->name, pinPromptDataEx->message, 0, TRUE);	
	ReleaseMutex(pinpad_thread_mutex);
	return TRUE;
#endif
}
예제 #7
0
void EstEID_logBase64(char *message, char* data, int dataLength) {
	char *base64;
	LOG_LOCATION;
	base64 = EstEID_base64Encode(data, dataLength);
	EstEID_log(message, base64);
	free(base64);
}
예제 #8
0
INT_PTR CALLBACK PinPadDialogProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) {		
	switch(message) {
		case WM_INITDIALOG:
			dialogWindowHandle = hwnd;			

			SetPinDialogLabels(dialogWindowHandle, lParam);
			SetDialogItemText(hwnd, IDC_PINPAD_PIN2_LABEL, l10n("For signing enter PIN2 from PIN pad"));

			countdownValue = 30; // in seconds
			EstEID_log("initializing pinpad countdown timer with value %i", countdownValue);
			SendMessage(GetDlgItem(dialogWindowHandle, IDC_PROGRESSBAR), PBM_SETSTATE, (WPARAM)PBST_PAUSED, 0L);
			SendMessage(GetDlgItem(dialogWindowHandle, IDC_PROGRESSBAR), PBM_SETRANGE, 0, MAKELPARAM(0, countdownValue));
			UpdateProgerssBar(dialogWindowHandle, countdownValue);
			SendMessage(GetDlgItem(dialogWindowHandle, IDC_PROGRESSBAR), PBM_SETSTATE, (WPARAM)PBST_NORMAL, 0L);
			SetTimer(dialogWindowHandle, 1, 1000, NULL);
			break;
		case WM_DESTROY:
			KillCountdownTimer();
			break;
		case WM_TIMER:
			CountdownTimerProc();
			break;
		case WM_CTLCOLORSTATIC:
			if(GetDlgItem(hwnd, IDC_ERROR) == ((HWND)lParam)){
				return SetMessageLabelColorToRed(wParam);
			}
		default:			
			return false;
	}
	return DefWindowProc(hwnd, message, wParam, lParam);	
}
예제 #9
0
static GtkTreeModel* createAndFillModel() {
	GtkListStore *certificatesList = gtk_list_store_new (4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
	GtkTreeIter iterator;
	char *validTo = NULL;	

	EstEID_Certs *certs = EstEID_loadCerts();
	EstEID_log("%i certificates found", certs->count);
	for(int i = 0; i < certs->count; i++) {
		EstEID_Map cert = certs->certs[i];
		if (!EstEID_mapGet(cert, "usageNonRepudiation")) continue;

		validTo = getDateFromDateTime(EstEID_mapGet(cert, "validTo"));

		gtk_list_store_append(certificatesList, &iterator);
		gtk_list_store_set(certificatesList, &iterator,
			0, EstEID_mapGet(cert, "commonName"),
			1, EstEID_mapGet(cert, "organizationName"),
			2, validTo,
			3, EstEID_mapGet(cert, "certHash"),
			-1);
		if(validTo) {			
			free(validTo);
			validTo = NULL;
		}
	}
	return GTK_TREE_MODEL(certificatesList);
}
예제 #10
0
int promptForCertificate(void *nativeWindowHandle, char* certId) {
	certId[0] = '\0';

	GtkWidget *window = getGtkWindow(nativeWindowHandle);
	GtkWidget *dialog = gtk_dialog_new_with_buttons("Select certificate", GTK_WINDOW(window), // ToDo l10n
		GTK_DIALOG_DESTROY_WITH_PARENT,
		GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
		GTK_STOCK_OK, GTK_RESPONSE_OK,
		NULL);
	GtkWidget* certificatesView = createCertificateSelectionView(dialog);

	gtk_dialog_set_response_sensitive(GTK_DIALOG(dialog), GTK_RESPONSE_OK, FALSE);
	
	gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), certificatesView);

	setDialogProperties(dialog, window);
	gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE);
	gtk_widget_show_all(dialog);

	gint result = gtk_dialog_run(GTK_DIALOG(dialog));

	gtk_widget_hide(dialog);

	int returnValue = IDCANCEL;
	if (result == GTK_RESPONSE_OK) {
		GtkTreeSelection* selectedRow = gtk_tree_view_get_selection(GTK_TREE_VIEW(certificatesView));
		GtkTreeModel* model = NULL;
		GtkTreeIter iter;
		if(gtk_tree_selection_get_selected(selectedRow, &model, &iter)){
			gchar* id;
			gtk_tree_model_get(model, &iter, 3, &id, -1);
			strcpy(certId, id);
			g_free(id);
			returnValue = IDOK;
			EstEID_log("promptForCertificate dialog returned cert ID %s", certId);
		}
		else {
			EstEID_log("promptForCertificate dialog returned without cert selection");
		}
	}
	else {		
		EstEID_log("promptForCertificate dialog canceled by user");
	}
	gtk_widget_destroy(dialog);
	return returnValue;
}
bool certGetProperty(CertInstance *obj, NPIdentifier name, NPVariant *variant) {
	NPUTF8* nameString = browserFunctions->utf8fromidentifier(name);
	EstEID_log("name=%s", (char *)nameString);
	const char *result = EstEID_mapGet(obj->certInfo, EstEID_getCertPropertyName(nameString));
	browserFunctions->memfree(nameString);
	if (result) return copyStringToNPVariant(result, variant);
	return false;
}
예제 #12
0
int EstEID_tokensChanged() {
  LOG_LOCATION;
	CK_SLOT_ID slotID;
	int changed = FALSE;
	while (fl->C_WaitForSlotEvent(CKF_DONT_BLOCK, &slotID, NULL_PTR) == CKR_OK) {
    EstEID_log("C_WaitForSlotEvent() pass cycle 1");
		changed = TRUE;
	}
	if (!changed) {
		while (fl->C_WaitForSlotEvent(CKF_DONT_BLOCK, &slotID, NULL_PTR) == CKR_OK) {
      EstEID_log("C_WaitForSlotEvent() pass cycle 2");
			changed = TRUE;
		}
	}  
  EstEID_log("tokens change %sdetected", changed ? "" : "not ");
	return changed;
}
예제 #13
0
int EstEID_CK_failure(const char *name, CK_RV result) {
	EstEID_clear_error();
	if (result == CKR_OK || result == CKR_CRYPTOKI_ALREADY_INITIALIZED) return FAILURE;
	sprintf(EstEID_error, "%s error: %s (%li)", name, pkcs11_error_message(result), result);
	EstEID_errorCode = ESTEID_PKCS11_ERROR;
	EstEID_log("cryptoki error: %s", EstEID_error);
	return SUCCESS;
}
예제 #14
0
char *EstEID_sign(char *certId, char *hash, EstEID_PINPromptData pinPromptData) {	
	EstEID_log("called, hash=%s", hash);
	char *signature = NULL;

	int i;
	EstEID_log("calling EstEID_loadCerts()");
	EstEID_Certs *certs = EstEID_loadCerts();
	EstEID_log("certs loaded");
	if (!certs) {
		EstEID_log("%s", EstEID_error);
	}
	else if ((i = EstEID_findNonRepuditionCert(certs, certId)) == NOT_FOUND) {
		snprintf(EstEID_error, sizeof(EstEID_error) - 1, "no cert has ID: %s", certId);
		EstEID_errorCode = ESTEID_CERT_NOT_FOUND_ERROR;
		EstEID_error[sizeof(EstEID_error) - 1] = 0;
		EstEID_log("%s", EstEID_error);
	}
	else if (EstEID_signHashHex(&signature, certs->slotIDs[i], certs->certs[i], hash, pinPromptData)) {
		EstEID_log("signature=%s", signature);
	}
	else {
		EstEID_log("%s", EstEID_error);
	}
	free(certId);
	free(hash);
	return signature;
}
예제 #15
0
int EstEID_md5_failure(void *ptr) {
	EstEID_clear_error();
	if (ptr) return FALSE;
	snprintf(EstEID_error, sizeof(EstEID_error) - 1, "Cert id creation failed");
	EstEID_errorCode = ESTEID_MD5_ERROR;
	EstEID_error[sizeof(EstEID_error) - 1] = 0;
	EstEID_log("%s", EstEID_error);
	return TRUE;
}
bool isAllowedSite() {
	if(!allowedSite) {
		sprintf(EstEID_error, "Site is not allowed");
		EstEID_errorCode = ESTEID_SITE_NOT_ALLOWED;
		EstEID_log("called from forbidden site");
		return false;
	}
	return true;
}
예제 #17
0
int EstEID_dl_failure(const char *name, void *ptr) {
	EstEID_clear_error();
	if (ptr) return FALSE;
	snprintf(EstEID_error, sizeof(EstEID_error) - 1, "%s failed: %s", name, library_error());
	EstEID_errorCode = ESTEID_LIBRARY_LOAD_ERROR;
	EstEID_error[sizeof(EstEID_error) - 1] = 0;
	EstEID_log("dl error: %s", EstEID_error);
	return TRUE;
}
std::string CEstEIDCertificate::dateToString(FILETIME *filetime) {
	EstEID_log("");
	SYSTEMTIME systemtime;
	FileTimeToSystemTime(filetime, &systemtime);
	char buf[40] = {0};
	sprintf_s(buf, "%02d.%02d.%04d %02d:%02d:%02d", systemtime.wDay, systemtime.wMonth, systemtime.wYear, systemtime.wHour, systemtime.wMinute, systemtime.wSecond);
	std::string result = buf;
	return result;
}
예제 #19
0
int EstEID_getRemainingTries(CK_SLOT_ID slotID) {
	CK_TOKEN_INFO tokenInfo;
	if (EstEID_CK_failure("C_GetTokenInfo", fl->C_GetTokenInfo(slotID, &tokenInfo))) return -1;
	EstEID_log("flags: %li (%lx)", tokenInfo.flags, tokenInfo.flags);
	if (tokenInfo.flags & CKF_USER_PIN_LOCKED) return 0;
	else if (tokenInfo.flags & CKF_USER_PIN_FINAL_TRY) return 1;
	else if (tokenInfo.flags & CKF_USER_PIN_COUNT_LOW) return 2;
	else return 3;
}
예제 #20
0
int EstEID_startInitializeCryptokiThread() {
	LOG_LOCATION;
	initialization_result = -1;
	FAIL_IF_THREAD_ERROR("CreateMutex", (initialization_mutex = CreateMutex(NULL, FALSE, NULL)));
	EstEID_log("initialization_mutex = %p", initialization_mutex);
	DWORD threadId;
	FAIL_IF_THREAD_ERROR("CreateThread", CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)&EstEID_initializeCryptokiThread, NULL, 0, &threadId));
	
	return SUCCESS;
}
예제 #21
0
INT_PTR CALLBACK CertSelectionDialogProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) {	
	static char* selectedCertID;
	switch(message) {
		case WM_INITDIALOG:
			buildCertificatesList(hwnd);
			selectedCertID = (char*)lParam;
			selectedCertID[0] = '\0';
			break;
		case WM_COMMAND:
			switch(LOWORD(wParam)) {
				case IDOK: {
					int index = ListView_GetNextItem(GetDlgItem(hwnd, IDC_CERTIFICATESLIST), -1, LVNI_SELECTED);
					TCHAR unicodeSelectedCertID[256];
					ListView_GetItemText(GetDlgItem(hwnd, IDC_CERTIFICATESLIST), index, 3, (LPTSTR)unicodeSelectedCertID, 33);
					strcpy(selectedCertID, CW2A(unicodeSelectedCertID));
					EstEID_log("selected certificate id in dialog proc: %s", selectedCertID);
				}
				default:
					EndDialog(hwnd, LOWORD(wParam));
			}	
			break;
		case WM_NOTIFY:			
			if(wParam == IDC_CERTIFICATESLIST) {
				switch(((LPNMHDR)lParam)->code) {
					case LVN_ITEMCHANGED:
					case NM_CLICK:
						Button_Enable(GetDlgItem(hwnd, IDOK), ((LPNMITEMACTIVATE)lParam)->iItem != -1);
						break;
					case LVN_ITEMACTIVATE: {
						int selectedCertIndex = ((LPNMITEMACTIVATE)lParam)->iItem;
						TCHAR unicodeSelectedCertID[256];
						ListView_GetItemText(GetDlgItem(hwnd, IDC_CERTIFICATESLIST), selectedCertIndex, 3, (LPTSTR)unicodeSelectedCertID, 33);
						strcpy(selectedCertID, CW2A(unicodeSelectedCertID));
						EstEID_log("dblcklicked certificate id in dialog proc: %s", selectedCertID);
						EndDialog(hwnd, LOWORD(wParam));
					}
				}
			}			
		default:
			return false;
	}
	return DefWindowProc(hwnd, message, wParam, lParam);	
}
예제 #22
0
char *promptForPIN(void *nativeWindowHandle, const char *name, const char *message) {
	GtkWidget *window = getGtkWindow(nativeWindowHandle);
	GtkWidget *entry = gtk_entry_new();
	GtkWidget *dialog = createDialog(window, entry, name, message);

	gint result = gtk_dialog_run(GTK_DIALOG(dialog));
	gtk_widget_hide(dialog);

	char *pin;
	if (result == GTK_RESPONSE_OK) {
		pin = strdup(gtk_entry_get_text(GTK_ENTRY(entry)));
		EstEID_log("promptForPIN\t got pin");
	}
	else {
		pin = strdup("");
		EstEID_log("promptForPIN\t user canceled");
	}
	gtk_widget_destroy(dialog);
	return pin;
}
예제 #23
0
void CEstEIDIEPluginBHO::mapInternalErrorCodes(unsigned int code) {
	EstEID_log("Mapping error code %Xh:", code, code);

	if(code == ESTEID_USER_CANCEL || code == 0x3E5 || code == 0xB7 || code == 0x05DE || code == SCARD_W_CANCELLED_BY_USER){ // 0x03E5 for ???; 0x05DE for SL base package; SCARD_W_CANCELLED_BY_USER (0x8010006E) for SK base package
		EstEID_log("    mapped to ESTEID_USER_CANCEL (%Xh)", ESTEID_USER_CANCEL);
		setError(ESTEID_USER_CANCEL);
	}
	else if(code == 0x80092004){		
		EstEID_log("    mapped to ESTEID_CERT_NOT_FOUND_ERROR (%Xh)", ESTEID_CERT_NOT_FOUND_ERROR);
		setError(ESTEID_CERT_NOT_FOUND_ERROR);
	}
	else if(code > 0x80000000) {		
		EstEID_log("    mapped to ESTEID_CRYPTO_API_ERROR (%Xh)", ESTEID_CRYPTO_API_ERROR);
		setError(ESTEID_CRYPTO_API_ERROR);
	}
	else {
		EstEID_log("    mapped to ESTEID_UNKNOWN_ERROR (%Xh)", ESTEID_UNKNOWN_ERROR);
		setError(ESTEID_UNKNOWN_ERROR);
	}
}
예제 #24
0
파일: l10n.c 프로젝트: Krabi/idkaart_public
char *EstEID_getLocaleFromEnvironment() {
	char *result = NULL;
	char *lang = getenv("LANG");
	if (lang && strlen(lang) >= 2) {
		result = (char *)malloc(3);
		strncpy(result, lang, 2);
		result[2] = 0;
		EstEID_log("locale from getenv('LANG'): %s => %s", lang, result);
	}
	return result;
}
예제 #25
0
char *promptForPIN(void *nativeWindowHandle, const char *name, const char *message) {
	char *pin2;
	DialogData dialogData;

	dialogData.pin2[0] = '\0';
	dialogData.name = name;
	dialogData.message = message;

	INT_PTR result = DialogBoxParamW(pluginInstance, MAKEINTRESOURCEW(IDD_PIN_DIALOG), (HWND)nativeWindowHandle, Pin2DialogProc, (LPARAM)&dialogData);
	if (result == IDOK) {		
		pin2 = strdup(dialogData.pin2);
		memset(dialogData.pin2, '\0', PIN2_MAX_LEN + 2);
		EstEID_log("promptForPIN\t got pin");
	}
	else {
		pin2 = strdup("");
		EstEID_log("promptForPIN\t user canceled");
	}
	
	return pin2;
}
예제 #26
0
bool doGetCertificate(PluginInstance *obj, NPVariant *result) {
	LOG_LOCATION;
	FAIL_IF_NOT_ALLOWED_SITE;
	char selectedCertID[33];
	int dlg_result = 0;
	
#ifdef _WIN32
	HWND ownerWindowHandle = (HWND)getNativeWindowHandle(obj);
	EstEID_log("owner window handle passed to DialogBoxParam() = %08X", ownerWindowHandle);
	dlg_result = (int)DialogBoxParam(pluginInstance, MAKEINTRESOURCE(IDD_CERTIFICATESELECTIONDLG), ownerWindowHandle, CertSelectionDialogProc, (LPARAM)selectedCertID);
#else
	dlg_result = promptForCertificate(getNativeWindowHandle(obj), selectedCertID);
#endif
	EstEID_log("Certificate selection dialog result = %i", dlg_result);
	EstEID_log("Selected certificate ID = %s", selectedCertID);

	if(dlg_result == IDCANCEL) {
		sprintf(EstEID_error, "User canceled");
		EstEID_errorCode = ESTEID_USER_CANCEL;
		EstEID_log("EstEID_error = %s", EstEID_error);
		browserFunctions->setexception(&obj->header, EstEID_error);	
		return false;
	}
	
	CertInstance *certInstance = (CertInstance *)browserFunctions->createobject(obj->npp, certClass());
	certInstance->npp = obj->npp;
	certInstance->certInfo = EstEID_mapClone(EstEID_getNonRepudiationCertById(selectedCertID));
//	certInstance->certInfo = EstEID_mapClone(EstEID_getNonRepudiationCert());

	EstEID_log("certObject=%p", certInstance);
	OBJECT_TO_NPVARIANT((NPObject *)certInstance, *result);
	EstEID_log("result=%p", result);	
	return true;
}
bool doSign(PluginInstance *obj, NPVariant *args, unsigned argCount, NPVariant *result) {
	EstEID_log("obj=%p, name=sign argCount=%u", obj, argCount);

	FAIL_IF_NOT_ALLOWED_SITE;

	if (argCount < 2) {
		browserFunctions->setexception(&obj->header, "Missing arguments");
		return false;
	}
	
	if(argCount > 2 && NPVARIANT_IS_OBJECT(args[2])){
		strncpy(pluginLanguage, getLanguageFromOptions(obj, args[2]), 2);
	}
	EstEID_setLocale(pluginLanguage);

	if(argCount > 3 && NPVARIANT_IS_OBJECT(args[3])){
		strcpy(promptMessage, createStringFromNPVariant(args[3]));
	}

	void* wnd = getNativeWindowHandle(obj);

	EstEID_PINPromptData pinPromptData = {promptForPIN, showAlert, wnd, promptMessage, NULL};
	NPUTF8* certId = createStringFromNPVariant(&args[0]);
	NPUTF8* hash = createStringFromNPVariant(&args[1]);
	char *signature = NULL;

	signature = EstEID_sign(certId, hash, pinPromptData);

	LOG_LOCATION
	if (signature) {
		copyStringToNPVariant(signature, result);
		free(signature);
		return true;
	}
	else {
		EstEID_log("EstEID_error=%s", EstEID_error);
		browserFunctions->setexception(&obj->header, EstEID_error);
		return false;
	}
}
예제 #28
0
STDMETHODIMP CEstEIDIEPluginBHO::SetSite(IUnknown* pUnkSite) {
	EstEID_log("");
	IObjectWithSiteImpl<CEstEIDIEPluginBHO>::SetSite(pUnkSite);

	CComPtr<IServiceProvider> pSP;
	HRESULT hr = GetSite(IID_IServiceProvider, reinterpret_cast<LPVOID *>(&pSP));
	if(S_OK != hr) {
		return hr;
	}
	hr = pSP->QueryService(IID_IWebBrowserApp, IID_IWebBrowser2, reinterpret_cast<LPVOID *>(&webBrowser));

	return S_OK;
}
bool pluginGetProperty(PluginInstance *obj, NPIdentifier name, NPVariant *variant) {
	LOG_LOCATION;
	if (isSameIdentifier(name, "version"))
		return copyStringToNPVariant(ESTEID_PLUGIN_VERSION, variant);
	else if (isSameIdentifier(name, "errorMessage")){
		EstEID_log("Reading error message: %s", EstEID_error);
		return copyStringToNPVariant(EstEID_error, variant);
	}
	else if (isSameIdentifier(name, "errorCode")) {
		INT32_TO_NPVARIANT(EstEID_errorCode, *variant);
		EstEID_log("returning errorCode=%i", EstEID_errorCode);
		return true;
	}
	else if (isSameIdentifier(name, "authCert") || isSameIdentifier(name, "signCert")){
		return doGetCertificate(obj, variant);
	}
	else if (isSameIdentifier(name, "pluginLanguage")){
		return copyStringToNPVariant(pluginLanguage, variant);
	}
	EstEID_log("returning false");
	return false;
}
예제 #30
0
BOOL CEstEidPin2Dlg::OnInitDialog() {
	LOG_LOCATION;
	CDialog::OnInitDialog();
	WCHAR label[512];

	int certIndex;
	EstEID_Certs *certs = EstEID_loadCerts();
	if (!certs) {
		EstEID_log("no certs found");
	}
	else if ((certIndex = EstEID_findNonRepuditionCert(certs, ATL::CW2A(this->certId))) == NOT_FOUND) {
		EstEID_log("card is changed");
	}
	EstEID_Map cert = certs->certs[certIndex];

	char* name = EstEID_getFullNameWithPersonalCode(cert);
	MultiByteToWideChar(CP_UTF8, 0, name, -1, label, sizeof(label) / sizeof(WCHAR));

	this->SetWindowText(label);

	SetDlgItemText(IDC_NAME, label);

	this->pin2MinLen = (unsigned)atoi(EstEID_mapGet(cert, "minPinLen"));

	free(name);

	MultiByteToWideChar(CP_UTF8, 0, l10n("For signing enter PIN2:"), -1, label, sizeof(label) / sizeof(WCHAR));
	SetDlgItemText(IDC_PIN2_LABEL, label);

	MultiByteToWideChar(CP_UTF8, 0, l10n("Sign"), -1, label, sizeof(label) / sizeof(WCHAR));
	SetDlgItemText(IDOK, label);

	MultiByteToWideChar(CP_UTF8, 0, l10n("Cancel"), -1, label, sizeof(label) / sizeof(WCHAR));
	SetDlgItemText(IDCANCEL, label);
	SetDlgItemText(IDC_ERROR, L"");

	EndDialogIfPIN2Blocked(SetUpPin2Dialog());
	return TRUE;
}