Add encrypt string

deps/wrapper/include/wrapper/pki/cipher.h

@@ -54,8 +54,8 @@ class Cipher{
 	/*Symetric or assymetric(default)*/
 	void setCryptoMethod(CryptoMethod::Crypto_Method method);
 
-	void encrypt(Handle<Bio> inSource, Handle<Bio> outEnc, DataFormat::DATA_FORMAT format);
-	void decrypt(Handle<Bio> inEnc, Handle<Bio> outDec, DataFormat::DATA_FORMAT format);
+	Handle<Bio> encrypt(Handle<Bio> inSource, Handle<Bio> outEnc, DataFormat::DATA_FORMAT format);
+	Handle<Bio> decrypt(Handle<Bio> inEnc, Handle<Bio> outDec, DataFormat::DATA_FORMAT format);
 
 public:
 	Handle<std::string> getAlgorithm();

deps/wrapper/include/wrapper/utils/csp.h

@@ -23,6 +23,8 @@ class Csp {
 	bool checkCPCSPLicense();
 	Handle<std::string> getCPCSPLicense();
 
+	Handle<std::string> getCPCSPVersion();
+
 	std::vector<ProviderProps> enumProviders();
 	std::vector<Handle<std::string>> enumContainers(int provType, Handle<std::string> provName);
 	Handle<Certificate> getCertifiacteFromContainer(Handle<std::string> contName, int provType, Handle<std::string> provName);

deps/wrapper/src/pki/cipher.cpp

@@ -87,9 +87,9 @@ void Cipher::setRecipientCert(Handle<Certificate> cert){
 	}
 }
 
-void Cipher::encrypt(Handle<Bio> inSource, Handle<Bio> outEnc, DataFormat::DATA_FORMAT format){
+Handle<Bio> Cipher::encrypt(Handle<Bio> inSource, Handle<Bio> outEnc, DataFormat::DATA_FORMAT format){
 	LOGGER_FN();
-
+	
 	try{
 		X509 *firstRecipientCertificate = NULL;
 		EVP_PKEY *pkey = NULL;
@@ -101,7 +101,7 @@ void Cipher::encrypt(Handle<Bio> inSource, Handle<Bio> outEnc, DataFormat::DATA_
 		case CryptoMethod::SYMMETRIC:
 			/*Check pass*/
 			if (hpass == NULL){
-
+		
 				/*Check key*/
 				if (hkey == NULL){
 					THROW_EXCEPTION(0, Cipher, NULL, "key  undefined");
@@ -120,16 +120,16 @@ void Cipher::encrypt(Handle<Bio> inSource, Handle<Bio> outEnc, DataFormat::DATA_
 			/*
 			* We use 'benc' how cipher BIO method.
 			* This is a filter BIO that encrypts any data written through it
-			*/
+			*/			
 			LOGGER_OPENSSL(BIO_new);
 			if ((benc = BIO_new(BIO_f_cipher())) == NULL){
 				THROW_OPENSSL_EXCEPTION(0, Cipher, NULL, "BIO_new(BIO_f_cipher())");
 			}
-
+			
 			/*Save internal BIO cipher context to 'ctx'*/
 			LOGGER_OPENSSL(BIO_get_cipher_ctx);
 			BIO_get_cipher_ctx(benc, &ctx);
-
+			
 			/*Use param '1' for encrypt*/
 			LOGGER_OPENSSL(EVP_CipherInit_ex);
 			if (!EVP_CipherInit_ex(ctx, cipher, NULL, key, iv, 1)) {
@@ -149,7 +149,7 @@ void Cipher::encrypt(Handle<Bio> inSource, Handle<Bio> outEnc, DataFormat::DATA_
 					THROW_OPENSSL_EXCEPTION(0, Cipher, NULL, "Error write bio");
 				}
 			}
-
+			
 			if (benc != NULL){
 				LOGGER_OPENSSL(BIO_push);
 				wbio = BIO_push(benc, wbio);
@@ -173,6 +173,8 @@ void Cipher::encrypt(Handle<Bio> inSource, Handle<Bio> outEnc, DataFormat::DATA_
 				THROW_EXCEPTION(0, Cipher, NULL, "bad decrypt");
 			}
 
+			return new Bio(wbio);
+
 			break;
 
 		//****************************************************************************************
@@ -241,15 +243,16 @@ void Cipher::encrypt(Handle<Bio> inSource, Handle<Bio> outEnc, DataFormat::DATA_
 		default:
 			THROW_EXCEPTION(0, Cipher, NULL, "Unknown crypto method");
 		}
+		return NULL;
+
 
-
 	}
 	catch (Handle<Exception> e){
 		THROW_EXCEPTION(0, Cipher, e, "Error encrypt");
 	}	
 }
 
-void Cipher::decrypt(Handle<Bio> inEnc, Handle<Bio> outDec, DataFormat::DATA_FORMAT format){
+Handle<Bio> Cipher::decrypt(Handle<Bio> inEnc, Handle<Bio> outDec, DataFormat::DATA_FORMAT format){
 	LOGGER_FN();
 
 	try{
@@ -288,7 +291,7 @@ void Cipher::decrypt(Handle<Bio> inEnc, Handle<Bio> outDec, DataFormat::DATA_FOR
 				else if (memcmp(mbuf, magic, sizeof magic - 1)) {
 					THROW_EXCEPTION(0, Cipher, NULL, "bad magic number");
 				}
-
+				
 				LOGGER_OPENSSL(EVP_BytesToKey);
 				if (EVP_BytesToKey(cipher, dgst, salt, (unsigned char *)hpass, strlen(hpass), 1, key, iv) == 0){
 					THROW_OPENSSL_EXCEPTION(0, Cipher, NULL, "EVP_BytesToKey");
@@ -320,7 +323,7 @@ void Cipher::decrypt(Handle<Bio> inEnc, Handle<Bio> outDec, DataFormat::DATA_FOR
 				inl = BIO_read(rbio, (char *)buff, bsize);
 				if (inl <= 0){
 					break;
-				}
+				}				
 				LOGGER_OPENSSL(BIO_write);
 				if (BIO_write(wbio, (char *)buff, inl) != inl) {
 					THROW_EXCEPTION(0, Cipher, NULL, "Error writing output bio");
@@ -331,6 +334,7 @@ void Cipher::decrypt(Handle<Bio> inEnc, Handle<Bio> outDec, DataFormat::DATA_FOR
 			if (!BIO_flush(wbio)){
 				THROW_EXCEPTION(0, Cipher, NULL, "bad decrypt");
 			}
+			return new Bio(wbio);
 
 			break;
 
@@ -366,7 +370,7 @@ void Cipher::decrypt(Handle<Bio> inEnc, Handle<Bio> outDec, DataFormat::DATA_FOR
 			if (!CMS_decrypt_set1_pkey(cms, rkey, rcert)) {
 				THROW_OPENSSL_EXCEPTION(0, Cipher, NULL, "CMS_decrypt_set1_pkey 'Error set private key'");
 			}
-
+			
 			LOGGER_OPENSSL(CMS_decrypt);
 			if (!CMS_decrypt(cms, NULL, NULL, NULL, outDec->internal(), flags)) {
 				THROW_OPENSSL_EXCEPTION(0, Cipher, NULL, "CMS_decrypt 'Error decrypt cms'");
@@ -381,6 +385,7 @@ void Cipher::decrypt(Handle<Bio> inEnc, Handle<Bio> outDec, DataFormat::DATA_FOR
 		default:
 			THROW_EXCEPTION(0, Cipher, NULL, "Unknown crypto method");
 		}
+		return NULL;
 
 
 	}

deps/wrapper/src/utils/csp.cpp

@@ -1,6 +1,7 @@
 #include "../stdafx.h"
 
 #include "wrapper/utils/csp.h"
+#include <sstream>
 
 bool Csp::isGost2001CSPAvailable() {
 	LOGGER_FN();
@@ -236,6 +237,58 @@ Handle<std::string> Csp::getCPCSPLicense() {
 	}
 }
 
+Handle<std::string> Csp::getCPCSPVersion() {
+	LOGGER_FN();
+
+	try {
+#ifdef CSP_ENABLE
+		static HCRYPTPROV hCryptProv = 0;
+		Handle<std::string> version;
+		DWORD dwVersion[100];
+		DWORD dwDataLength = (DWORD)sizeof(dwVersion);
+
+		if (!isGost2001CSPAvailable()) {
+			THROW_EXCEPTION(0, Key, NULL, "GOST 2001 provaider not available");
+		}
+
+		if (!CryptAcquireContext(&hCryptProv, NULL,	NULL, PROV_GOST_2001_DH, CRYPT_VERIFYCONTEXT)){
+			THROW_EXCEPTION(0, Csp, NULL, "CryptAcquireContext. Error: 0x%08x", GetLastError());
+		}
+
+		if (!CryptGetProvParam(hCryptProv, PP_VERSION_EX, (BYTE*)&dwVersion, &dwDataLength, 0)){
+			THROW_EXCEPTION(0, Key, NULL, "CryptGetProvParam. Error: 0x%08x", GetLastError());
+		}
+
+		std::string str = "";
+		for (int i = 3; i >= 0; i--){
+			if (i == 1) continue;
+			std::stringstream ss;
+			ss << dwVersion[i];
+			if (i == 0)
+				str = str + ss.str();
+			else
+				str = str + ss.str() + ".";
+		}
+		version = new std::string(str);
+
+		if (hCryptProv) {
+			if (!CryptReleaseContext(hCryptProv, 0)) {
+				THROW_EXCEPTION(0, Csp, NULL, "CryptReleaseContext. Error: 0x%08x", GetLastError());
+			}
+		}
+
+		hCryptProv = 0;
+
+		return version;
+#else
+		THROW_EXCEPTION(0, Csp, NULL, "Only if defined CSP_ENABLE");
+#endif
+	}
+	catch (Handle<Exception> e){
+		THROW_EXCEPTION(0, Csp, e, "Error get cpcsp version");
+	}
+}
+
 std::vector<ProviderProps> Csp::enumProviders() {
 	LOGGER_FN();
 

index.d.ts

@@ -187,11 +187,22 @@ declare namespace native {
             save(filename: string, dataFormat: trusted.DataFormat): void;
             getEncodedHEX(): Buffer;
         }
+
+        export enum CipherContentType {
+            url,
+            buffer,
+        }
+
+        export interface ICipherContent {
+            type: CipherContentType;
+            data: string | Buffer;
+        }
+
         class Cipher {
             constructor();
             setCryptoMethod(method: trusted.CryptoMethod): void;
-            encrypt(filenameSource: string, filenameEnc: string, format: trusted.DataFormat): void;
-            decrypt(filenameEnc: string, filenameDec: string, format?: trusted.DataFormat): void;
+            encrypt(source: ICipherContent, destinationEnc: ICipherContent, format: trusted.DataFormat): string;
+            decrypt(sourceEnc: ICipherContent, destinationDec: ICipherContent, format?: trusted.DataFormat): string;
             addRecipientsCerts(certs: CertificateCollection): void;
             setPrivKey(rkey: Key): void;
             setRecipientCert(rcert: Certificate): void;
@@ -835,6 +846,8 @@ declare namespace trusted.utils {
          * @memberof Csp
          */
         static getCPCSPLicense(): string;
+
+        static getCPCSPVersion(): string;
         /**
          * Enumerate available CSP
          *

lib/native.ts

@@ -158,11 +158,21 @@ declare namespace native {
             public getEncodedHEX(): Buffer;
         }
 
+        export enum CipherContentType {
+            url,
+            buffer,
+        }
+
+        export interface ICipherContent {
+            type: CipherContentType;
+            data: string | Buffer;
+        }
+
         class Cipher {
             constructor();
             public setCryptoMethod(method: trusted.CryptoMethod): void;
-            public encrypt(filenameSource: string, filenameEnc: string, format: trusted.DataFormat): void;
-            public decrypt(filenameEnc: string, filenameDec: string, format?: trusted.DataFormat): void;
+            public encrypt(source: ICipherContent, destinationEnc: ICipherContent, format: trusted.DataFormat): string;
+            public decrypt(sourceEnc: ICipherContent, destDec: ICipherContent, format?: trusted.DataFormat): string;
             public addRecipientsCerts(certs: CertificateCollection): void;
             public setPrivKey(rkey: Key): void;
             public setRecipientCert(rcert: Certificate): void;
@@ -475,6 +485,7 @@ declare namespace native {
             public isGost2012_512CSPAvailable(): boolean;
             public checkCPCSPLicense(): boolean;
             public getCPCSPLicense(): string;
+            public getCPCSPVersion(): string;
             public enumProviders(): object[];
             public enumContainers(type?: number, provName?: string): string[];
             public getCertifiacteFromContainer(contName: string, provType: number, provName?: string): PKI.Certificate;

lib/pki/cipher.ts

@@ -2,6 +2,16 @@
 /// <reference path="../object.ts" />
 
 namespace trusted.pki {
+
+    export enum CipherContentType {
+        url,
+        buffer,
+    }
+
+    export interface ICipherContent {
+        type: CipherContentType;
+        data: string | Buffer;
+    }
     /**
      * Encrypt and decrypt operations
      *
@@ -42,8 +52,21 @@ namespace trusted.pki {
          *
          * @memberOf Cipher
          */
-        public encrypt(filenameSource: string, filenameEnc: string, format: DataFormat): void {
-            this.handle.encrypt(filenameSource, filenameEnc, format);
+        public encrypt(source: ICipherContent, destinationEnc: ICipherContent, format: DataFormat): string {
+            let sourceData: any;
+            let destinationData: any;
+
+            if (source.type === CipherContentType.url) {
+                sourceData = source.data.toString();
+            } else {
+                sourceData = new Buffer(source.data.valueOf() as any);
+            }
+            if (destinationEnc.type === CipherContentType.url) {
+                destinationData = destinationEnc.data.toString();
+            } else {
+                destinationData = new Buffer(destinationEnc.data.valueOf() as any);
+            }
+            return this.handle.encrypt(sourceData, destinationData, format);
         }
 
         /**
@@ -55,8 +78,20 @@ namespace trusted.pki {
          *
          * @memberOf Cipher
          */
-        public decrypt(filenameEnc: string, filenameDec: string, format?: DataFormat): void {
-            this.handle.decrypt(filenameEnc, filenameDec, format);
+        public decrypt(sourceEnc: ICipherContent, destDec: ICipherContent, format: DataFormat): string {
+            let sourceData: any;
+            let destinationData: any;
+            if (sourceEnc.type === CipherContentType.url) {
+                sourceData = sourceEnc.data.toString();
+            } else {
+                sourceData = new Buffer(sourceEnc.data.valueOf() as any);
+            }
+            if (destDec.type === CipherContentType.url) {
+                destinationData = destDec.data.toString();
+            } else {
+                destinationData = new Buffer(destDec.data.valueOf() as any);
+            }
+            return this.handle.decrypt(sourceData, destinationData, format);
         }
 
         /**

lib/utils/csp.ts

@@ -73,6 +73,19 @@ namespace trusted.utils {
             return csp.getCPCSPLicense();
         }
 
+         /**
+         * Return instaled correct license for CryptoPro CSP
+         * Throw exception if provaider not available
+         *
+         * @static
+         * @returns {boolean}
+         * @memberof Csp
+         */
+        public static getCPCSPVersion(): string {
+            const csp = new native.UTILS.Csp();
+            return csp.getCPCSPVersion();
+        }
+
         /**
          * Enumerate available CSP
          *