public static int ToInt32(IBuffer buffer)
{
byte[] data;
CryptographicBuffer.CopyToByteArray(buffer, out data);
data = GetBytes(data, 4);
return(BitConverter.ToInt32(data, 0));
}
/// <summary>
/// This function converts IBuffer data to string by specified format
/// </summary>
/// <param name="buffer"></param>
/// <param name="format"></param>
/// <returns></returns>
public static string FormatValue(IBuffer buffer, DataFormat format)
{
byte[] data;
CryptographicBuffer.CopyToByteArray(buffer, out data);
switch (format)
{
case DataFormat.ASCII:
return(Encoding.ASCII.GetString(data));
case DataFormat.UTF8:
return(Encoding.UTF8.GetString(data));
case DataFormat.Dec:
return(string.Join(" ", data.Select(b => b.ToString("00"))));
case DataFormat.Hex:
return(BitConverter.ToString(data).Replace("-", " "));
case DataFormat.Bin:
var s = string.Empty;
foreach (var b in data)
{
s += Convert.ToString(b, 2).PadLeft(8, '0') + " ";
}
return(s);
default:
return(Encoding.ASCII.GetString(data));
}
}
/// <summary>
/// Decrypts a message using a symmetric algorithm.
/// </summary>
private static void SymmetricDecrypt(
TcpChannelToken token,
ArraySegment <byte> dataToDecrypt,
bool useClientKeys)
{
// get the decrypting key.
CryptographicKey decryptingKey = (useClientKeys) ? token.ClientEncryptor : token.ServerEncryptor;
IBuffer IV = (useClientKeys) ? CryptographicBuffer.CreateFromByteArray(token.ClientInitializationVector) : CryptographicBuffer.CreateFromByteArray(token.ServerInitializationVector);
if (decryptingKey == null)
{
throw ServiceResultException.Create(StatusCodes.BadSecurityChecksFailed, "Token missing symmetric key object.");
}
SymmetricKeyAlgorithmProvider AesCbcProvider = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesCbc);
if (dataToDecrypt.Count % AesCbcProvider.BlockLength != 0)
{
throw ServiceResultException.Create(StatusCodes.BadSecurityChecksFailed, "Input data is not an even number of encryption blocks.");
}
byte[] blockToDecrypt = new byte[dataToDecrypt.Count];
Array.ConstrainedCopy(dataToDecrypt.Array, dataToDecrypt.Offset, blockToDecrypt, 0, dataToDecrypt.Count);
IBuffer block = CryptographicBuffer.CreateFromByteArray(blockToDecrypt);
IBuffer encryptedBuffer = CryptographicEngine.Decrypt(decryptingKey, block, IV);
CryptographicBuffer.CopyToByteArray(encryptedBuffer, out blockToDecrypt);
Array.ConstrainedCopy(blockToDecrypt, 0, dataToDecrypt.Array, dataToDecrypt.Offset, dataToDecrypt.Count);
}
public static byte[] DecryptAES(byte[] source, string publicKey)
{
if (source == null || source.Length == 0)
{
throw new ArgumentNullException("source");
}
if (string.IsNullOrEmpty(publicKey))
{
throw new ArgumentNullException("publicKey");
}
try
{
var str = Convert.ToBase64String(source);
IBuffer toDecryptBuffer = CryptographicBuffer.DecodeFromBase64String(str);
SymmetricKeyAlgorithmProvider aes = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesEcbPkcs7);
var symetricKey = aes.CreateSymmetricKey(GetMD5Hash(publicKey));
var buffDecrypted = CryptographicEngine.Decrypt(symetricKey, toDecryptBuffer, null);
byte[] result;
CryptographicBuffer.CopyToByteArray(buffDecrypted, out result);
return(result);
}
catch (Exception ex)
{
return(null);
}
}
public async Task <object> GenerateLocalPasswordAsync()
{
//var response = await _protoService.SendAsync(new GetTonWalletPasswordSalt());
//if (response is TonWalletPasswordSalt passwordSalt)
//{
// var passwordBuffer = CryptographicBuffer.GenerateRandom(64);
// var saltBuffer = CryptographicBuffer.GenerateRandom(32);
// CryptographicBuffer.CopyToByteArray(passwordBuffer, out byte[] password);
// CryptographicBuffer.CopyToByteArray(saltBuffer, out byte[] salt);
// System.Buffer.BlockCopy(passwordSalt.Salt.ToArray(), 0, password, 32, 32);
// return new ByteTuple(password, salt);
//}
//else if (response is Error error)
//{
// return new Ton.Tonlib.Api.Error(error.Code, error.Message);
//}
//return null;
var passwordBuffer = CryptographicBuffer.GenerateRandom(64);
var saltBuffer = CryptographicBuffer.GenerateRandom(32);
CryptographicBuffer.CopyToByteArray(passwordBuffer, out byte[] password);
CryptographicBuffer.CopyToByteArray(saltBuffer, out byte[] salt);
await Task.CompletedTask;
return(new ByteTuple(password, salt));
}
/// <summary>
/// Generate a cryptographically secure random number
/// </summary>
/// <param name="length">Length of the desired number in bytes</param>
/// <returns></returns>
public static byte[] GenerateRandomBytes(uint length)
{
IBuffer buffer = CryptographicBuffer.GenerateRandom(length);
byte[] rand = new byte[length];
CryptographicBuffer.CopyToByteArray(buffer, out rand);
return rand;
}
/// <inheritdoc />
public override void ForwardProcessDataStream(Stream inStream, Stream outStream, Dictionary <string, string> options, out long writtenBytes)
{
if (options == null)
{
throw new ArgumentException("Options dictionary was null", "options");
}
else if (!options.ContainsKey(paddedSizeOptionName) || !options.ContainsKey(padTypeOptionName) || !options.ContainsKey(padExceptionOptionName))
{
throw new ArgumentException("Options dictionary did not contain the necessary padding options", "options");
}
int paddingSize;
DataPaddingType padType;
bool padException;
if (!int.TryParse(options[paddedSizeOptionName], out paddingSize) || !bool.TryParse(options[padExceptionOptionName], out padException))
{
throw new ArgumentException("Options dictionary contained invalid options for DataPadder", "options");
}
try { padType = (DataPaddingType)Enum.Parse(typeof(DataPaddingType), options[padTypeOptionName]); }
catch (ArgumentException) { throw new ArgumentException("Options dictionary contained invalid options for DataPadder", "options"); }
if (padException && inStream.Length > paddingSize - 4)
{
throw new ArgumentException("Options dictionary contained invalid options for DataPadder. Not enough data padding was allowed", "options");
}
paddingSize = paddingSize - 4 - (int)inStream.Length;
if (paddingSize < 0)
{
paddingSize = 0;
}
byte[] padData;
if (padType == DataPaddingType.Random)
{
#if NETFX_CORE
CryptographicBuffer.CopyToByteArray(CryptographicBuffer.GenerateRandom((uint)paddingSize), out padData);
#else
padData = new byte[paddingSize];
rand.GetBytes(padData);
#endif
}
else
{
padData = new byte[paddingSize];
}
StreamTools.Write(inStream, 0, inStream.Length, outStream, 8192, double.MaxValue, int.MaxValue);
if (paddingSize != 0)
{
outStream.Write(padData, 0, padData.Length);
}
outStream.Write(BitConverter.GetBytes(paddingSize + 4), 0, 4);
writtenBytes = outStream.Position;
}
/// <summary>
/// Implementation of Load from storage for Windows Store.
/// </summary>
protected async Task <byte[]> LoadDataAsync()
{
try
{
// find the storage file
var localFolder = ApplicationData.Current.LocalFolder;
var storageFile = await localFolder.GetFileAsync(StorageFile);
// read the data. It will be encrypted data
IBuffer buffProtected = await FileIO.ReadBufferAsync(storageFile);
DataProtectionProvider provider = new DataProtectionProvider();
// decrypt the data
IBuffer clearBuffer = await provider.UnprotectAsync(buffProtected);
// convert it to byte array
byte[] clearBytes = new byte[clearBuffer.Length];
CryptographicBuffer.CopyToByteArray(clearBuffer, out clearBytes);
return(clearBytes);
}
catch (Exception)
{
return(null);
}
}
/// <summary>
/// HTTP请求签名
/// </summary>
/// <param name="url">请求目标的URL</param>
/// <param name="body">请求的主体数据</param>
/// <returns></returns>
public string SignRequest(string url, byte[] body)
{
Uri u = new Uri(url);
string pathAndQuery = u.PathAndQuery;
byte[] pathAndQueryBytes = Encoding.UTF8.GetBytes(pathAndQuery);
using (MemoryStream buffer = new MemoryStream())
{
buffer.Write(pathAndQueryBytes, 0, pathAndQueryBytes.Length);
buffer.WriteByte((byte)'\n');
if (body != null && body.Length > 0)
{
buffer.Write(body, 0, body.Length);
}
#if WINDOWS_UWP
var hma = MacAlgorithmProvider.OpenAlgorithm(MacAlgorithmNames.HmacSha1);
var skBuffer = CryptographicBuffer.ConvertStringToBinary(mac.SecretKey, BinaryStringEncoding.Utf8);
var hmacKey = hma.CreateKey(skBuffer);
var dataBuffer = CryptographicBuffer.CreateFromByteArray(buffer.ToArray());
var signBuffer = CryptographicEngine.Sign(hmacKey, dataBuffer);
byte[] digest;
CryptographicBuffer.CopyToByteArray(signBuffer, out digest);
#else
HMACSHA1 hmac = new HMACSHA1(Encoding.UTF8.GetBytes(mac.SecretKey));
byte[] digest = hmac.ComputeHash(buffer.ToArray());
#endif
string digestBase64 = Base64.UrlSafeBase64Encode(digest);
return(string.Format("{0}:{1}", mac.AccessKey, digestBase64));
}
}
/// <summary>
/// Creates a public and private key pair that can be used for asymmethric encryption
/// </summary>
/// <param name="keySize">The keysize to generate</param>
/// <returns>The generated key size</returns>
public static KeyPair CreateKeyPair(RSAKeySizes keySize)
{
#if WINDOWS_UWP
var asym = AsymmetricKeyAlgorithmProvider.OpenAlgorithm(AsymmetricAlgorithmNames.RsaPkcs1);
var key = asym.CreateKeyPair((uint)keySize);
var privateKeyBuffer = key.Export(CryptographicPrivateKeyBlobType.Capi1PrivateKey);
var publicKeyBuffer = key.ExportPublicKey(CryptographicPublicKeyBlobType.Capi1PublicKey);
byte[] privateKeyBytes;
byte[] publicKeyBytes;
CryptographicBuffer.CopyToByteArray(privateKeyBuffer, out privateKeyBytes);
CryptographicBuffer.CopyToByteArray(publicKeyBuffer, out publicKeyBytes);
string privateKey = Convert.ToBase64String(privateKeyBytes);
string publicKey = Convert.ToBase64String(publicKeyBytes);
#else
var cspParams = new CspParameters {
ProviderType = 1 /* PROV_RSA_FULL */
};
var rsaProvider = new RSACryptoServiceProvider((int)keySize, cspParams);
string publicKey = Convert.ToBase64String(rsaProvider.ExportCspBlob(false));
string privateKey = Convert.ToBase64String(rsaProvider.ExportCspBlob(true));
#endif
return(new KeyPair(privateKey.ToSecureString(), publicKey));
}
public static byte[] Decrypt(SecureString privateKey, byte[] data)
{
if (privateKey == null)
{
throw new ArgumentNullException(nameof(privateKey));
}
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
#if WINDOWS_UWP
var keyBuffer = CryptographicBuffer.DecodeFromBase64String(privateKey.GetString());
var asym = AsymmetricKeyAlgorithmProvider.OpenAlgorithm(AsymmetricAlgorithmNames.RsaPkcs1);
var key = asym.ImportKeyPair(keyBuffer, CryptographicPrivateKeyBlobType.Capi1PrivateKey);
var plainBuffer = CryptographicEngine.Decrypt(key, data.AsBuffer(), null);
byte[] plainBytes;
CryptographicBuffer.CopyToByteArray(plainBuffer, out plainBytes);
return(plainBytes);
#else
var cspParams = new CspParameters {
ProviderType = 1 /* PROV_RSA_FULL */
};
var rsaProvider = new RSACryptoServiceProvider(cspParams);
rsaProvider.ImportCspBlob(Convert.FromBase64String(privateKey.GetString()));
return(rsaProvider.Decrypt(data, false));
#endif
}
/// <summary>
/// Encrypts data
/// </summary>
/// <param name="publicKey">The public key to use to encrypt the data</param>
/// <param name="data">The data to encrypt</param>
/// <returns>The ecrypted data</returns>
/// <exception cref="ArgumentNullException"><paramref name="publicKey"/> is null</exception>
/// <exception cref="ArgumentNullException"><paramref name="data"/> is null</exception>
public static byte[] Encrypt(string publicKey, byte[] data)
{
if (publicKey == null)
{
throw new ArgumentNullException(nameof(publicKey));
}
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
#if WINDOWS_UWP
var keyBuffer = CryptographicBuffer.DecodeFromBase64String(publicKey);
var asym = AsymmetricKeyAlgorithmProvider.OpenAlgorithm(AsymmetricAlgorithmNames.RsaPkcs1);
var key = asym.ImportPublicKey(keyBuffer, CryptographicPublicKeyBlobType.Capi1PublicKey);
var plainBuffer = CryptographicBuffer.CreateFromByteArray(data);
var encryptedBuffer = CryptographicEngine.Encrypt(key, plainBuffer, null);
byte[] encryptedBytes;
CryptographicBuffer.CopyToByteArray(encryptedBuffer, out encryptedBytes);
return(encryptedBytes);
#else
var cspParams = new CspParameters {
ProviderType = 1 /* PROV_RSA_FULL */
};
var rsaProvider = new RSACryptoServiceProvider(cspParams);
rsaProvider.ImportCspBlob(Convert.FromBase64String(publicKey));
return(rsaProvider.Encrypt(data, false));
#endif
}
// if received "01", send logs via notification from HistoryData characteristic
protected override bool WriteRequested(GattSession session, GattWriteRequest request)
{
byte[] receivedWrite;
CryptographicBuffer.CopyToByteArray(request.Value, out receivedWrite);
var receivedWriteHexString = Helpers.ToHexString(request.Value);
QuickLockHistoryService parent = (QuickLockHistoryService)this.ParentService;
if ((request.Value.Length != 1) || (receivedWrite[0] != 0x01))
{
Debug.WriteLine($"Quicklock history cmd WriteRequested, but invalid format: {receivedWriteHexString} ({request.Value.Length})");
//do not update Value, return
OnPropertyChanged(new PropertyChangedEventArgs("InvalidRequest"));
return(true);
}
Debug.WriteLine($"Quicklock history cmd received, sending out logs");
// OnPropertyChanged(new PropertyChangedEventArgs("Logs"));
// set the status characteristic and send notification
parent.QuickLockHistoryData.SendLogs();
return(true);
}
private void Characteristic_ValueChanged(GattCharacteristic sender, GattValueChangedEventArgs args)
{
try
{
byte[] data;
IBuffer buffer = args.CharacteristicValue;
ThermometerResult Result = new ThermometerResult();
CryptographicBuffer.CopyToByteArray(buffer, out data);
string rawdata = "";
// float temperature =(float) (((data[4] & 255) * 256 + (data[3] & 255)) * 0.01);
// decimal temperature = (decimal) ((data[4] & 255) * 256 + (data[3] & 255)) ;
int a = data[4] & 255;
int b = data[3] & 255;
int c = a * 256;
int d = b + c;
decimal f = decimal.Round(((decimal)d / (decimal)100), 1);
//temperature = decimal.Round((temperature / (decimal)100), 1);
for (int i = 0; i < data.Length; i++)
{
rawdata += data[i].ToString() + "-";
}
MainPage.TestresultModel.ThermometerData(f, data.Length > 6? data[6]:0, data[2] == 193, rawdata);
}catch (Exception ex)
{
MainPage.TestresultModel.NotifyStatusMessage?.Invoke("Exception: " + ex.Message, 2);
}
// double temperature = (((0x0e & 0xff) * 256 + (0x78 & 0xff)) * 0.01);
// double t = temperature;
// double t1 = temperature1;
}
static async Task <(int err, byte[] sig)> VerifyUser(string key_name, string contentToSign)
{
if (await KeyCredentialManager.IsSupportedAsync() == false)
{
await(new MessageDialog("KeyCredentialManager not supported")).ShowAsync();
return(ERR_VERIFY_HELLO_NOT_SUPPORTED, null);
}
var key = await KeyCredentialManager.OpenAsync(key_name);
if (key.Status != KeyCredentialStatus.Success)
{
return(CredentialStatusToExitCode(key.Status), null);
}
var buf = CryptographicBuffer.ConvertStringToBinary(contentToSign, BinaryStringEncoding.Utf8);
var signRes = await key.Credential.RequestSignAsync(buf);
if (signRes.Status != KeyCredentialStatus.Success)
{
return(CredentialStatusToExitCode(key.Status), null);
}
byte[] sig;
CryptographicBuffer.CopyToByteArray(signRes.Result, out sig);
return(0, sig);
}
private static byte[] GetCipherKey(string passphrase, int length)
{
List <byte> cipherKey = new List <byte>();
var md5 = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Md5);
{
byte[] passwordBytes = Encoding.UTF8.GetBytes(passphrase);
byte[] buffer;
CryptographicBuffer.CopyToByteArray(md5.HashData(CryptographicBuffer.CreateFromByteArray(passwordBytes.ToArray())), out buffer);
var hash = buffer.AsEnumerable();
cipherKey.AddRange(hash);
while (cipherKey.Count < length)
{
hash = passwordBytes.Concat(hash);
CryptographicBuffer.CopyToByteArray(md5.HashData(CryptographicBuffer.CreateFromByteArray(hash.ToArray())), out buffer);
hash = buffer.AsEnumerable();
cipherKey.AddRange(hash);
}
}
return(cipherKey.Take(length).ToArray());
}
/// <summary>
/// Initializes a new instance of the <see cref="SecureString"/> class from a subarray of
/// <see cref="char"/> objects.
/// </summary>
/// <param name="value">A pointer to an array of System.Char objects.</param>
/// <param name="length">The number of elements of value to include in the new instance.</param>
public unsafe SecureString(char *value, int length)
{
this.Length = length;
this.initialisationVector = Encoding.UTF8.GetBytes(CryptoUtils.BrewPassword(42)).GetBytes(16);
byte[] dataCopy = new byte[length];
var gc = GCHandle.Alloc(dataCopy, GCHandleType.Pinned);
for (int i = 0; i < dataCopy.Length; i++)
{
dataCopy[i] = (byte)*(value + i);
}
// We cannot use our Aes implemtation in here because we will cause a cycling
// dependency... And that will lead to a StackOverflow
var passPhrase = Encoding.UTF8.GetBytes(Debug.HardwareIdentifier.GetHash(HashAlgorithms.Sha512));
var keyMaterial = CryptographicBuffer.CreateFromByteArray(passPhrase);
var toDecryptBuffer = CryptographicBuffer.CreateFromByteArray(dataCopy);
var aes = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesCbcPkcs7);
var symetricKey = aes.CreateSymmetricKey(keyMaterial);
var buffEncrypted = CryptographicEngine.Encrypt(symetricKey, dataCopy.AsBuffer(), initialisationVector.AsBuffer());
CryptographicBuffer.CopyToByteArray(buffEncrypted, out data);
gc.FillWithRandomValues(dataCopy.Length);
}
private void GetTokenResponse(object Sender, IqResultEventArgs e)
{
object[] P = (object[])e.State;
#if WINDOWS_UWP
Certificate Certificate = (Certificate)P[0];
#else
X509Certificate2 Certificate = (X509Certificate2)P[0];
#endif
XmlElement E = e.FirstElement;
if (e.Ok && E != null && E.LocalName == "getTokenChallenge" && E.NamespaceURI == NamespaceProvisioningToken)
{
int SeqNr = XML.Attribute(E, "seqnr", 0);
string Challenge = E.InnerText;
byte[] Bin = System.Convert.FromBase64String(Challenge);
#if WINDOWS_UWP
CryptographicKey Key = PersistedKeyProvider.OpenPublicKeyFromCertificate(Certificate,
Certificate.SignatureHashAlgorithmName, CryptographicPadding.RsaPkcs1V15);
IBuffer Buffer = CryptographicBuffer.CreateFromByteArray(Bin);
Buffer = CryptographicEngine.Decrypt(Key, Buffer, null);
CryptographicBuffer.CopyToByteArray(Buffer, out Bin);
string Response = System.Convert.ToBase64String(Bin);
#else
Bin = Certificate.GetRSAPrivateKey().Decrypt(Bin, RSAEncryptionPadding.Pkcs1);
string Response = System.Convert.ToBase64String(Bin);
#endif
this.client.SendIqGet(this.provisioningServerAddress, "<getTokenChallengeResponse xmlns='" + NamespaceProvisioningToken + "' seqnr='" +
SeqNr.ToString() + "'>" + Response + "</getTokenChallengeResponse>",
this.GetTokenChallengeResponse, P);
}
}
/// <summary>
/// Encrypt using AES/ECB
/// </summary>
/// <param name="message">The message to encrypt</param>
/// <param name="key">The key with which to encrypt</param>
/// <returns>Encrypted data</returns>
private static byte[] EncryptAes(byte[] message, CryptographicKey key)
{
int blockRoundedSize = ((message.Length + 15) / 16) * 16;
byte[] paddedMessage = new byte[blockRoundedSize];
Array.Copy(message, paddedMessage, message.Length);
IBuffer encrypted;
IBuffer iv = null;
IBuffer data = CryptographicBuffer.CreateFromByteArray(paddedMessage);
String algName = SymmetricAlgorithmNames.AesEcb;
// Encrypt the data.
try
{
encrypted = CryptographicEngine.Encrypt(key, data, iv);
}
catch (Exception)
{
Debug.WriteLine("An invalid key size was selected for the given algorithm.\n");
return null;
}
byte[] encryptedMsg = new byte[encrypted.Length];
CryptographicBuffer.CopyToByteArray(encrypted, out encryptedMsg);
return encryptedMsg;
}
public byte[] ComputeHash(byte[] buffer, int offset, int count)
{
#if WINDOWS_STORE
MacAlgorithmProvider provider = MacAlgorithmProvider.OpenAlgorithm(algorithmName);
CryptographicKey hmacKey;
if (Key != null)
{
hmacKey = provider.CreateKey(CryptographicBuffer.CreateFromByteArray(Key));
}
else
{
hmacKey = provider.CreateKey(CryptographicBuffer.GenerateRandom(provider.MacLength));
}
IBuffer hmacValue = CryptographicEngine.Sign(hmacKey, CryptographicBuffer.CreateFromByteArray(buffer));
byte[] result;
CryptographicBuffer.CopyToByteArray(hmacValue, out result);
return(result);
#else
return(hmac.ComputeHash(buffer, offset, count));
#endif
}
public byte[] Sign(byte[] securedInput, object key)
{
//using (var sha = HashAlgorithm)
//{
//var privateKey = Ensure.Type<AsymmetricAlgorithm>(key, "RsaUsingSha alg expects key to be of AsymmetricAlgorithm type.");
AsymmetricKeyAlgorithmProvider provider =
AsymmetricKeyAlgorithmProvider.OpenAlgorithm(AsymmetricAlgorithmNames.RsaSignPkcs1Sha256);
//CryptographicKey cryptographicKey = (CryptographicKey)key;
CryptographicKey cryptographicKey = provider.ImportKeyPair(((CryptographicKey)key).Export(CryptographicPrivateKeyBlobType.BCryptPrivateKey),
CryptographicPrivateKeyBlobType.BCryptPrivateKey);
//provider.ImportKeyPair(null, CryptographicPrivateKeyBlobType.)
IBuffer signedData =
CryptographicEngine.Sign(cryptographicKey, CryptographicBuffer.CreateFromByteArray(securedInput));
byte[] result;
CryptographicBuffer.CopyToByteArray(signedData, out result);
return(result);
//var pkcs1 = new RSAPKCS1SignatureFormatter(privateKey);
//pkcs1.SetHashAlgorithm(hashMethod);
//return pkcs1.CreateSignature(sha.ComputeHash(securedInput));
//}
}
public static byte[] Encrypt(string plainText, string pw, string salt = "")
{
IBuffer pwBuffer = CryptographicBuffer.ConvertStringToBinary(pw, BinaryStringEncoding.Utf8);
IBuffer saltBuffer = CryptographicBuffer.ConvertStringToBinary(salt, BinaryStringEncoding.Utf16LE);
IBuffer plainBuffer = CryptographicBuffer.ConvertStringToBinary(plainText, BinaryStringEncoding.Utf16LE);
// Derive key material for password size 32 bytes for AES256 algorithm
KeyDerivationAlgorithmProvider keyDerivationProvider = Windows.Security.Cryptography.Core.KeyDerivationAlgorithmProvider.OpenAlgorithm("PBKDF2_SHA1");
// using salt and 1000 iterations
KeyDerivationParameters pbkdf2Parms = KeyDerivationParameters.BuildForPbkdf2(saltBuffer, 1000);
// create a key based on original key and derivation parmaters
CryptographicKey keyOriginal = keyDerivationProvider.CreateKey(pwBuffer);
IBuffer keyMaterial = CryptographicEngine.DeriveKeyMaterial(keyOriginal, pbkdf2Parms, 32);
CryptographicKey derivedPwKey = keyDerivationProvider.CreateKey(pwBuffer);
// derive buffer to be used for encryption salt from derived password key
IBuffer saltMaterial = CryptographicEngine.DeriveKeyMaterial(derivedPwKey, pbkdf2Parms, 16);
// display the buffers – because KeyDerivationProvider always gets cleared after each use, they are very similar unforunately
string keyMaterialString = CryptographicBuffer.EncodeToBase64String(keyMaterial);
string saltMaterialString = CryptographicBuffer.EncodeToBase64String(saltMaterial);
SymmetricKeyAlgorithmProvider symProvider = SymmetricKeyAlgorithmProvider.OpenAlgorithm("AES_CBC_PKCS7");
// create symmetric key from derived password key
CryptographicKey symmKey = symProvider.CreateSymmetricKey(keyMaterial);
// encrypt data buffer using symmetric key and derived salt material
IBuffer resultBuffer = CryptographicEngine.Encrypt(symmKey, plainBuffer, saltMaterial);
byte[] result;
CryptographicBuffer.CopyToByteArray(resultBuffer, out result);
return(result);
}
/// <summary>
/// WPRT的RSA私钥解密
/// </summary>
/// <param name="rawData"></param>
/// <returns></returns>
public static string PrivateDecrypt(string rawData)
{
try
{
/*将文本转换成IBuffer*/
IBuffer bufferRawData = CryptographicBuffer.ConvertStringToBinary(rawData, BinaryStringEncoding.Utf8);
/*加密算法提供程序*/
AsymmetricKeyAlgorithmProvider provider = AsymmetricKeyAlgorithmProvider.OpenAlgorithm
(AsymmetricAlgorithmNames.RsaPkcs1);
/*导入私钥*/
string PRIVATE_KEY = "MIICXAIBAAKBgQCJIYvV7IEzHOm4vdgu8RWc9it09ggXCKNAMEtcQM4kXT1mQyEnbEeGVYOyJWTd2jVhpToxMQ4r9p9EKd1bMClAA/KhUjQC/l9YdS3MFAZC65V47Bx6CTad4bZo1E1D6x1rOjQe4lANxWnApwY4QPYGFxEmQD3yNyErh38VlNL2GQIDAQABAoGAFxGmpZFI1uFpTCPbx2HVQfeDrgRprf5NAFJfiyB3zVRGLPrkC+7CRY4DPqfdxRidXFTgakAXYzv05RGp5FpAxf1GBAR6HQxVcntBpNqJUo2UBP+IrXgPFDPdodAl9SWgaHKwc79pCARVdJutm86kRRsy5rjcWpR8HQCYWzk/lmUCQQDcRnenz6CAhMvztS04APlly3uhvLGIVsXkGdsmv7JltRvFmZ/1MqpvAbC6WrzFMlWeFgYz6EyBiqfH6m4CbdJbAkEAn18K40E3r9WzPlbhIAEs2SiY68iZGCmzR/0n6PR48NtFSGsSDRIR632oeftBPfN7W4+kUIehL2gt9RgnRH8bmwJBAJMYK4dQSyoHg/q2nf+sBt9HRsP2sccNyxBLg+EYWhU5H9aQhBTFRLLkOhP3y98TgcETjAjVs2E+KlSB4/yTQckCQH4axVG23CptDQyp0C7z3xnh7sa7DrC45lxzK25Aa6YhyruXxUvEXZuZ7YK/1gsAKz7y9RCnkVoitCK4vvGLJjsCQBbzsW7HwZVe5RMiRsjxX7v0Ng4NnM85tnX0GUmkpuixOpfcq3PsZo7ujcBvJ5IJvbXo4QuuIRKSmxItHI26tkI=";
CryptographicKey privateKey = provider.ImportKeyPair(CryptographicBuffer.DecodeFromBase64String(PRIVATE_KEY));
//解密
IBuffer result = CryptographicEngine.Decrypt(privateKey, bufferRawData, null);
byte[] res;
CryptographicBuffer.CopyToByteArray(result, out res);
return(Encoding.UTF8.GetString(res, 0, res.Length));
}
catch (Exception)
{
return(rawData);
}
}
protected override bool WriteRequested(GattSession session, GattWriteRequest request)
{
byte[] receivedWrite;
CryptographicBuffer.CopyToByteArray(request.Value, out receivedWrite);
var receivedWriteHexString = Helpers.ToHexString(request.Value);
QuickLockMainService parent = (QuickLockMainService)this.ParentService;
//expected: 0066612666 (pcap), or 006661266600000000 (also correct)
if ((request.Value.Length != 5) && (request.Value.Length != 9))
{
Debug.WriteLine($"Smart lock auth WriteRequested, but invalid format: {receivedWriteHexString} ({request.Value.Length})");
//do not update Value, return
OnPropertyChanged(new PropertyChangedEventArgs("InvalidRequest"));
return(true);
}
//check just the first byte and password, ignore rest if provided
if ((receivedWrite[0] != 0x00) || (receivedWrite[1] != password[0]) || (receivedWrite[2] != password[1]) || (receivedWrite[3] != password[2]) || (receivedWrite[4] != password[3]))
{
Debug.WriteLine($"Smart lock auth WriteRequested: INVALID PASSWORD: {receivedWriteHexString} ({request.Value.Length})");
//do not update Value, return
OnPropertyChanged(new PropertyChangedEventArgs("InvalidPin"));
return(true);
}
parent.UpdateAuthenticationState(true);
OnPropertyChanged(new PropertyChangedEventArgs("AuthenticationState"));
return(true);
}
protected override bool WriteRequested(GattSession session, GattWriteRequest request)
{
byte[] receivedWrite;
CryptographicBuffer.CopyToByteArray(request.Value, out receivedWrite);
var receivedWriteHexString = Helpers.ToHexString(request.Value);
if ((request.Value.Length != 6) || (receivedWrite[5] != 0xFF))
{
Debug.WriteLine($"Light Bulb color Write requested, INVALID INPUT: {receivedWriteHexString} ({request.Value.Length})");
//send notification to user
OnPropertyChanged(new PropertyChangedEventArgs("InvalidRequest"));
//do not update Value, return
return(true);
}
// ARGB request
if (receivedWrite[0] == 0xAA)
{
ProcessARGB(receivedWrite);
}
// password protected request
else if (receivedWrite[0] == 0xBE)
{
ProcessPassProtected(receivedWrite);
}
//send to scenario
return(true);
}
static public async Task <bool> createUser(User user, string password)
{
RestController <User> userController = new RestController <User>();
var list = await userController.getObjects(WcfConfig.getUserUrl(user.Email));
if (list.Count != 0)
{
return(false);
}
RestController <Role> roleController = new RestController <Role>();
RestController <Patient> patientController = new RestController <Patient> ();
List <Role> roles = await roleController.getObjects(WcfConfig.getRole(RolesKind.PATIENT));
user.Roles = roles;
IBuffer buff = CryptographicBuffer.ConvertStringToBinary(password, BinaryStringEncoding.Utf8);
HashAlgorithmProvider hap = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha256);
IBuffer shaBuff = hap.HashData(buff);
byte[] pass;
CryptographicBuffer.CopyToByteArray(shaBuff, out pass);
user.Pass = pass;
await userController.insertObject(user, WcfConfig.TableUser);
await patientController.insertObject(new Patient { Pesel = user.Pesel }, WcfConfig.TablePatient);
return(true);
}
/// <summary>
/// helper function that copies the raw data into byte array
/// </summary>
/// <param name="buffer">The raw input buffer</param>
private void SetValue(IBuffer buffer)
{
_rawData = buffer;
CryptographicBuffer.CopyToByteArray(_rawData, out _data);
SetValue();
}
public static byte[] HashData(TpmAlgId algId, byte[] dataToHash)
{
string algName;
switch (algId)
{
case TpmAlgId.Sha1:
algName = HashAlgorithmNames.Sha1;
break;
case TpmAlgId.Sha256:
algName = HashAlgorithmNames.Sha256;
break;
case TpmAlgId.Sha384:
algName = HashAlgorithmNames.Sha384;
break;
case TpmAlgId.Sha512:
algName = HashAlgorithmNames.Sha512;
break;
default:
Globs.Throw <ArgumentException>("AlgId is not a supported hash algorithm");
return(null);
}
HashAlgorithmProvider algProvider = HashAlgorithmProvider.OpenAlgorithm(algName);
IBuffer hashedData = algProvider.HashData(CryptographicBuffer.CreateFromByteArray(dataToHash));
byte[] digest;
CryptographicBuffer.CopyToByteArray(hashedData, out digest);
return(digest);
}
public virtual void NextBytes(byte[] bytes, int start, int len)
{
if (start < 0)
{
throw new ArgumentException("Start offset cannot be negative", "start");
}
if (bytes.Length < (start + len))
{
throw new ArgumentException("Byte array too small for requested offset and length");
}
if (bytes.Length == len && start == 0)
{
NextBytes(bytes);
}
else
{
#if NETFX_CORE
byte[] tmpBuf = null;
var buffer = CryptographicBuffer.GenerateRandom((uint)bytes.Length);
CryptographicBuffer.CopyToByteArray(buffer, out tmpBuf);
#else
byte[] tmpBuf = new byte[len];
NextBytes(tmpBuf);
#endif
Array.Copy(tmpBuf, 0, bytes, start, len);
}
}
void OnValueChanged(GattCharacteristic sender, GattValueChangedEventArgs args)
{
CryptographicBuffer.CopyToByteArray(args.CharacteristicValue, out var value);
if (_cache == null)
{
_cache = value;
}
else
{
var values = new List <byte>(_cache);
values.AddRange(value);
_cache = values.ToArray();
}
if (_cache.Length < 2)
{
return;
}
var code1 = _cache[_cache.Length - 2];
var code2 = _cache[_cache.Length - 1];
if (code1 != 0x0D || code2 != 0x0A)
{
return;
}
var str = Encoding.ASCII.GetString(_cache).TrimEnd();
_cache = null;
DealWithStr(str);
}