public string Decrypt(string metaStr)
{
#region metaStr_buffer
var metaStr_buffer = CryptographicBuffer.DecodeFromHexString(metaStr);
#endregion
#region _Key
var _SymmetricKeyAlgorithmProvider = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesCbc);
var _Key = _SymmetricKeyAlgorithmProvider.CreateSymmetricKey(CryptographicBuffer.CreateFromByteArray(this._key));
#endregion
#region IV_buffer
var IV_buffer = CryptographicBuffer.CreateFromByteArray(_iv);
#endregion
IBuffer _result_buffer = CryptographicEngine.Decrypt(_Key, metaStr_buffer, IV_buffer);
byte[] dat = new byte[256];
CryptographicBuffer.CopyToByteArray(_result_buffer, out dat);
#region rebuild string
List <byte> list_byte = new List <byte>();
for (int i = 0; i < dat.Count(); i++)
{
if (dat[i] != 0)
{
list_byte.Add(dat[i]);
}
}
#endregion
return(Encoding.UTF8.GetString(list_byte.ToArray()));
}
public async Task Decrypt_should_decrypt_content()
{
using (var input = TestFiles.Read("IO.Demo7Pass.kdbx"))
{
input.Seek(222);
var masterSeed = CryptographicBuffer.DecodeFromHexString(
"2b4656399a5bdf9fdfe9e8705a34b6f484f9b1b940c3d7cfb7ffece3b634e0ae");
var masterKey = CryptographicBuffer.DecodeFromHexString(
"87730050341ff55c46421f2f2a5f4e1e018d0443d19cacc8682f128f1874d0a4");
var encryptionIV = CryptographicBuffer.DecodeFromHexString(
"f360c29e1a603a6548cfbb28da6fff50");
using (var decrypted = await FileFormat.Decrypt(input,
masterKey, masterSeed, encryptionIV))
{
var buffer = WindowsRuntimeBuffer.Create(32);
buffer = await decrypted.ReadAsync(buffer, 32);
Assert.Equal(
"54347fe32f3edbccae1fc60f72c11dafd0a72487b315f9b174ed1073ed67a6e0",
CryptographicBuffer.EncodeToHexString(buffer));
}
}
}
public IAsyncOperation <IInputStream> UriToStreamAsync(System.Uri uri)
{
string path = uri.AbsolutePath;
if (path.StartsWith("/ajax", StringComparison.OrdinalIgnoreCase))
{
return(GetObject(new
{
a = 1,
b = "b"
}).AsAsyncOperation());
}
string host = uri.Host;
int delimiter = host.LastIndexOf('_');
string encodedContentId = host.Substring(delimiter + 1);
IBuffer buffer = CryptographicBuffer.DecodeFromHexString(encodedContentId);
string contentIdentifier = CryptographicBuffer.ConvertBinaryToString(BinaryStringEncoding.Utf8, buffer);
string relativePath = uri.PathAndQuery;
// For this sample, we will return a stream for a file under the local app data
// folder, under the subfolder named after the contentIdentifier and having the
// given relativePath. Real apps can have more complex behavior, such as handling
// contentIdentifiers in a custom manner (not necessarily as paths), and generating
// arbitrary streams that are not read directly from a file.
System.Uri appDataUri = new Uri("ms-appx:///app" + relativePath);
return(GetFileStreamFromApplicationUriAsync(appDataUri).AsAsyncOperation());
}
public string getDPK(string username, string password)
{
string dpk = "";
try
{
PasswordCredential credential = vault.Retrieve(vaultID, username);
if (credential != null)
{
credential.RetrievePassword();
JObject jsonEntries = JObject.Parse(credential.Password);
string saltString = jsonEntries.GetValue(JSONStoreConstants.JSON_STORE_KEY_SALT).ToString();
string ivString = jsonEntries.GetValue(JSONStoreConstants.JSON_STORE_KEY_IV).ToString();
IBuffer salt = CryptographicBuffer.DecodeFromHexString(saltString);
IBuffer iv = CryptographicBuffer.DecodeFromHexString(ivString);
IBuffer pwKey = CryptographicBuffer.ConvertStringToBinary(password, BinaryStringEncoding.Utf8);
IBuffer cpk = passwordToKey(pwKey, salt);
// decrypt the dpk
dpk = decryptWithKey(cpk, jsonEntries.GetValue(JSONStoreConstants.JSON_STORE_KEY_DPK).ToString(), iv);
}
}
catch (Exception)
{
//log error message
}
return(dpk);
}
/// <summary>
/// 将 HexString 转换为 Byte 数组数据
/// </summary>
/// <param name="hexString">需要转换的 HexString </param>
/// <returns>转换完成的 Byte 数组</returns>
public static Byte[] DecodeFromHexString(String hexString)
{
var buff = CryptographicBuffer.DecodeFromHexString(hexString);
Byte[] data = new Byte[buff.Length];
CryptographicBuffer.CopyToByteArray(buff, out data);
return(data);
}
private void ReceiveEncryptionKey(Windows.Networking.Proximity.ProximityDevice sender, Windows.Networking.Proximity.ProximityMessage message)
{
string keyString = message.DataAsString;
this.keyBuff = CryptographicBuffer.DecodeFromHexString(keyString);
lastSelected.encryptionKey = AppServices.encryptionAlgorithim.CreateSymmetricKey(this.keyBuff);
this.PrintMessageAsync("Secure connection established! You may now separate your devices.");
}
public static string DESDecrypt(string pwd, string str)
{
IBuffer buffKey = CryptographicBuffer.ConvertStringToBinary(MD5Encrypt(pwd, MD5MD5EncryptType.Key), BinaryStringEncoding.Utf8);
IBuffer cryptBuffer = CryptographicBuffer.DecodeFromHexString(str);
CryptographicKey myKey = Syprvd.CreateSymmetricKey(buffKey);
IBuffer decryptBuffer = CryptographicEngine.Decrypt(myKey, cryptBuffer, BuffIni);
return(CryptographicBuffer.ConvertBinaryToString(BinaryStringEncoding.Utf8, decryptBuffer));
}
/// <summary>
/// This is the click handler for the 'RunSample' button. It is responsible for executing the sample code.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void RunSample_Click(object sender, RoutedEventArgs e)
{
String algName = AlgorithmNames.SelectionBoxItem.ToString();
IBuffer Secret = CryptographicBuffer.ConvertStringToBinary("Master key to derive from", BinaryStringEncoding.Utf8);
UInt32 TargetSize = UInt32.Parse(KeySizes.SelectionBoxItem.ToString());
KeyDerivationText.Text = "";
KeyDerivationParameters Params;
if (algName.Contains("PBKDF2"))
{
// Password based key derivation function (PBKDF2).
Params = KeyDerivationParameters.BuildForPbkdf2(
CryptographicBuffer.GenerateRandom(16), // Salt
10000 // PBKDF2 Iteration Count
);
}
else if (algName.Contains("SP800_108"))
{
// SP800_108_CTR_HMAC key derivation function.
Params = KeyDerivationParameters.BuildForSP800108(
CryptographicBuffer.ConvertStringToBinary("Label", BinaryStringEncoding.Utf8), // Label
CryptographicBuffer.DecodeFromHexString("303132333435363738") // Context
);
}
else if (algName.Contains("SP800_56A"))
{
Params = KeyDerivationParameters.BuildForSP80056a(
CryptographicBuffer.ConvertStringToBinary("AlgorithmId", BinaryStringEncoding.Utf8),
CryptographicBuffer.ConvertStringToBinary("VParty", BinaryStringEncoding.Utf8),
CryptographicBuffer.ConvertStringToBinary("UParty", BinaryStringEncoding.Utf8),
CryptographicBuffer.ConvertStringToBinary("SubPubInfo", BinaryStringEncoding.Utf8),
CryptographicBuffer.ConvertStringToBinary("SubPrivInfo", BinaryStringEncoding.Utf8)
);
}
else
{
KeyDerivationText.Text += " An invalid algorithm was specified.\n";
return;
}
// Create a KeyDerivationAlgorithmProvider object for the algorithm specified on input.
KeyDerivationAlgorithmProvider Algorithm = KeyDerivationAlgorithmProvider.OpenAlgorithm(algName);
KeyDerivationText.Text += "*** Sample Kdf Algorithm: " + Algorithm.AlgorithmName + "\n";
KeyDerivationText.Text += " Secrect Size: " + Secret.Length + "\n";
KeyDerivationText.Text += " Target Size: " + TargetSize + "\n";
// Create a key.
CryptographicKey key = Algorithm.CreateKey(Secret);
// Derive a key from the created key.
IBuffer derived = CryptographicEngine.DeriveKeyMaterial(key, Params, TargetSize);
KeyDerivationText.Text += " Derived " + derived.Length + " bytes\n";
KeyDerivationText.Text += " Derived: " + CryptographicBuffer.EncodeToHexString(derived) + "\n";
}
// Decrypt data using the AES_ECB_PKCS7 Algorithim and the given key and return the raw data as a UTF8 encoded string.
// the data passed in should be encrypted HEX encoded string that was encrypted using the passed in encryptionKey
public static string DecryptString(string data, CryptographicKey encryptionKey)
{
// Create the algorithim, the key, and a buffer to store the string that we want to encrypt
IBuffer dataBuff = CryptographicBuffer.DecodeFromHexString(data);
// Decrypt the data and return it as a string
IBuffer decryptedBuff = CryptographicEngine.Decrypt(encryptionKey, dataBuff, null);
return(CryptographicBuffer.ConvertBinaryToString(BinaryStringEncoding.Utf8, decryptedBuff));
}
public void Enscrypt_should_compute_the_correct_hash(string password, string saltText, int iterations, string expected)
{
var hasher = new PasswordHasher(password);
var salt = saltText == "" ? new byte[0] : CryptographicBuffer.DecodeFromHexString(saltText).ToArray();
var key = hasher.Enscrypt(salt, iterations);
var keyHex = CryptographicBuffer.EncodeToHexString(CryptographicBuffer.CreateFromByteArray(key));
Assert.AreEqual(expected, keyHex, ignoreCase: true);
}
public static string TripleDesDecrypt(string key, string ciphertext)
{
SymmetricKeyAlgorithmProvider tripleDes = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.TripleDesEcb);
IBuffer keyMaterial = CryptographicBuffer.ConvertStringToBinary(key, BinaryStringEncoding.Utf8);
CryptographicKey symmetricKey = tripleDes.CreateSymmetricKey(keyMaterial);
IBuffer cipherBuffer = CryptographicBuffer.DecodeFromHexString(ciphertext);
IBuffer plainBuffer = CryptographicEngine.Decrypt(symmetricKey, cipherBuffer, null);
return CryptographicBuffer.ConvertBinaryToString(BinaryStringEncoding.Utf8, plainBuffer);
}
public static string ComputeHash(string algorithm, string input, bool isByteArray)
{
byte[] a;
if (isByteArray)
{
if (input.Length % 2 == 1)
{
throw new Exception("\'" + input + "\' is missing a character to be a valid byte string.");
}
// making sure there are even number of characters.
IBuffer inBuffer = null;
try
{
// convert from characters to values ('0' -> 0, etc.)
inBuffer = CryptographicBuffer.DecodeFromHexString(input);
}
catch (Exception e)
{
throw new Exception("\'" + input + "\' is not a valid byte string.", e);
}
CryptographicBuffer.CopyToByteArray(inBuffer, out a);
if (a == null)
{
throw new Exception("\'" + input + "\' could not be converted into a byte stream.");
}
}
else
{
int i = 0;
a = new byte[input.Length];
foreach (char c in input)
{
a[i++] = (byte)c;
}
}
if (a.Length == 0)
{
throw new Exception("Byte array generated from \'" + input + "\' is empty.");
}
byte[] encoded = ComputeHash(algorithm, a);
if (encoded == null)
{
throw new Exception("Could not compute hash from \'" + input + "\'.");
}
var buffer = CryptographicBuffer.CreateFromByteArray(encoded);
var ret = CryptographicBuffer.EncodeToHexString(buffer);
return(ret);
}
internal string EncryptData(string data)
{
if (!SettingsManager.Instance.ContainsKey("EncryptionKey"))
{
GenerateEncryptionKey();
}
var key =
CryptographicBuffer.DecodeFromHexString(
SettingsManager.Instance.GetValue <string>("EncryptionKey"));
return(string.Empty);
}
public async Task Headers_should_detect_1x_file_format()
{
using (var file = new InMemoryRandomAccessStream())
{
await file.WriteAsync(CryptographicBuffer
.DecodeFromHexString("03D9A29A65FB4BB5"));
file.Seek(0);
var result = await FileFormat.Headers(file);
Assert.Null(result.Headers);
Assert.Equal(FileFormats.KeePass1x, result.Format);
}
}
public void Enscrypt_should_return_a_number_of_iterations_that_produces_hash(string password, string saltText, int seconds)
{
var hasher = new PasswordHasher(password);
int iterations;
var salt = saltText == "" ? new byte[0] : CryptographicBuffer.DecodeFromHexString(saltText).ToArray();
var hash = hasher.Enscrypt(salt, TimeSpan.FromSeconds(seconds), out iterations);
var expected = hasher.Enscrypt(salt, iterations);
var hashText = CryptographicBuffer.EncodeToHexString(hash.AsBuffer());
var expectedText = CryptographicBuffer.EncodeToHexString(expected.AsBuffer());
Assert.AreEqual(expectedText, hashText);
}
public IAsyncOperation <IInputStream> UriToStreamAsync(Uri uri)
{
string host = uri.Host;
int delimiter = host.LastIndexOf('_');
string encodedContentId = host.Substring(delimiter + 1);
IBuffer buffer = CryptographicBuffer.DecodeFromHexString(encodedContentId);
string contentIdentifier = CryptographicBuffer.ConvertBinaryToString(BinaryStringEncoding.Utf8, buffer);
string relativePath = uri.PathAndQuery;
var appDataUri = new Uri("ms-appx:///" + contentIdentifier + relativePath);
return(GetFileStreamFromApplicationUriAsync(appDataUri).AsAsyncOperation());
}
public async Task Headers_should_detect_old_format()
{
using (var file = new InMemoryRandomAccessStream())
{
// Schema; 2.01
await file.WriteAsync(CryptographicBuffer
.DecodeFromHexString("03D9A29A67FB4BB501000200"));
file.Seek(0);
var result = await FileFormat.Headers(file);
Assert.Null(result.Headers);
Assert.Equal(FileFormats.OldVersion, result.Format);
}
}
/// <summary>
/// A 64-byte keyfile is read as a UTF8 string, which must represent a hex string.
/// If the string is not hex, null is returned.
/// Otherwise the hex string is reinterpreted as a byte array and returned.
/// </summary>
/// <param name="fileData"></param>
/// <returns></returns>
private static IBuffer LoadHexKey32(IBuffer fileData)
{
DebugHelper.Assert(fileData.Length == 64);
try
{
string hexString = CryptographicBuffer.ConvertBinaryToString(BinaryStringEncoding.Utf8, fileData);
IBuffer hexData = CryptographicBuffer.DecodeFromHexString(hexString);
DebugHelper.Assert(hexData.Length == 32);
return(hexData);
}
catch (Exception)
{
return(null);
}
}
public async Task Should_transform_master_key()
{
var data = new PasswordData
{
Password = "******",
};
var seed = CryptographicBuffer.DecodeFromHexString(
"9525f6992beb739cbaa73ae6e050627fcaff378d3cd6f6c232d20aa92f6d0927");
var masterKey = await data.GetMasterKey(seed, 6000);
Assert.Equal(
"87730050341ff55c46421f2f2a5f4e1e018d0443d19cacc8682f128f1874d0a4",
CryptographicBuffer.EncodeToHexString(masterKey));
}
/// <summary>
/// 认证用户授权
/// </summary>
/// <returns></returns>
public static async Task <AuthenticatorState> VerifyUserAsync()
{
if (await CheckSupportAsync().ConfigureAwait(false))
{
if (ApplicationData.Current.LocalSettings.Values["WindowsHelloPublicKeyForUser"] is string PublicKey)
{
KeyCredentialRetrievalResult RetrievalResult = await KeyCredentialManager.OpenAsync(CredentialName);
switch (RetrievalResult.Status)
{
case KeyCredentialStatus.Success:
{
KeyCredentialOperationResult OperationResult = await RetrievalResult.Credential.RequestSignAsync(CryptographicBuffer.ConvertStringToBinary(ChallengeText, BinaryStringEncoding.Utf8));
if (OperationResult.Status == KeyCredentialStatus.Success)
{
var Algorithm = AsymmetricKeyAlgorithmProvider.OpenAlgorithm(AsymmetricAlgorithmNames.RsaSignPkcs1Sha256);
var Key = Algorithm.ImportPublicKey(CryptographicBuffer.DecodeFromHexString(PublicKey));
return(CryptographicEngine.VerifySignature(Key, CryptographicBuffer.ConvertStringToBinary(ChallengeText, BinaryStringEncoding.Utf8), OperationResult.Result) ? AuthenticatorState.VerifyPassed : AuthenticatorState.VerifyFailed);
}
else
{
return(AuthenticatorState.UnknownError);
}
}
case KeyCredentialStatus.NotFound:
{
return(AuthenticatorState.CredentialNotFound);
}
default:
{
return(AuthenticatorState.UnknownError);
}
}
}
else
{
return(AuthenticatorState.UserNotRegistered);
}
}
else
{
return(AuthenticatorState.WindowsHelloUnsupport);
}
}
public void Enscrypt_should_use_a_number_of_iterations_that_takes_the_specified_duration_to_hash(string password, string saltText, int seconds)
{
// This test may sometimes give a false positive and report the method as failing. This is due to the inaccurate way we are measuring the duration.
var hasher = new PasswordHasher(password);
int iterations;
var salt = saltText == "" ? new byte[0] : CryptographicBuffer.DecodeFromHexString(saltText).ToArray();
var hash = hasher.Enscrypt(salt, TimeSpan.FromSeconds(seconds), out iterations);
var expected = DateTime.Now.AddSeconds(seconds);
var result = hasher.Enscrypt(salt, iterations);
var actual = DateTime.Now;
var difference = expected - actual;
Assert.IsTrue(difference < TimeSpan.FromSeconds(1), "hashing by iteration took {0}s less time than the specified duration of {1}s", difference.TotalSeconds, seconds);
Assert.IsTrue(difference >= TimeSpan.FromSeconds(-1), "hashing by iteration took {0}s more time than the specified duration of {1}s", difference.TotalSeconds, seconds);
}
private string ConvertHexToPassPhrase(NetworkAuthenticationType authType, string presharedKey)
{
// If this is a WPA/WPA2-PSK type network then convert the HEX STRING back to a passphrase
// Note that a 64 character WPA/2 network key is expected as a 128 character HEX-ized that will be
// converted back to a 64 character network key.
if ((authType == NetworkAuthenticationType.WpaPsk) ||
(authType == NetworkAuthenticationType.RsnaPsk))
{
var tempBuffer = CryptographicBuffer.DecodeFromHexString(presharedKey);
var hexString = CryptographicBuffer.ConvertBinaryToString(BinaryStringEncoding.Utf8, tempBuffer);
return(hexString);
}
// If this is a WEP key then it should arrive here as a 10 or 26 character hex-ized
// string which will be passed straight through
return(presharedKey);
}
public async static Task <String> UnprotectAsync(string strProtected)
{
// Create a DataProtectionProvider object.
DataProtectionProvider Provider = new DataProtectionProvider();
BinaryStringEncoding encoding = BinaryStringEncoding.Utf8;
// Decrypt the protected message specified on input.
IBuffer buffUnprotected = await Provider.UnprotectAsync(CryptographicBuffer.DecodeFromHexString(strProtected));
// Execution of the SampleUnprotectData method resumes here
// after the awaited task (Provider.UnprotectAsync) completes
// Convert the unprotected message from an IBuffer object to a string.
String strClearText = CryptographicBuffer.ConvertBinaryToString(encoding, buffUnprotected);
// Return the plaintext string.
return(strClearText);
}
public void CrcValidation()
{
byte[] mlvi = CryptographicBuffer.DecodeFromHexString("a1c46b44c67a053a").ToArray();
byte[] salt = CryptographicBuffer.DecodeFromHexString("5555555555555555").ToArray();
byte[] bchipid = CryptographicBuffer.DecodeFromHexString("febbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb").ToArray();
byte[] pubkey = new byte[BChipMemoryLayout_BCHIP.PUBKEY_MAX_DATA];
for (int i = 0; i < BChipMemoryLayout_BCHIP.PUBKEY_MAX_DATA; i++)
{
pubkey[i] = 0xaa;
}
byte[] privkey = new byte[BChipMemoryLayout_BCHIP.PRIVATEKEY_MAX_DATA];
for (int i = 0; i < BChipMemoryLayout_BCHIP.PRIVATEKEY_MAX_DATA; i++)
{
privkey[i] = 0x0;
}
byte[] checksum = CryptographicBuffer.DecodeFromHexString("6c66ba9ae44d9b").ToArray();
List <byte> simulatedCard = new List <byte>();
simulatedCard.AddRange(salt);
simulatedCard.AddRange(bchipid);
simulatedCard.AddRange(pubkey);
simulatedCard.AddRange(privkey);
simulatedCard.AddRange(checksum);
BChipMemoryLayout_BCHIP bChipCardData =
new BChipMemoryLayout_BCHIP(
mlvi,
simulatedCard.ToArray(),
PKStatus.NotAvailable);
Assert.IsTrue(bChipCardData.crcData.Length == BChipMemoryLayout_BCHIP.CRC_MAX_SIZE);
for (int i = 0; i < checksum.Length; ++i)
{
Assert.AreEqual(checksum[i], bChipCardData.crcData[i]);
}
byte[] calculatedChecksum = bChipCardData.GetCardCheckSum();
for (int i = 0; i < checksum.Length; ++i)
{
Assert.AreEqual(checksum[i], calculatedChecksum[i]);
}
}
/// <summary>
/// Task to call the "configure-ap" command to a Particle Device in Listening mode
/// </summary>
/// <param name="index">Index for this cofiguration</param>
/// <param name="scanAP">The SoftAPScanAP to use</param>
/// <param name="password">The unencrypted password for the WiFi connection</param>
/// <param name="publicKey">The publi key from the device</param>
/// <returns>Returns response code</returns>
public static async Task <int> SetConfigureAPAsync(int index, SoftAPScanAP scanAP, string password, SoftAPPublicKey publicKey)
{
var configureAP = new SoftAPConfigureAP();
configureAP.Index = index;
configureAP.SSID = scanAP.SSID;
configureAP.Security = scanAP.Security;
configureAP.Channel = scanAP.Channel;
if (configureAP.Security != SecurityType.SecurityOpen)
{
var algorithm = AsymmetricKeyAlgorithmProvider.OpenAlgorithm(AsymmetricAlgorithm.RsaPkcs1);
var publicKeyBuffer = CryptographicBuffer.DecodeFromHexString(publicKey.Data);
var key = algorithm.ImportPublicKey(publicKeyBuffer);
var data = CryptographicBuffer.ConvertStringToBinary(password, System.Text.Encoding.UTF8);
var encryptedData = CryptographicEngine.Encrypt(key, data, null);
string encryptedPassword = CryptographicBuffer.EncodeToHexString(encryptedData);
configureAP.Password = encryptedPassword;
}
var configureAPString = JsonConvert.SerializeObject(configureAP,
Formatting.None,
new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore
});
string responseContent = await SendSoftAPCommandAsync(SetupCommand.ConfigureAP, configureAPString);
if (responseContent == null)
{
return(-1);
}
var result = JToken.Parse(responseContent);
var responseCode = (int)result["r"];
return(responseCode);
}
private static byte[] ConvertStringToByteArray(string input, bool isByteArray)
{
byte[] byteArray = null;
if (isByteArray)
{
if (input.Length % 2 == 1)
{
throw new Exception("\'" + input + "\' is missing a character to be a valid byte string.");
}
IBuffer inBuffer = null;
try
{
// convert from characters to values ('0' -> 0, etc.)
inBuffer = CryptographicBuffer.DecodeFromHexString(input);
}
catch (Exception e)
{
throw new Exception("\'" + input + "\' is not a valid byte string.", e);
}
CryptographicBuffer.CopyToByteArray(inBuffer, out byteArray);
if (byteArray == null)
{
throw new Exception("\'" + input + "\' could not be converted into a byte stream.");
}
}
else
{
int i = 0;
byteArray = new byte[input.Length];
foreach (char c in input)
{
byteArray[i++] = (byte)c;
}
}
if (byteArray.Length == 0)
{
throw new Exception("Byte array generated from \'" + input + "\' is empty.");
}
return(byteArray);
}
/// <summary>
/// Loads the specified key file.
/// </summary>
/// <param name="input">The input.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentNullException">
/// The <paramref name="input"/> parameter cannot be <c>null</c>.
/// </exception>
private static async Task <IBuffer> LoadKeyFile(IRandomAccessStream input)
{
if (input == null)
{
throw new ArgumentNullException("input");
}
var buffer = WindowsRuntimeBuffer.Create(1024);
switch (input.Size)
{
case 32: // Binary key file
return(await input.ReadAsync(buffer, 32));
case 64: // Hex text key file
buffer = await input.ReadAsync(buffer, 64);
var hex = CryptographicBuffer.ConvertBinaryToString(
BinaryStringEncoding.Utf8, buffer);
if (IsHexString(hex))
{
return(CryptographicBuffer.DecodeFromHexString(hex));
}
break;
}
// XML
input.Seek(0);
var xml = LoadXmlKeyFile(input);
if (xml != null)
{
return(xml);
}
// Random keyfile
input.Seek(0);
return(await GetFileHash(input, buffer));
}
public async Task <ByteTuple> DecryptAsync(string publicKey)
{
var vault = new PasswordVault();
var credential = vault.Retrieve($"{_session}", publicKey);
var split = credential.Password.Split(';');
var saltString = split[0];
var dataString = split[1];
var localPasswordString = split[2];
var typeString = split[3];
var salt = CryptographicBuffer.DecodeFromHexString(saltString);
var data = CryptographicBuffer.DecodeFromHexString(dataString);
var localPassword = CryptographicBuffer.DecodeFromHexString(localPasswordString);
var dialog = new SettingsPasscodeConfirmView(passcode => Task.FromResult(false), true);
var confirm = await dialog.ShowQueuedAsync();
if (confirm != ContentDialogResult.Primary)
{
return(null);
}
var secret = CryptographicBuffer.ConvertStringToBinary(dialog.Passcode, BinaryStringEncoding.Utf8);
var material = PBKDF2(secret, salt);
var objAlg = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesEcbPkcs7);
var key = objAlg.CreateSymmetricKey(material);
var decrypt = CryptographicEngine.Decrypt(key, data, null);
CryptographicBuffer.CopyToByteArray(decrypt, out byte[] result);
CryptographicBuffer.CopyToByteArray(localPassword, out byte[] local);
return(new ByteTuple(result, local));
}
public async Task <LogOnResult> LogOnAsync(string userId, string password)
{
using (var client = new HttpClient())
{
// Ask the server for a password challenge string
var requestId = CryptographicBuffer.EncodeToHexString(CryptographicBuffer.GenerateRandom(4));
var challengeResponse = await client.GetAsync(new Uri(_clientBaseUrl + "GetPasswordChallenge?requestId=" + requestId));
challengeResponse.EnsureSuccessStatusCode();
var challengeEncoded = await challengeResponse.Content.ReadAsStringAsync();
challengeEncoded = challengeEncoded.Replace(@"""", string.Empty);
var challengeBuffer = CryptographicBuffer.DecodeFromHexString(challengeEncoded);
// Use HMAC_SHA512 hash to encode the challenge string using the password being authenticated as the key.
var provider = MacAlgorithmProvider.OpenAlgorithm(MacAlgorithmNames.HmacSha512);
var passwordBuffer = CryptographicBuffer.ConvertStringToBinary(password, BinaryStringEncoding.Utf8);
var hmacKey = provider.CreateKey(passwordBuffer);
var buffHmac = CryptographicEngine.Sign(hmacKey, challengeBuffer);
var hmacString = CryptographicBuffer.EncodeToHexString(buffHmac);
// Send the encoded challenge to the server for authentication (to avoid sending the password itself)
var response = await client.GetAsync(new Uri(_clientBaseUrl + userId + "?requestID=" + requestId + "&passwordHash=" + hmacString));
// Raise exception if sign in failed
response.EnsureSuccessStatusCode();
// On success, return sign in results from the server response packet
var responseContent = await response.Content.ReadAsStringAsync();
var result = JsonConvert.DeserializeObject <UserInfo>(responseContent);
var serverUri = new Uri(Constants.ServerAddress);
return(new LogOnResult {
UserInfo = result
});
}
}
/// <summary>
/// Gets the file format of the specified stream based on file signature.
/// </summary>
/// <param name="buffer">The signature bytes buffer.</param>
/// <returns>The detected database file format.</returns>
private static FileFormats CheckSignature(IBuffer buffer)
{
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
// KeePass 1.x
var oldSignature = CryptographicBuffer
.DecodeFromHexString("03D9A29A65FB4BB5");
if (CryptographicBuffer.Compare(buffer, oldSignature))
{
return(FileFormats.KeePass1x);
}
// KeePass 2.x pre-release
var preRelease = CryptographicBuffer
.DecodeFromHexString("03D9A29A66FB4BB5");
if (CryptographicBuffer.Compare(buffer, preRelease))
{
return(FileFormats.OldVersion);
}
// KeePass 2.x
var current = CryptographicBuffer
.DecodeFromHexString("03D9A29A67FB4BB5");
if (!CryptographicBuffer.Compare(buffer, current))
{
return(FileFormats.NotSupported);
}
return(FileFormats.Supported);
}