internal override void Evaluate()
{
byte[] oaepOut = Hex.Decode(
"4458cce0f94ebd79d275a134d224f95ef4126034e5d979359703b466096fcc15b71b78df4d4a68033112dfcfad7611cc" +
"0458475ab4a66b815f87fcb16a8aa1133441b9d61ed846c4856c5d42059fab7505bd8ffa5281a2bb187c6c853f298c98" +
"d5752a40be905f85e5ccb27d59415f09ac12a1788d654c675d98f412e6481e6f1159f1736dd96b29c99b411b4e5420b5" +
"6b07be2885dbc397fa091f66877c41e502cb4afeba460a2ebcdec7d09d933e630b98a4510ad6f32ca7ffc1bdb43e46ff" +
"f709819d3a69d9b62b774cb12c9dc176a6911bf370ab5029719dc1b4c13e23e57e46a7cd8ba5ee54c954ed460835ddab" +
"0086fa36ac110a5790e82c929bc7ca86");
IAsymmetricBlockCipher cipher = new OaepEncoding(provider.CreateEngine(EngineUsage.GENERAL), new Sha1Digest(), new Sha1Digest(), null);
cipher.Init(true, new ParametersWithRandom(testPubKey, new TestRandomData("18b776ea21069d69776a33e96bad48e1dda0a5ef")));
byte[] output;
output = cipher.ProcessBlock(msg, 0, msg.Length);
if (!Arrays.AreEqual(FipsKats.Values[FipsKats.Vec.RsaStartupOaepEnc], output))
{
Fail("self test OAEP transport encrypt failed.");
}
cipher.Init(false, new ParametersWithRandom(testPrivKey, Utils.testRandom));
output = cipher.ProcessBlock(oaepOut, 0, oaepOut.Length);
if (!Arrays.AreEqual(FipsKats.Values[FipsKats.Vec.RsaStartupOaepDec], output))
{
Fail("self test OAEP transport decrypt failed.");
}
}
public void Test_Function()
{
SHA256Managed hash = new SHA256Managed();
SecureRandom randomNumber = new SecureRandom();
byte[] encodingParam = hash.ComputeHash(Encoding.UTF8.GetBytes(randomNumber.ToString()));
string inputMessage = "Test Message";
UTF8Encoding utf8enc = new UTF8Encoding();
byte[] inputBytes = utf8enc.GetBytes(inputMessage);
RsaKeyPairGenerator rsaKeyPairGnr = new RsaKeyPairGenerator();
rsaKeyPairGnr.Init(new Org.BouncyCastle.Crypto.KeyGenerationParameters(new SecureRandom(), 1024));
AsymmetricCipherKeyPair keyPair = rsaKeyPairGnr.GenerateKeyPair();
publicKey = (RsaKeyParameters)keyPair.Public;
privateKey = (RsaKeyParameters)keyPair.Private;
//string pub = GetPublicKey();
//string priv = GetPrivateKey();
IAsymmetricBlockCipher cipher = new OaepEncoding(new RsaEngine(), new Sha256Digest(), encodingParam);
cipher.Init(true, publicKey);
byte[] ciphered = cipher.ProcessBlock(inputBytes, 0, inputMessage.Length);
string cipheredText = utf8enc.GetString(ciphered);
cipher.Init(false, privateKey);
byte[] deciphered = cipher.ProcessBlock(ciphered, 0, ciphered.Length);
string decipheredText = utf8enc.GetString(deciphered);
}
private void EncDec(
string label,
RsaKeyParameters pubParameters,
RsaKeyParameters privParameters,
byte[] seed,
byte[] input,
byte[] output)
{
IAsymmetricBlockCipher cipher = new OaepEncoding(new RsaEngine());
cipher.Init(true, new ParametersWithRandom(pubParameters, new VecRand(seed)));
byte[] outBytes = cipher.ProcessBlock(input, 0, input.Length);
for (int i = 0; i != output.Length; i++)
{
if (outBytes[i] != output[i])
{
Fail(label + " failed encryption");
}
}
cipher.Init(false, privParameters);
outBytes = cipher.ProcessBlock(output, 0, output.Length);
for (int i = 0; i != input.Length; i++)
{
if (outBytes[i] != input[i])
{
Fail(label + " failed decoding");
}
}
}
private void doTestOaep(RsaKeyParameters pubParameters, RsaKeyParameters privParameters)
{
//
// OAEP - public encrypt, private decrypt
//
IAsymmetricBlockCipher eng = new OaepEncoding(new RsaEngine());
byte[] data = Hex.Decode(input);
eng.Init(true, pubParameters);
try
{
data = eng.ProcessBlock(data, 0, data.Length);
}
catch (Exception e)
{
Fail("failed - exception " + e.ToString(), e);
}
eng.Init(false, privParameters);
try
{
data = eng.ProcessBlock(data, 0, data.Length);
}
catch (Exception e)
{
Fail("failed - exception " + e.ToString(), e);
}
if (!input.Equals(Hex.ToHexString(data)))
{
Fail("failed OAEP Test");
}
// check for oversized input
byte[] message = new byte[87];
RsaEngine rsaEngine = new RsaEngine();
IAsymmetricBlockCipher cipher = new OaepEncoding(rsaEngine, new Sha1Digest(), new Sha1Digest(), message);
cipher.Init(true, new ParametersWithRandom(pubParameters, new SecureRandom()));
try
{
cipher.ProcessBlock(message, 0, message.Length);
Fail("no exception thrown");
}
catch (DataLengthException e)
{
IsTrue("message mismatch", "input data too long".Equals(e.Message));
}
catch (InvalidCipherTextException e)
{
Fail("failed - exception " + e.ToString(), e);
}
}
public static byte[] EncryptRsa(string plainText, string key, Encoding encoding)
{
using (var publicKeyPem = new StringReader(key))
{
var publicKeyReader = new PemReader(publicKeyPem);
var publicKeyParam = (AsymmetricKeyParameter)publicKeyReader.ReadObject();
var rsa = new OaepEncoding(new RsaEngine());
rsa.Init(true, publicKeyParam);
var blockDataSize = rsa.GetInputBlockSize();
var encrypted = encoding
.GetBytes(plainText)
.Buffer(blockDataSize)
.Select(x =>
{
var arr = x.ToArray();
return(rsa.ProcessBlock(arr, 0, arr.Length));
})
.SelectMany(x => x)
.ToArray();
return(encrypted);
}
}
private static void DecryptRsa(Stream input, Stream output, Stream key, byte[] salt, char[] password)
{
using (StreamReader streamReader = new StreamReader(key))
{
AsymmetricCipherKeyPair cipherKeyPair = (AsymmetricCipherKeyPair) new PemReader(streamReader, new PasswordFinder(password)).ReadObject();
using (MemoryStream inputMemory = new MemoryStream(), outputMemory = new MemoryStream())
{
input.CopyTo(inputMemory);
byte[] inputBytes = inputMemory.ToArray();
IAsymmetricBlockCipher cipher = new OaepEncoding(new RsaEngine(), new Sha256Digest(), salt);
cipher.Init(false, cipherKeyPair.Private);
int length = inputBytes.Length;
int blockSize = cipher.GetInputBlockSize();
for (int offset = 0; offset < length; offset += blockSize)
{
int chunkSize = Math.Min(blockSize, length - offset);
byte[] deciphered = cipher.ProcessBlock(inputBytes, offset, chunkSize);
outputMemory.Write(deciphered, 0, deciphered.Length);
}
outputMemory.WriteTo(output);
Console.WriteLine("RSA-OAEP decryption successfull.");
}
}
}
public static string RSADecrypt(string cipherText, string pri)
{
byte[] cipherTextBytes = Convert.FromBase64String(cipherText);
StringReader t = new StringReader(pri);
PemReader pr = new PemReader(t);
AsymmetricCipherKeyPair keys = (AsymmetricCipherKeyPair)pr.ReadObject();
OaepEncoding eng = new OaepEncoding(new RsaEngine());
eng.Init(false, keys.Private);
int length = cipherTextBytes.Length;
int blockSize = eng.GetInputBlockSize();
List <byte> plainTextBytes = new List <byte>();
for (int chunkPosition = 0;
chunkPosition < length;
chunkPosition += blockSize)
{
int chunkSize = Math.Min(blockSize, length - chunkPosition);
plainTextBytes.AddRange(eng.ProcessBlock(
cipherTextBytes, chunkPosition, chunkSize
));
}
string st = Encoding.UTF8.GetString(plainTextBytes.ToArray());
return(st);
}
/// <summary>
/// Decrypts the specified encrypted e-KYC response data received from UIDAI.
/// </summary>
/// <param name="kycInfo">The encrypted e-KYC data.</param>
/// <returns>The decrypted e-KYC data.</returns>
/// <exception cref="ArgumentNullException"><paramref name="kycInfo"/> or <see cref="EncryptedKycInfo.InfoValue"/> is null.</exception>
public DecryptedKycInfo Decrypt(EncryptedKycInfo kycInfo)
{
ValidateNull(kycInfo, nameof(kycInfo));
ValidateNull(kycInfo.InfoValue, nameof(EncryptedKycInfo.InfoValue));
var iv = new byte[kycInfo.OaepLabel.Count];
Buffer.BlockCopy(kycInfo.OaepLabel.Array, kycInfo.OaepLabel.Offset, iv, 0, iv.Length);
// Decrypt Key
var oaep = new OaepEncoding(new RsaEngine(), new Sha256Digest(), iv);
oaep.Init(false, DotNetUtilities.GetRsaKeyPair(KuaKey.GetRSAPrivateKey()).Private);
var key = oaep.ProcessBlock(kycInfo.EncryptedKey.Array, kycInfo.EncryptedKey.Offset, kycInfo.EncryptedKey.Count);
// Decrypt Data
var cipher = CipherUtilities.GetCipher(SymmetricAlgorithm);
var parameter = new ParametersWithIV(new KeyParameter(key), iv, 0, 16);
cipher.Init(false, parameter);
var data = cipher.DoFinal(kycInfo.EncryptedData.Array, kycInfo.EncryptedData.Offset, kycInfo.EncryptedData.Count);
return(new DecryptedKycInfo {
InfoValue = data
});
}
public static byte[] Encrypt(byte[] data, byte[] key)
{
var pr = new PemReader(new StringReader(StringHelper.NewString(key).Trim()));
var keys = (RsaKeyParameters)pr.ReadObject();
// Pure mathematical RSA implementation
// RsaEngine eng = new RsaEngine();
// PKCS1 v1.5 paddings
// Pkcs1Encoding eng = new Pkcs1Encoding(new RsaEngine());
// PKCS1 OAEP paddings
var eng = new OaepEncoding(new RsaEngine());
eng.Init(true, keys);
var length = data.Length;
var blockSize = eng.GetInputBlockSize();
var encryptedData = new List <byte>();
for (var chunkPosition = 0; chunkPosition < length; chunkPosition += blockSize)
{
var chunkSize = Math.Min(blockSize, length - chunkPosition);
encryptedData.AddRange(eng.ProcessBlock(data, chunkPosition, chunkSize));
}
return(encryptedData.ToArray());
}
public static string RSAEncryptLong(string XmlPublicKey, string PlainText)
{
byte[] publicInfoByte = Convert.FromBase64String(XmlPublicKey);
AsymmetricKeyParameter publicKey = PublicKeyFactory.CreateKey(publicInfoByte);
var decryptEngine = new OaepEncoding(new RsaEngine());
decryptEngine.Init(true, publicKey);
byte[] bytesToDecrypt = Encoding.Default.GetBytes(PlainText);
int MaxPlainTextLength = Common.GetOEAPFixedMaxPlainTextLength(decryptEngine.GetOutputBlockSize());
byte[] decrypted = null;
int Times = (bytesToDecrypt.Length - 1) / MaxPlainTextLength + 1;
List <byte> encryptedCache = new List <byte>();
int Counter = 0;
while (Counter < Times)
{
int RemainLength = bytesToDecrypt.Length - MaxPlainTextLength * Counter;
int Length = MaxPlainTextLength > RemainLength ? RemainLength : MaxPlainTextLength;
byte[] decryptedPatch = decryptEngine.ProcessBlock(bytesToDecrypt, MaxPlainTextLength * Counter, Length);
encryptedCache.AddRange(decryptedPatch);
Counter++;
}
decrypted = encryptedCache.ToArray();
return(Convert.ToBase64String(decrypted));
}
/// <summary>
/// Uses RSA Publickey to Ecrypt
/// Requires .pem file
/// </summary>
/// <param name="plainText"></param>
/// <returns>Cypherbasestring</returns>
protected internal static string Encrypt(string plainText)
{
byte[] plainTextBytes = Encoding.UTF8.GetBytes(plainText);
Org.BouncyCastle.OpenSsl.PemReader pr = new Org.BouncyCastle.OpenSsl.PemReader(
File.OpenText(Program.tempDirectory + "\\IAPubkey.pem")
);
RsaKeyParameters keys = (RsaKeyParameters)pr.ReadObject();
// PKCS1 OAEP paddings
OaepEncoding eng = new OaepEncoding(new RsaEngine());
eng.Init(true, keys);
// Pure mathematical RSA implementation
int length = plainTextBytes.Length;
int blockSize = eng.GetInputBlockSize();
List <byte> cipherTextBytes = new List <byte>();
for (int chunkPosition = 0;
chunkPosition < length;
chunkPosition += blockSize)
{
int chunkSize = Math.Min(blockSize, length - chunkPosition);
cipherTextBytes.AddRange(eng.ProcessBlock(
plainTextBytes, chunkPosition, chunkSize
));
}
return(Convert.ToBase64String(cipherTextBytes.ToArray()));
}
public void btn_enc_Ok_Click(object sender, EventArgs e)
{
bool isChecked_enc = rb_enc_pri.Checked;
//Encryption using private key
if (isChecked_enc)
{
IAsymmetricBlockCipher cipher = new OaepEncoding(new RsaEngine());
cipher.Init(true, GprivateKey);
// byte[] ciphertext = System.Text.Encoding.UTF8.GetBytes(txt_enc_writeText.Text);
byte[] plaintext = System.Text.Encoding.UTF8.GetBytes(txt_enc_writeText.Text);
byte[] ciphertext = cipher.ProcessBlock(plaintext, 0, plaintext.Length);
string result = Encoding.UTF8.GetString(ciphertext);
txt_enc_output.Text = result;
//txt_enc_output.Text = System.Text.Encoding.UTF8.GetString(ciphertext);
}
//encryption using public key
else
{
IAsymmetricBlockCipher cipher = new OaepEncoding(new RsaEngine());
cipher.Init(true, GpublicKey);
// byte[] ciphertext = System.Text.Encoding.UTF8.GetBytes(txt_enc_writeText.Text);
byte[] plaintext = System.Text.Encoding.UTF8.GetBytes(txt_enc_writeText.Text);
byte[] ciphertext = cipher.ProcessBlock(plaintext, 0, plaintext.Length);
string result = Encoding.UTF8.GetString(ciphertext);
txt_enc_output.Text = result;
}
}
public string Decrypt(string encryptedText, string certificateKey, string privateCertificateFile)
{
try
{
byte[] cipherTextBytes = Convert.FromBase64String(encryptedText);
IPasswordFinder pf = new securityPasswordFinderInterface(certificateKey);
PemReader pr = new PemReader(
(StreamReader)File.OpenText(privateCertificateFile), pf
);
AsymmetricCipherKeyPair keys = (AsymmetricCipherKeyPair)pr.ReadObject();
OaepEncoding eng = new OaepEncoding(new RsaEngine());
eng.Init(false, keys.Private);
int length = cipherTextBytes.Length;
int blockSize = eng.GetInputBlockSize();
List <byte> plainTextBytes = new List <byte>();
for (int chunkPosition = 0;
chunkPosition < length;
chunkPosition += blockSize)
{
int chunkSize = Math.Min(blockSize, length - chunkPosition);
plainTextBytes.AddRange(eng.ProcessBlock(
cipherTextBytes, chunkPosition, chunkSize
));
}
return(Encoding.UTF8.GetString(plainTextBytes.ToArray()));
} catch (Exception ex)
{
throw ex;
}
}
public byte[] Decrypt(byte[] data)
{
if (_keyPrivate == null)
{
throw new Exception("Private key not set");
}
var engine = new OaepEncoding(new RsaEngine());
engine.Init(false, _keyPrivate);
int length = data.Length;
int blockSize = engine.GetInputBlockSize();
var decryptedBytes = new List <byte>();
for (int chunkPosition = 0;
chunkPosition < length;
chunkPosition += blockSize)
{
int chunkSize = Math.Min(blockSize, length - chunkPosition);
decryptedBytes.AddRange(engine.ProcessBlock(
data, chunkPosition, chunkSize
));
}
return(decryptedBytes.ToArray());
}
public static string DecryptRsa(byte[] encrypted, string key, Encoding encoding)
{
using (var privateKeyPem = new StringReader(key))
{
var rsa = new OaepEncoding(new RsaEngine());
var privateKeyReader = new PemReader(privateKeyPem);
var keyPair = (AsymmetricCipherKeyPair)privateKeyReader.ReadObject();
rsa.Init(false, keyPair.Private);
var blockDataSize = rsa.GetInputBlockSize();
var decrypted = encrypted
.Buffer(blockDataSize)
.Select(x =>
{
var arr = x.ToArray();
return(rsa.ProcessBlock(arr, 0, arr.Length));
})
.SelectMany(x => x)
.ToArray();
return(encoding.GetString(decrypted));
}
}
/*
* Function: EncryptByPublicKey()
* Key Type: PEM
* Description: Encrypt data by public key, corresponding to function DecryptByPrivateKey()
*/
public static string EncryptByPublicKey(string plainText, string publicKey, string paddingMode)
{
byte[] plainByte = Encoding.UTF8.GetBytes(plainText);
IAsymmetricBlockCipher encoding;
switch (paddingMode)
{
case MessageDefinition.RSAPaddingMode01:
encoding = new Pkcs1Encoding(new RsaEngine());
break;
case MessageDefinition.RSAPaddingMode02:
encoding = new ISO9796d1Encoding(new RsaEngine());
break;
default:
encoding = new OaepEncoding(new RsaEngine());
break;
}
encoding.Init(true, ReadPublicKey(publicKey));
int blockSize = encoding.GetInputBlockSize();
List <byte> output = new List <byte>();
for (int chunkPositon = 0; chunkPositon < plainByte.Length; chunkPositon += blockSize)
{
int chunkSize = Math.Min(blockSize, plainByte.Length - chunkPositon);
output.AddRange(encoding.ProcessBlock(plainByte, chunkPositon, chunkSize));
}
return(Convert.ToBase64String(output.ToArray()));
}
private static byte[] DecodeSymmetricKey(string label, string privateKeyPath, string ciphertext)
{
byte[] cipherTextBytes = HexToByte(ciphertext);
byte[] labelBytes = Encoding.UTF8.GetBytes(label);
PemReader pr = new PemReader(File.OpenText(privateKeyPath));
AsymmetricCipherKeyPair keys = (AsymmetricCipherKeyPair)pr.ReadObject();
OaepEncoding eng = new OaepEncoding(new RsaEngine(), new Sha256Digest(), new Sha256Digest(), labelBytes);
eng.Init(false, keys.Private);
int length = cipherTextBytes.Length;
int blockSize = eng.GetInputBlockSize();
List <byte> plainTextBytes = new List <byte>();
for (int chunkPosition = 0;
chunkPosition < length;
chunkPosition += blockSize)
{
int chunkSize = Math.Min(blockSize, length - chunkPosition);
plainTextBytes.AddRange(eng.ProcessBlock(
cipherTextBytes, chunkPosition, chunkSize
));
}
return(plainTextBytes.ToArray());
}
// to be done
public static string RSADecryptLong(string XmlPrivateKey, string EncryptedText)
{
AsymmetricKeyParameter privateKey = PrivateKeyFactory.CreateKey(Convert.FromBase64String(XmlPrivateKey));
var decryptEngine = new OaepEncoding(new RsaEngine());
decryptEngine.Init(false, privateKey);
int CipherLength = decryptEngine.GetInputBlockSize();
byte[] bytesToDecrypt = Convert.FromBase64String(EncryptedText);
byte[] decrypted = null;
int Times = (bytesToDecrypt.Length - 1) / CipherLength + 1;
List <byte> decryptedCache = new List <byte>();
int Counter = 0;
while (Counter < Times)
{
byte[] decryptedPatch = decryptEngine.ProcessBlock(bytesToDecrypt, CipherLength * Counter, CipherLength);
decryptedCache.AddRange(decryptedPatch);
Counter++;
}
decrypted = decryptedCache.ToArray();
return(Encoding.Default.GetString(decrypted));
}
public static byte[] Decrypt(byte[] data, byte[] key, byte[] encodingParam)
{
var pr = new PemReader(new StringReader(StringHelper.NewString(key).Trim()));
var keys = (AsymmetricCipherKeyPair)pr.ReadObject();
// Pure mathematical RSA implementation
// RsaEngine eng = new RsaEngine();
// PKCS1 v1.5 paddings
// Pkcs1Encoding eng = new Pkcs1Encoding(new RsaEngine());
// PKCS1 OAEP paddings
var eng = new OaepEncoding(new RsaEngine(), new Sha256Digest(), encodingParam);
eng.Init(false, keys.Private);
var length = data.Length;
var blockSize = eng.GetInputBlockSize();
var decryptedData = new List <byte>();
for (var chunkPosition = 0; chunkPosition < length; chunkPosition += blockSize)
{
var chunkSize = Math.Min(blockSize, length - chunkPosition);
decryptedData.AddRange(eng.ProcessBlock(data, chunkPosition, chunkSize));
}
return(decryptedData.ToArray());
}
public static byte[] Decrypt(byte[] data, AsymmetricKeyParameter key)
{
var cipher = new OaepEncoding(new RsaEngine());
cipher.Init(false, key);
return(cipher.ProcessBlock(data, 0, data.Length));
}
/// <summary>
/// Create instance of RSAManager
/// </summary>
public RSAManager RSAGenerateManager()
{
var keyGen = new RsaKeyPairGenerator();
keyGen.Init(new KeyGenerationParameters(new SecureRandom(), 2048));
var keyPair = keyGen.GenerateKeyPair();
Func <string, string> decrypt = (string encryptedValue) =>
{
var decryptEngine = new OaepEncoding(new RsaEngine());
var bytesToDecrypt = Convert.FromBase64String(encryptedValue);
decryptEngine.Init(false, keyPair.Private as RsaPrivateCrtKeyParameters);
return(Encoding.UTF8.GetString(decryptEngine.ProcessBlock(bytesToDecrypt, 0, bytesToDecrypt.Length)));
};
var info = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(keyPair.Public);
var stringWriter = new StringWriter();
var pemWriter = new PemWriter(stringWriter);
var pemObject = new PemObject("PUBLIC KEY", info.GetEncoded());
pemWriter.WriteObject(pemObject);
return(new RSAManager
{
Decrypt = decrypt,
PublicKey = stringWriter.ToString(),
});
}
/// <summary>
/// Encrypts the data with RSA oaep SHA 512
/// </summary>
/// <param name="key">The RSA public keys</param>
/// <param name="data">Data to encrypt</param>
/// <returns>Encrypted data</returns>
public static byte[] RsaEncrypt(AsymmetricKeyParameter key, byte[] data)
{
var encryptEngine = new OaepEncoding(new RsaEngine(), new Sha512Digest());
encryptEngine.Init(true, key);
return(encryptEngine.ProcessBlock(data, 0, data.Length));
}
internal static void PostProcess(this IEncryptedPrivateKeyModel model, string secretCryptoAccessKey)
{
// reference: https://stackoverflow.com/questions/44767290/decrypt-passphrase-protected-pem-containing-private-key
using (var keyReader = new StringReader(model.EncryptedPrivateKey))
{
// decrypt server-provided PEM private key using our secret passphrase
var pemReader = new PemReader(keyReader, new PasswordFinder(secretCryptoAccessKey));
object privateKeyObject = pemReader.ReadObject();
var rsaPrivatekey = privateKeyObject as RsaPrivateCrtKeyParameters;
if (rsaPrivatekey != null)
{
var rsaEngine = new OaepEncoding(
new RsaEngine(),
new Sha1Digest(),
new Sha1Digest(),
null);
rsaEngine.Init(false, rsaPrivatekey);
// use the client's private key to decrypt the server-provided data key,
// storing the result in the 'UnwrappedDataKey' property
var wrappedDataKeyBytes = Convert.FromBase64String(model.WrappedDataKey);
model.UnwrappedDataKey = rsaEngine.ProcessBlock(wrappedDataKeyBytes, 0, wrappedDataKeyBytes.Length);
}
}
}
/// <summary>
/// Encrypts a file key.
/// </summary>
/// <param name="plainFileKey">The file key to encrypt.</param>
/// <param name="userPublicKey">The public key which should be used for the encryption.</param>
/// <returns>The encrypted file key.</returns>
/// <exception cref="Dracoon.Crypto.Sdk.InvalidFileKeyException">If the provided file key is invalid.</exception>
/// <exception cref="Dracoon.Crypto.Sdk.InvalidKeyPairException">If the provided public key is invalid.</exception>
/// <exception cref="Dracoon.Crypto.Sdk.CryptoException">If an unexpected error occured.</exception>
public static EncryptedFileKey EncryptFileKey(PlainFileKey plainFileKey, UserPublicKey userPublicKey)
{
ValidatePlainFileKey(plainFileKey);
ValidateUserPublicKey(userPublicKey);
AsymmetricKeyParameter pubKey = ConvertPublicKey(userPublicKey.PublicKey);
byte[] eFileKey;
try {
OaepEncoding engine = new OaepEncoding(new RsaEngine(), new Sha256Digest(), new Sha1Digest(), null);
engine.Init(true, pubKey);
byte[] pFileKey = Convert.FromBase64String(plainFileKey.Key);
eFileKey = engine.ProcessBlock(pFileKey, 0, pFileKey.Length);
} catch (Exception e) {
throw new CryptoException("Could not encrypt file key. Encryption failed.", e);
}
EncryptedFileKey encFileKey = new EncryptedFileKey()
{
Key = Convert.ToBase64String(eFileKey),
Iv = plainFileKey.Iv,
Tag = plainFileKey.Tag,
Version = plainFileKey.Version
};
return(encFileKey);
}
public static string RSAEncrypt(string plainText, string pub)
{
byte[] plainTextBytes = Encoding.UTF8.GetBytes(plainText);
StringReader t = new StringReader(pub);
PemReader pr = new PemReader(t);
RsaKeyParameters keys = (RsaKeyParameters)pr.ReadObject();
OaepEncoding eng = new OaepEncoding(new RsaEngine());
eng.Init(true, keys);
int length = plainTextBytes.Length;
int blockSize = eng.GetInputBlockSize();
List <byte> cipherTextBytes = new List <byte>();
for (int chunkPosition = 0;
chunkPosition < length;
chunkPosition += blockSize)
{
int chunkSize = Math.Min(blockSize, length - chunkPosition);
cipherTextBytes.AddRange(eng.ProcessBlock(
plainTextBytes, chunkPosition, chunkSize
));
}
return(Convert.ToBase64String(cipherTextBytes.ToArray()));
}
/// <summary>
/// Decrypts a file key.
/// </summary>
/// <param name="encFileKey">The file key to decrypt.</param>
/// <param name="userPrivateKey">The private key which should be used for the decryption.</param>
/// <param name="password">The password which secures the private key.</param>
/// <returns>The decrypted file key.</returns>
/// <exception cref="Dracoon.Crypto.Sdk.InvalidFileKeyException">If the provided encrypted file key is invalid.</exception>
/// <exception cref="Dracoon.Crypto.Sdk.InvalidKeyPairException">If the provided private key is invalid.</exception>
/// <exception cref="Dracoon.Crypto.Sdk.InvalidPasswordException">If the provided private key password is invalid</exception>
/// <exception cref="Dracoon.Crypto.Sdk.CryptoException">If an unexpected error in the decryption occured.</exception>
public static PlainFileKey DecryptFileKey(EncryptedFileKey encFileKey, UserPrivateKey userPrivateKey, string password)
{
ValidateEncryptedFileKey(encFileKey);
ValidateUserPrivateKey(userPrivateKey);
ValidatePassword(password);
AsymmetricKeyParameter privateKey = DecryptPrivateKey(userPrivateKey.PrivateKey, password);
byte[] dFileKey;
try {
OaepEncoding engine = new OaepEncoding(new RsaEngine(), new Sha256Digest(), new Sha1Digest(), null);
engine.Init(false, privateKey);
byte[] eFileKey = Convert.FromBase64String(encFileKey.Key);
dFileKey = engine.ProcessBlock(eFileKey, 0, eFileKey.Length);
} catch (InvalidCipherTextException e) {
throw new CryptoException("Could not decrypt file key. Decryption failed.", e);
}
PlainFileKey plainFileKey = new PlainFileKey()
{
Key = Convert.ToBase64String(dFileKey),
Iv = encFileKey.Iv,
Tag = encFileKey.Tag,
Version = encFileKey.Version
};
return(plainFileKey);
}
private static byte[] Process(byte[] data, AsymmetricKeyParameter key, bool isEncryption)
{
var encoding = new OaepEncoding(new RsaEngine(), new Sha256Digest(), new Sha1Digest(), new byte[0]);
encoding.Init(isEncryption, key);
return(encoding.ProcessBlock(data, 0, data.Length));
}
static void Main(string[] args)
{
// Console.WriteLine("Hello World!");
// Variables declaration
string SrcData;
byte[] tmpSource;
// byte[] tempHash;
// Retrieve message
Console.WriteLine("Ingrese cualquier texto: ");
SrcData = Console.ReadLine();
// Create byte array from source data
tmpSource = Encoding.ASCII.GetBytes(SrcData);
Console.WriteLine();
Console.WriteLine("Pareja de llaves generandose...\n");
// RSAKeyPairGenerator
RsaKeyPairGenerator rsaKeyPairGen = new RsaKeyPairGenerator();
rsaKeyPairGen.Init(new KeyGenerationParameters(new SecureRandom(), 2048));
AsymmetricCipherKeyPair keyPair = rsaKeyPairGen.GenerateKeyPair();
// Extract public and private key
RsaKeyParameters PrivateKey = (RsaKeyParameters)keyPair.Private;
RsaKeyParameters PublicKey = (RsaKeyParameters)keyPair.Public;
// Print public key in PEM format
TextWriter textWriter1 = new StringWriter();
PemWriter pemWriter1 = new PemWriter(textWriter1);
pemWriter1.WriteObject(PublicKey);
pemWriter1.Writer.Flush();
string printPublicKey = textWriter1.ToString();
Console.WriteLine("La llave pública es: {0}", printPublicKey);
Console.WriteLine();
// Encryption
IAsymmetricBlockCipher cipher = new OaepEncoding(new RsaEngine());
cipher.Init(true, PublicKey);
byte[] cipherText = cipher.ProcessBlock(tmpSource, 0, tmpSource.Length);
string result = Encoding.UTF8.GetString(cipherText);
Console.WriteLine("Texto cifrado: ");
Console.WriteLine(result);
Console.WriteLine();
Console.WriteLine("¿Quiete descifrar el texto? Presione espacio para cifrarlo, o cualquier otra tecla si no");
char inputChar = Console.ReadKey().KeyChar;
if (inputChar == ' ')
{
Decryption(cipherText, PrivateKey);
}
}
public static byte[] Decrypt(byte[] data, AsymmetricKeyParameter privateKey)
{
if (privateKey == null || !privateKey.IsPrivate)
{
throw new ArgumentException("Not a valid decryption key");
}
// purely mathematical RSA
var engine = new RsaEngine();
// use padding
var cipher = new OaepEncoding(engine);
cipher.Init(false, privateKey);
var length = data.Length;
var blockSize = engine.GetInputBlockSize();
var plainTextBytes = new List <byte>();
for (var i = 0; i < length; i += blockSize)
{
var chunkSize = Math.Min(blockSize, length - i);
plainTextBytes.AddRange(engine.ProcessBlock(data, i, chunkSize));
}
return(plainTextBytes.ToArray());
}
internal static string Decode(string data)
{
try
{
X509Certificate k;
// read in the certificate
using (var textReader = File.OpenText("public.cer"))
{
// I'm assuming here that the certificate is PEM-encoded.
var pemReader = new PemReader(textReader);
k = (X509Certificate)pemReader.ReadObject();
}
// un-base64 the input
var dataBytes = Convert.FromBase64String(data);
// what php openssl_public_decrypt does
var cipher = new OaepEncoding(new RsaEngine());
cipher.Init(false, k.GetPublicKey());
var returnBytes = cipher.ProcessBlock(dataBytes, 0, dataBytes.Length);
// What is the character-encoding of the bytes? UTF-8?
return(Encoding.UTF8.GetString(returnBytes));
}
catch (Exception ex)
{
return("Failed:" + ex.Message);
}
}
