IBuffer GetNonce()
{
// Security best practises require that an ecryption operation not
// be called more than once with the same nonce for the same key.
// A nonce value can be predictable, but must be unique for each
// secure session.
NonceBytes[0]++;
for (int i = 0; i < NonceBytes.Length - 1; i++)
{
if (NonceBytes[i] == 255)
{
NonceBytes[i + 1]++;
}
}
return(CryptographicBuffer.CreateFromByteArray(NonceBytes));
}
public static byte[] aesCtr(byte[] message, byte[] key, uint counter)
{
SymmetricKeyAlgorithmProvider objAlg = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesCbcPkcs7); // CRT
IBuffer buffKey = CryptographicBuffer.CreateFromByteArray(key);
CryptographicKey ckey = objAlg.CreateSymmetricKey(buffKey);
byte[] ivBytes = new byte[16];
ByteUtil.intToByteArray(ivBytes, 0, (int)counter);
IBuffer buffPlaintext = CryptographicBuffer.CreateFromByteArray(message);
IBuffer buffIV = CryptographicBuffer.CreateFromByteArray(ivBytes);
IBuffer buffEncrypt = CryptographicEngine.Encrypt(ckey, buffPlaintext, buffIV);
byte[] ret;
CryptographicBuffer.CopyToByteArray(buffEncrypt, out ret);
return(ret);
}
public static string CalculateMD5Hash(this byte[] input)
{
#if NETFX_CORE
var alg = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Md5);
IBuffer buff = CryptographicBuffer.CreateFromByteArray(input);
var hashed = alg.HashData(buff);
var res = CryptographicBuffer.EncodeToHexString(hashed);
return(res);
#else
var hash = Cryptography.MD5.Create().ComputeHash(input);
var sb = new StringBuilder();
foreach (var b in hash)
{
sb.Append(b.ToString("x2"));
}
return(sb.ToString());
#endif
}
public async Task <bool> EncryptAsync(string publicKey, IList <byte> dataArray, IList <byte> localPassword)
{
//if (await KeyCredentialManager.IsSupportedAsync())
//{
// var boh = await KeyCredentialManager.RequestCreateAsync(publicKey, KeyCredentialCreationOption.ReplaceExisting);
// if (boh.Status == KeyCredentialStatus.Success)
// {
// var boh2 = await boh.Credential.RequestSignAsync()
// }
//}
//else
{
var dialog = new SettingsPasscodeInputPopup();
var confirm = await dialog.ShowQueuedAsync();
if (confirm != ContentDialogResult.Primary)
{
return(false);
}
var secret = CryptographicBuffer.ConvertStringToBinary(dialog.Passcode, BinaryStringEncoding.Utf8);
var salt = CryptographicBuffer.GenerateRandom(32);
var material = PBKDF2(secret, salt);
var data = CryptographicBuffer.CreateFromByteArray(dataArray.ToArray());
var objAlg = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesEcbPkcs7);
var key = objAlg.CreateSymmetricKey(material);
var encrypt = CryptographicEngine.Encrypt(key, data, null);
var saltString = CryptographicBuffer.EncodeToHexString(salt);
var dataString = CryptographicBuffer.EncodeToHexString(encrypt);
var localPasswordBuffer = CryptographicBuffer.CreateFromByteArray(localPassword.ToArray());
var localPasswordString = CryptographicBuffer.EncodeToHexString(localPasswordBuffer);
var vault = new PasswordVault();
var password = $"{saltString};{dataString};{localPasswordString};{(dialog.IsSimple ? 1 : 2)}";
vault.Add(new PasswordCredential($"{_session}", publicKey, password));
}
return(true);
}
//-------------------------------------------------------------------------------------------------
//--- Generate a OneTime Password from a Guid
//-------------------------------------------------------------------------------------------------
public static async Task <int> OTPFromGuid(Guid TheGuid, bool UseNetworkTime = false)
{
Int64 myTimeStamp;
byte[] mySecret;
byte[] myHmac;
byte[] myData;
int myOffset;
int myOneTimePassword;
Int64 MyUnixTimestamp;
mySecret = StringToBytes(TheGuid.ToString("N"));
#if WINDOWS_UWP
var myCryptprovider = MacAlgorithmProvider.OpenAlgorithm(MacAlgorithmNames.HmacSha1);
#else
HMACSHA1 crypt = new HMACSHA1(mySecret);
#endif
MyUnixTimestamp = await GetUnixTimestamp(UseNetworkTime);
myTimeStamp = Convert.ToInt64(MyUnixTimestamp / 30);
myData = BitConverter.GetBytes(myTimeStamp).Reverse().ToArray();
#if WINDOWS_UWP
var myBuffer = CryptographicBuffer.CreateFromByteArray(myData);
var myKeyBuffer = CryptographicBuffer.CreateFromByteArray(mySecret);
var myKey = myCryptprovider.CreateKey(myKeyBuffer);
var mySignedBuffer = CryptographicEngine.Sign(myKey, myBuffer);
CryptographicBuffer.CopyToByteArray(mySignedBuffer, out myHmac);
#else
myHmac = new HMACSHA1(mySecret).ComputeHash(myData);
#endif
myOffset = myHmac.Last() & 0x0F;
myOneTimePassword = (
((myHmac[myOffset + 0] & 0x7f) << 24) |
((myHmac[myOffset + 1] & 0xff) << 16) |
((myHmac[myOffset + 2] & 0xff) << 8) |
(myHmac[myOffset + 3] & 0xff)
) % 1000000;
return(myOneTimePassword);
}
public static CryptographicKey New([ReadOnlyArray] byte[] x, [ReadOnlyArray] byte[] y, [ReadOnlyArray] byte[] d)
{
if (x.Length != y.Length)
{
throw new ArgumentException("X, Y and Z must be same size");
}
if (x.Length != d.Length)
{
throw new ArgumentException("X and Y must be same size");
}
int partSize = x.Length;
byte[] magic;
string alg;
if (partSize == 32)
{
magic = BCRYPT_ECDSA_PRIVATE_P256_MAGIC;
alg = AsymmetricAlgorithmNames.EcdsaP256Sha256;
}
else if (partSize == 48)
{
magic = BCRYPT_ECDSA_PRIVATE_P384_MAGIC;
alg = AsymmetricAlgorithmNames.EcdsaP384Sha384;
}
else if (partSize == 66)
{
magic = BCRYPT_ECDSA_PRIVATE_P521_MAGIC;
alg = AsymmetricAlgorithmNames.EcdsaP521Sha512;
}
else
{
throw new ArgumentException("Size of X,Y or D must equal to 32, 48 or 66 bytes");
}
byte[] partLength = BitConverter.GetBytes(partSize);
byte[] blob = Arrays.Concat(magic, partLength, x, y, d);
return(AsymmetricKeyAlgorithmProvider.OpenAlgorithm(alg)
.ImportKeyPair(CryptographicBuffer.CreateFromByteArray(blob), CryptographicPrivateKeyBlobType.BCryptPrivateKey));
}
public static byte[] decrypt(byte[] input, byte[] key)
{
/*
* byte[] iv = new byte[IV_LENGTH];
*/
byte[] encryptedData = new byte[input.Length - IV_LENGTH];
// Buffer.BlockCopy(input, 0, iv, 0, iv.Length);
Buffer.BlockCopy(input, IV_LENGTH, encryptedData, 0, encryptedData.Length);
var encryptedBuffer = CryptographicBuffer.CreateFromByteArray(encryptedData);
var aes = SymmetricKeyAlgorithmProvider.OpenAlgorithm(ENC_ALG);
var symmetricKey = aes.CreateSymmetricKey(CryptographicBuffer.CreateFromByteArray(key));
// var ivBuffer = CryptographicBuffer.CreateFromByteArray(iv);
var decryptedBuffer = CryptographicEngine.Decrypt(symmetricKey, encryptedBuffer, null);
byte[] outputBuffer = new byte[decryptedBuffer.Length];
CryptographicBuffer.CopyToByteArray(decryptedBuffer, out outputBuffer);
return(outputBuffer);
}
public Part[] Encrypt([ReadOnlyArray] byte[] aad, [ReadOnlyArray] byte[] plainText, [ReadOnlyArray] byte[] cek)
{
Ensure.BitSize(cek, keySizeBits, string.Format("AesCbcHmacEncryptor expected key of size {0} bits, but was given {1} bits", keySizeBits, cek.Length * 8));
byte[] hmacKey = Arrays.FirstHalf(cek);
byte[] aesKey = Arrays.SecondHalf(cek);
IBuffer iv = CryptographicBuffer.GenerateRandom(16);
SymmetricKeyAlgorithmProvider alg = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesCbcPkcs7);
CryptographicKey key = alg.CreateSymmetricKey(CryptographicBuffer.CreateFromByteArray(aesKey));
byte[] cipherText = Buffer.ToBytes(CryptographicEngine.Encrypt(key, CryptographicBuffer.CreateFromByteArray(plainText), iv));
byte[] authTag = ComputeAuthTag(aad, Buffer.ToBytes(iv), cipherText, hmacKey);
return(new[] { new Part(Buffer.ToBytes(iv)), new Part(cipherText), new Part(authTag) });
}
public byte[] DecryptSsh1(BigInteger e, BigInteger n, BigInteger encryptedChallenge, byte[] sessionId)
{
var decryptKey = GetKey(e, n);
if (decryptKey == null)
{
return(null);
}
RsaCipher cipher = new RsaCipher((RsaKey)decryptKey.Key.Key);
byte[] decryptedChallenge = cipher.Decrypt(encryptedChallenge.ToByteArray().Reverse().ToArray());
var md5 = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Md5);
byte[] response;
CryptographicBuffer.CopyToByteArray(md5.HashData(CryptographicBuffer.CreateFromByteArray(decryptedChallenge.Concat(sessionId).ToArray())), out response);
return(response);
}
private async void sendChallenge(byte[] data)
{
IBuffer buffer = CryptographicBuffer.CreateFromByteArray(data);
DataReader reader = DataReader.FromBuffer(buffer);
DataWriter writer = new DataWriter();
// read packet type
byte packetType = reader.ReadByte();
m_logger.WriteLine("Packet type: " + packetType);
// read pseudonym
byte len = reader.ReadByte();
string pseudonym = reader.ReadString(len);
m_logger.WriteLine("Server pseudonym: " + pseudonym);
byte[] sharedKey = m_member.computeSharedKeyClient(pseudonym, HandshakeParty.SERVER_ROLE);
m_logger.WriteLine("Computed shared key: " + BitConverter.ToString(sharedKey));
// set packet type and write pseudonym
writer.WriteByte((byte)PACKET_TYPE.PKT_TYPE_CHLNG);
writer.WriteByte((byte)m_member.getPseudonym().Length);
writer.WriteString(m_member.getPseudonym());
// prepare challenge
byte[] encChallenge = m_member.getChallenge(sharedKey, out m_challenge);
m_logger.WriteLine("Sending challenge " + m_challenge.ToString() + " to other party");
// send challenge length
len = (byte)encChallenge.Length;
writer.WriteByte(len);
// send challenge
writer.WriteBytes(encChallenge);
byte[] adData = getWriterData(writer);
startPublisher(adData);
await System.Threading.Tasks.Task.Delay(TimeSpan.FromSeconds(3));
// wait for response
startScanning(handleResponse);
}
public static string GetZeroDigestForAlgorithm(string algorithm, int initialValue = 0)
{
uint digestSize = GetDigestSizeForAlgorithm(algorithm);
byte[] zeroDigest = new byte[digestSize];
Array.Clear(zeroDigest, 0, (int)digestSize);
var buffer = CryptographicBuffer.CreateFromByteArray(zeroDigest);
var ret = CryptographicBuffer.EncodeToHexString(buffer);
if (initialValue != 0)
{
string initialString = String.Format("{0:x}", initialValue);
int start = ret.Length - initialString.Length;
ret = ret.Remove(start, initialString.Length).Insert(start, initialString);
}
return(ret);
}
public static String CreateHMAC(String encrypted, String keyBytes)
{
String strAlgName = SampleConfiguration.MacAlg;
MacAlgorithmProvider objMacProv = MacAlgorithmProvider.OpenAlgorithm(strAlgName);
IBuffer buffKeyMaterial = CryptographicBuffer.CreateFromByteArray(System.Text.Encoding.UTF8.GetBytes(keyBytes));
IBuffer bufMsg = CryptographicBuffer.CreateFromByteArray(System.Text.Encoding.UTF8.GetBytes(encrypted));
CryptographicKey hmacKey = objMacProv.CreateKey(buffKeyMaterial);
IBuffer buffHMAC = CryptographicEngine.Sign(hmacKey, bufMsg);
// Verify that the HMAC length is correct for the selected algorithm
if (buffHMAC.Length != objMacProv.MacLength)
{
throw new Exception("Error computing digest");
}
return(CryptographicBuffer.EncodeToBase64String(buffHMAC));
}
//-------------------------------------------------------------------------------------------------
//--- Private constructor to initialise the internal variables
//-------------------------------------------------------------------------------------------------
private StringEncryptor()
{
myRandomGenerator = new Random();
myEncoder = new UTF8Encoding();
myKeyArray = Convert.FromBase64String("Do+Not+Forget+to+Change+this+Now");
#if WINDOWS_UWP
myCryptoAlgorithm = SymmetricKeyAlgorithmProvider.OpenAlgorithm("AES_CBC_PKCS7");
keymaterial = CryptographicBuffer.CreateFromByteArray(myKeyArray);
key = myCryptoAlgorithm.CreateSymmetricKey(keymaterial);
#else
myCryptoAlgorithm = new AesCryptoServiceProvider();
myCryptoAlgorithm.Mode = CipherMode.CBC;
myCryptoAlgorithm.Padding = PaddingMode.PKCS7;
myCryptoAlgorithm.KeySize = 256;
myCryptoAlgorithm.BlockSize = 128;
#endif
}
private static string DecryptPassword(CryptoPassword cp)
{
// Restore Buffer for IV.
var bufferIV = CryptographicBuffer.CreateFromByteArray(cp.IV);
// Restore Buffer for Encrypted Password.
var bufferEncryptedPassword = CryptographicBuffer.CreateFromByteArray(cp.EncryptedPassword);
// Restore Buffer for Key.
var bufferKeyMaterial = CryptographicBuffer.CreateFromByteArray(cp.KeyMaterial);
// Rebuild key.
var key = CreateSymmetricKey(bufferKeyMaterial);
// Get buffer for decrypted Password.
var bufferDecrypt = CryptographicEngine.Decrypt(key, bufferEncryptedPassword, bufferIV);
return(CryptographicBuffer.ConvertBinaryToString(_encoding, bufferDecrypt));
}
internal static string ComputeHmac256(byte[] key, string message)
{
#if RT
MacAlgorithmProvider macAlgorithmProvider = MacAlgorithmProvider.OpenAlgorithm("HMAC_SHA256");
IBuffer keyMaterial = CryptographicBuffer.CreateFromByteArray(key);
CryptographicKey hmacKey = macAlgorithmProvider.CreateKey(keyMaterial);
IBuffer messageBuffer = CryptographicBuffer.ConvertStringToBinary(message, BinaryStringEncoding.Utf8);
IBuffer signedMessage = CryptographicEngine.Sign(hmacKey, messageBuffer);
return(CryptographicBuffer.EncodeToBase64String(signedMessage));
#elif COMMON
return(null);
#else
using (HashAlgorithm hashAlgorithm = new HMACSHA256(key))
{
byte[] messageBuffer = Encoding.UTF8.GetBytes(message);
return(Convert.ToBase64String(hashAlgorithm.ComputeHash(messageBuffer)));
}
#endif
}
/// <summary>
/// /////////////////////////////////////////////////////////////////////////////////////////////
/// </summary>
/// <param name="sender"></param>
////////////////////////////////////////////////////////////////////////////////////////////
private async void btnCharacteristicWriteData1_Click(object sender, EventArgs e)
{
if (!String.IsNullOrEmpty(CharacteristicWriteValue.Text))
{
byte[] bw = { 0 };
bw[0] = (byte)Convert.ToInt32(CharacteristicWriteValue.Text);;
IBuffer writeBuffer = CryptographicBuffer.CreateFromByteArray(bw);
var writeSuccessful = await WriteBufferToSelectedCharacteristicAsync(writeBuffer);
}
else
{
strDevName = "No data to write to device";
printToLog(strDevName);
}
}
/// <summary>
/// Hash message using SHA1
/// </summary>
/// <param name="data">The data to hash</param>
/// <returns>Byte array containing SHA1 hash</returns>
private static byte[] ToSHA1Bytes(byte[] data)
{
IBuffer messageBuffer = CryptographicBuffer.CreateFromByteArray(data);
// Create a HashAlgorithmProvider object that opens SHA1.
HashAlgorithmProvider algProv = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha1);
// Hash the message
IBuffer hashedBuffer = algProv.HashData(messageBuffer);
// Verify that the hash length equals the length specified for the algorithm.
if (hashedBuffer.Length != algProv.HashLength)
{
throw new Exception("There was an error creating the hash");
}
byte[] hashed = new byte[hashedBuffer.Length];
CryptographicBuffer.CopyToByteArray(hashedBuffer, out hashed);
return(hashed);
}
public void TestDeriveSharedSecret()
{
BigInteger pX = BigInteger.Parse("68319caad24e6909cd8b3962d7d0077f4cc9dc348b96da80e9b45de70e6ba30e", NumberStyles.HexNumber);
BigInteger pY = BigInteger.Parse("00d82256dcb4153cb26b9ffc3846660b348767e06422c996b0f1646c8f1aee0051", NumberStyles.HexNumber);
EllipticCurvePoint publicKey = new EllipticCurvePoint(pX, pY);
BigInteger privateKey = BigInteger.Parse("00885d74025021979e140f419966b2119dc4a19f89bae719c14f97bdb594c3e2f5", NumberStyles.HexNumber);
var provider = new EllipticCurveCryptoProvider(EllipticCurveNames.Secp256R1);
EllipticCurvePoint sharedSecret = provider.DeriveSharedSecret(privateKey, publicKey);
IBuffer info = CryptographicBuffer.CreateFromByteArray(new byte[] { 0x01 });
IBuffer salt = null;
var outputKeyMaterial = provider.DerivteKeyWithHkdf(sharedSecret, salt, info);
var strKeyHex = CryptographicBuffer.EncodeToHexString(outputKeyMaterial);
Assert.AreEqual("a6cf3a73f624e73bef4f9760156b039bc2004133207c1186685aa72c2cbdf752".ToUpper(), strKeyHex.ToUpper());
}
public int TransformBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset)
{
if (inputBuffer == null)
{
throw new ArgumentNullException("inputBuffer");
}
if (inputOffset < 0 || inputOffset > inputBuffer.Length)
{
throw new ArgumentOutOfRangeException("inputOffset");
}
if (inputCount < 0 || inputOffset > inputBuffer.Length - inputCount)
{
throw new ArgumentOutOfRangeException("inputCount");
}
if (outputBuffer == null)
{
throw new ArgumentNullException("outputBuffer");
}
if (outputOffset < 0 || outputOffset > outputBuffer.Length - algorithm.BlockLength)
{
throw new ArgumentOutOfRangeException("outputOffset");
}
IBuffer encrypted, data;
byte[] input, output;
input = new byte[inputCount];
Array.Copy(inputBuffer, inputOffset, input, 0, inputCount);
data = CryptographicBuffer.CreateFromByteArray(input);
encrypted = CryptographicEngine.Encrypt(key, data, iv);
CryptographicBuffer.CopyToByteArray(encrypted, out output);
Array.Copy(output, 0, outputBuffer, outputOffset, output.Length);
return(output.Length);
}
public byte[] ComputeHash(Stream stream)
{
int bytesRead = 0;
var cryptoBuffer = CryptographicBuffer.CreateFromByteArray(new byte[AWSSDKUtils.DefaultBufferSize]);
byte[] buffer = new byte[AWSSDKUtils.DefaultBufferSize];
while ((bytesRead = stream.Read(buffer, 0, buffer.Length)) != 0)
{
if (bytesRead != cryptoBuffer.Length)
{
cryptoBuffer = CryptographicBuffer.CreateFromByteArray(new byte[bytesRead]);
}
buffer.CopyTo(0, cryptoBuffer, 0, bytesRead);
_hash.Append(cryptoBuffer);
}
return(_hash.GetValueAndReset().ToArray());
}
private static CryptographicKey GenerateKey()
{
HashAlgorithmProvider algorithm = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha512);
CryptographicHash cryptographicHash = algorithm.CreateHash();
SymmetricKeyAlgorithmProvider provider = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesEcbPkcs7);
byte[] hash = new byte[32];
cryptographicHash.Append(CryptographicBuffer.CreateFromByteArray(Encoding.UTF8.GetBytes("Pa$$w0rd")));
byte[] temp;
CryptographicBuffer.CopyToByteArray(cryptographicHash.GetValueAndReset(), out temp);
Array.Copy(temp, 0, hash, 0, 16);
Array.Copy(temp, 0, hash, 15, 16);
CryptographicKey key = provider.CreateSymmetricKey(CryptographicBuffer.CreateFromByteArray(hash));
return(key);
}
public string GenerateSteamGuardCodeForTime(long time)
{
if (string.IsNullOrEmpty(this.SharedSecret))
{
return("");
}
IBuffer sharedSecretArray = CryptographicBuffer.DecodeFromBase64String(this.SharedSecret);
var timeArray = new byte[8];
time /= 30L;
for (var i = 8; i > 0; i--)
{
timeArray[i - 1] = (byte)time;
time >>= 8;
}
IBuffer data = CryptographicBuffer.CreateFromByteArray(timeArray);
MacAlgorithmProvider hmacsha1 = MacAlgorithmProvider.OpenAlgorithm("HMAC_SHA1");
CryptographicKey hmacKey = hmacsha1.CreateKey(sharedSecretArray);
byte[] hashedData = CryptographicEngine.Sign(hmacKey, data).ToArray();
var codeArray = new byte[5];
try
{
var b = (byte)(hashedData[19] & 0xF);
int codePoint = (hashedData[b] & 0x7F) << 24 | (hashedData[b + 1] & 0xFF) << 16 | (hashedData[b + 2] & 0xFF) << 8 | (hashedData[b + 3] & 0xFF);
for (var i = 0; i < 5; ++i)
{
codeArray[i] = SteamGuardCodeTranslations[codePoint % SteamGuardCodeTranslations.Length];
codePoint /= SteamGuardCodeTranslations.Length;
}
}
catch (Exception)
{
return(null); //Change later, catch-alls are bad!
}
return(Encoding.UTF8.GetString(codeArray, 0, codeArray.Length));
}
// Note: ivec - big-endian, but BigInterger.ctor and BigInteger.ToByteArray return little-endian
public static byte[] AES_ctr128_encrypt(byte[] input, IBuffer key, ref byte[] ivec, ref byte[] ecount_buf, ref uint num)
{
uint n;
var output = new byte[input.Length];
n = num;
var provider = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesEcb);
var keySymmetric = provider.CreateSymmetricKey(key);
for (uint i = 0; i < input.Length; i++)
{
if (n == 0)
{
var ivecBuffer = CryptographicBuffer.CreateFromByteArray(ivec);
var ecountBuffer = CryptographicEngine.Encrypt(keySymmetric, ivecBuffer, null);
CryptographicBuffer.CopyToByteArray(ecountBuffer, out ecount_buf);
Array.Reverse(ivec);
var bi = new System.Numerics.BigInteger(TLUtils.Combine(ivec, new byte[] { 0x00 }));
bi = (bi + 1);
var biArray = bi.ToByteArray();
var b = new byte[16];
//for (var j = 0; j < biArray.Length && j < b.Length; j++)
//{
// b[j] = biArray[j];
//}
System.Buffer.BlockCopy(biArray, 0, b, 0, Math.Min(biArray.Length, b.Length));
//System.Diagnostics.Debug.WriteLine(bi);
Array.Reverse(b);
ivec = b;
}
output[i] = (byte)(input[i] ^ ecount_buf[n]);
n = (n + 1) % 16;
}
num = n;
return(output);
}
private void WriteSignedData(Stream stream, SmtpMessage message, Byte[] body, Byte[] boundary)
{
var mg = message;
Stream mm = stream;
ThrowExceptionIfValueIsNull(mg.From.CryptographicKeyInfo.Base64Content, "Can't sign message unless the From property contains a privateKey.");
mm.Write(ByteData.ContentTypeMultipartSignedProtocolApplicationXpkcs7Signature);
mm.WriteByte(34); // "
mm.Write(boundary);
mm.WriteByte(34); // "
mm.Write(ByteData.NewLine);
mm.Write(ByteData.NewLine);
mm.Write(ByteData.NewLine);
mm.Write(boundary);
mm.Write(ByteData.NewLine);
mm.Write(body);
mm.Write(ByteData.NewLine);
mm.Write(boundary);
mm.Write(ByteData.NewLine);
mm.Write(ByteData.ContentTypeApplicationXpkcs7Signature);
mm.Write(ByteData.NewLine);
mm.Write(ByteData.ContentTransferEncodingIsBase64);
mm.Write(ByteData.NewLine);
mm.Write(ByteData.ContentDispositionAttachmentFileNameIsSmimeP7s);
mm.Write(ByteData.NewLine);
mm.Write(ByteData.NewLine);
var signatureBuffer = Cryptography.ToSignMessage(CryptographicBuffer.CreateFromByteArray(body), mg.From.CryptographicKeyInfo);
Byte[] signature;
CryptographicBuffer.CopyToByteArray(signatureBuffer, out signature);
Base64Converter converter = new Base64Converter(body.Length);
mm.Write(converter.Encode(signature));
mm.Write(ByteData.NewLine);
mm.Write(ByteData.NewLine);
mm.Write(boundary);
mm.Write(Encoding.UTF8.GetBytes("--"));
mm.Write(ByteData.NewLine);
}
/// <summary>
/// Obtiene los datos cifrados con DES
/// </summary>
/// <param name="data">Datos a cifrar</param>
/// <param name="keyString">clave con la que cifrar</param>
/// <returns></returns>
public static byte[] getDES(byte[] data, string keyString)
{
//creamos el proveedor de cifrado
SymmetricKeyAlgorithmProvider symmetricKeyAlgorithmProvider =
SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.DesEcb);
// Declaramos el encoding
BinaryStringEncoding encoding = BinaryStringEncoding.Utf8;
// Creamos un buffer con el contenido de la clave
IBuffer buffkey = CryptographicBuffer.ConvertStringToBinary(keyString, encoding);
//creamos la clave
CryptographicKey cryptographicKey =
symmetricKeyAlgorithmProvider.CreateSymmetricKey(buffkey);
// Creamos un buffer con el contenido a cifrar
IBuffer dataBuffer = CryptographicBuffer.CreateFromByteArray(data);
IBuffer dataToSign = dataBuffer;
if ((data.Length % 8) > 0)
{
int diff = (int)(data.Length % 8);
byte[] buff = new byte[dataBuffer.Length + (8 - diff)];
for (int i = 0; i < buff.Length; i++)
{
buff[i] = 0;
}
Array.Copy(data, buff, data.Length);
dataToSign = CryptographicBuffer.CreateFromByteArray(buff);
}
//ciframos
IBuffer cipherTextBuffered = CryptographicEngine.Encrypt(cryptographicKey, dataToSign, null);
//Se prepara el contenedor del mensaje cifrado
byte[] cipherText = new byte[cipherTextBuffered.Length];
//Se copia el contenido
CryptographicBuffer.CopyToByteArray(cipherTextBuffered, out cipherText);
//se devuelve el contenido cifrado.
return(cipherText);
}
public static string GetAnonymousLoginKey()
{
byte[] radomBytes16 = GenerateRandomByte(16);
byte[] radomByte4 = GenerateRandomByte(4);
int time = (int)(DateTime.Now - new DateTime(1970, 1, 1)).TotalSeconds;
byte[] timeBytes = BitConverter.GetBytes(time);
byte[] timeBytes1 = timeBytes.Concat(radomByte4).ToArray();
byte[] timeBytes2 = timeBytes1.Concat(Param).ToArray();
byte[] arrayOfByte = AESHandle(timeBytes2, radomBytes16);
byte[] arrayOfByte1 = radomBytes16.Concat(arrayOfByte).ToArray();
byte[] arrayOfByte2 = MD5Handle(arrayOfByte1);
byte[] arrayOfByte3 = arrayOfByte2.Concat(radomBytes16).ToArray();
byte[] arrayOfByte4 = arrayOfByte3.Concat(arrayOfByte).ToArray();
string rst = CryptographicBuffer.EncodeToBase64String(CryptographicBuffer.CreateFromByteArray(arrayOfByte4));
return(rst);
}
/// <summary>
/// Hashes the given <paramref name="data"/> with the given <paramref name="algName"/> and returns it.
/// <para/>
/// Source: https://docs.microsoft.com/en-us/uwp/api/windows.security.cryptography.core.hashalgorithmprovider
/// </summary>
/// <param name="data">The data that should get hashed.</param>
/// <param name="algName">The <see cref="HashAlgorithmNames"/> name that should get used for hashing.</param>
/// <returns></returns>
private static byte[] hash(byte[] data, string algName)
{
// Convert the message string to binary data.
IBuffer buffUtf8Msg = CryptographicBuffer.CreateFromByteArray(data);
// Create a HashAlgorithmProvider object.
HashAlgorithmProvider objAlgProv = HashAlgorithmProvider.OpenAlgorithm(algName);
// Hash the message.
IBuffer buffHash = objAlgProv.HashData(buffUtf8Msg);
// Verify that the hash length equals the length specified for the algorithm.
if (buffHash.Length != objAlgProv.HashLength)
{
throw new InvalidOperationException("There was an error creating the hash");
}
// Return the encoded string
return(buffHash.ToArray());
}
public static byte[] aesCbcPkcs5(byte[] message, byte[] key, byte[] iv)
{
SymmetricKeyAlgorithmProvider objAlg = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesCbcPkcs7);
IBuffer buffKey = CryptographicBuffer.CreateFromByteArray(key);
CryptographicKey ckey = objAlg.CreateSymmetricKey(buffKey);
if (message.Length % objAlg.BlockLength != 0)
{
throw new Exception("Invalid ciphertext length");
}
IBuffer buffPlaintext = CryptographicBuffer.CreateFromByteArray(message);
IBuffer buffIV = CryptographicBuffer.CreateFromByteArray(iv);
IBuffer buffEncrypt = CryptographicEngine.Decrypt(ckey, buffPlaintext, buffIV);
byte[] ret;
CryptographicBuffer.CopyToByteArray(buffEncrypt, out ret);
return(ret);
}
/// <summary>
/// Calculates MD5 hash
/// </summary>
/// <param name="data">Input array of bytes</param>
/// <param name="numBytes">Number of bytes in array to use</param>
/// <returns>byte[32] MD5 hash</returns>
public static byte[] MD5(byte[] data, int numBytes)
{
Debug.Assert(numBytes <= data.Length);
byte[] result;
#if NETFX_CORE
HashAlgorithmProvider alg = Windows.Security.Cryptography.Core.HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Md5);
CryptographicHash hash = alg.CreateHash();
IBuffer buffer = CryptographicBuffer.CreateFromByteArray(data);
hash.Append(buffer);
IBuffer hashBuff = hash.GetValueAndReset();
result = hashBuff.ToArray();
#else
MD5 md5 = System.Security.Cryptography.MD5.Create();
result = md5.ComputeHash(data);
#endif
return(result);
} // end of MD5()
public static string Decrypt(byte[] encryptedData, string pw, string salt)
{
IBuffer pwBuffer = CryptographicBuffer.ConvertStringToBinary(pw, BinaryStringEncoding.Utf8);
IBuffer saltBuffer = CryptographicBuffer.ConvertStringToBinary(salt, BinaryStringEncoding.Utf16LE);
IBuffer cipherBuffer = CryptographicBuffer.CreateFromByteArray(encryptedData);
KeyDerivationAlgorithmProvider keyDerivationProvider = Windows.Security.Cryptography.Core.KeyDerivationAlgorithmProvider.OpenAlgorithm("PBKDF2_ SHA1");
KeyDerivationParameters pbkdf2Parms = KeyDerivationParameters.BuildForPbkdf2(saltBuffer, 1000);
CryptographicKey keyOriginal = keyDerivationProvider.CreateKey(pwBuffer);
IBuffer keyMaterial = CryptographicEngine.DeriveKeyMaterial(keyOriginal, pbkdf2Parms, 32);
CryptographicKey derivedPwKey = keyDerivationProvider.CreateKey(pwBuffer);
IBuffer saltMaterial = CryptographicEngine.DeriveKeyMaterial(derivedPwKey, pbkdf2Parms, 16);
string keyMaterialString = CryptographicBuffer.EncodeToBase64String(keyMaterial);
string saltMaterialString = CryptographicBuffer.EncodeToBase64String(saltMaterial);
SymmetricKeyAlgorithmProvider symProvider = SymmetricKeyAlgorithmProvider.OpenAlgorithm("AES_CBC_PKCS7");
CryptographicKey symmKey = symProvider.CreateSymmetricKey(keyMaterial);
IBuffer resultBuffer = CryptographicEngine.Decrypt(symmKey, cipherBuffer, saltMaterial);
string result = CryptographicBuffer.ConvertBinaryToString(BinaryStringEncoding.Utf16LE, resultBuffer);
return(result);
}
