public static string GetHash(string input)
{
HashAlgorithm hashAlgorithm = new SHA256CryptoServiceProvider();
byte[] byteValue = System.Text.Encoding.UTF8.GetBytes(input);
byte[] byteHash = hashAlgorithm.ComputeHash(byteValue);
return Convert.ToBase64String(byteHash);
}
// https://docs.microsoft.com/en-us/azure/active-directory/develop/active-directory-certificate-credentials
public async Task <string> GetClientAssertionAsync(string tenantId, string appId)
{
try
{
var cert = await _kvClient.GetCertificateAsync($"https://{_kvName}.vault.azure.net/certificates/func-cred-cert/{_signingKeyId}").ConfigureAwait(false);
//var thumbprint = cert.X509Thumbprint.Aggregate(new StringBuilder(),
// (sb, v) => sb.Append(v.ToString("X2"))).ToString();
var x509 = new System.Security.Cryptography.X509Certificates.X509Certificate2(cert.Cer);
var jwk = JsonWebKeyConverter.ConvertFromX509SecurityKey(new X509SecurityKey(x509));
var token = new JwtSecurityToken(
issuer: appId,
audience: $"https://login.microsoftonline.com/{tenantId}/oauth2/token",
claims: new Claim[]
{
new Claim("jti", Guid.NewGuid().ToString("D")),
new Claim("sub", appId)
},
notBefore: DateTime.UtcNow,
expires: DateTime.UtcNow.AddMinutes(10)
);
var header = Base64UrlEncoder.Encode(JsonConvert.SerializeObject(new Dictionary <string, string>()
{
{ JwtHeaderParameterNames.Alg, "RS256" },
{ JwtHeaderParameterNames.X5t, jwk.X5t }, // "CM2UiOQMKph-SkcT5_Ejki2Kzik"; initially, used B2C to get this value; see https://stackoverflow.microsoft.com/questions/179774
{ JwtHeaderParameterNames.Typ, "JWT" }
}));
var unsignedToken = $"{header}.{token.EncodedPayload}";
var byteData = Encoding.UTF8.GetBytes(unsignedToken);
var hasher = new SHA256CryptoServiceProvider();
var digest = hasher.ComputeHash(byteData);
var signature = await _kvClient.SignAsync($"https://{_kvName}.vault.azure.net/keys/func-cred-cert/{_signingKeyId}", "RS256", digest);
return($"{unsignedToken}.{Base64UrlEncoder.Encode(signature.Result)}");
}
catch (Exception ex)
{
return(ex.Message);
}
}
/// <summary>
/// Verifies that a digital signature is valid by determining the hash value
/// in the signature using the provided public key and comparing it to the hash
/// value of the provided data.
/// </summary>
/// <param name="buffer">The data that was signed.</param>
/// <param name="signature">The signature data to be verified.</param>
/// <param name="rsaProvider">the RSA crypto service provider.</param>
/// <param name="hashAlgorithm">The hash algorithm to use to create the hash value.</param>
/// <returns>True if the signature is valid; otherwise, false.</returns>
public static bool VerifyData(byte[] buffer, byte[] signature, RSACryptoServiceProvider rsaProvider, Nequeo.Cryptography.HashcodeType hashAlgorithm = HashcodeType.SHA512)
{
bool dataVerified = false;
// Select the hash code type.
switch (hashAlgorithm)
{
case HashcodeType.MD5:
// MD5 hashcode.
MD5 md5 = new MD5CryptoServiceProvider();
dataVerified = rsaProvider.VerifyData(buffer, md5, signature);
break;
case HashcodeType.SHA1:
// SHA1 hashcode.
SHA1 sha1 = new SHA1CryptoServiceProvider();
dataVerified = rsaProvider.VerifyData(buffer, sha1, signature);
break;
case HashcodeType.SHA256:
// SHA256 hashcode.
SHA256 sha256 = new SHA256CryptoServiceProvider();
dataVerified = rsaProvider.VerifyData(buffer, sha256, signature);
break;
case HashcodeType.SHA384:
// SHA384 hashcode.
SHA384 sha384 = new SHA384CryptoServiceProvider();
dataVerified = rsaProvider.VerifyData(buffer, sha384, signature);
break;
case HashcodeType.SHA512:
// SHA512 hashcode.
SHA512 sha512 = new SHA512CryptoServiceProvider();
dataVerified = rsaProvider.VerifyData(buffer, sha512, signature);
break;
}
// Return the result.
return(dataVerified);
}
/// <summary>
/// Creates an RSA PKCS#1 v1.5 signature of a SHA256 for the stream.
/// </summary>
private static byte[] RsaPkcs15Sha256_Sign(
ArraySegment <byte> dataToSign,
X509Certificate2 signingCertificate)
{
// extract the private key.
RSACryptoServiceProvider rsa = (RSACryptoServiceProvider)signingCertificate.PrivateKey;
if (rsa == null)
{
throw ServiceResultException.Create(StatusCodes.BadSecurityChecksFailed, "No private key for certificate.");
}
// Instantiate enhanced crypto provider that supports SHA256
const int PROV_RSA_AES = 24;
if (rsa != null && rsa.CspKeyContainerInfo.ProviderType != PROV_RSA_AES && rsa.CspKeyContainerInfo.Exportable)
{
byte[] privateKeyBlob = rsa.ExportCspBlob(true);
var enhCsp = new RSACryptoServiceProvider().CspKeyContainerInfo;
string mKeyContainerName = rsa.CspKeyContainerInfo.KeyContainerName;
var cspparams = new CspParameters
(
enhCsp.ProviderType, enhCsp.ProviderName, mKeyContainerName
);
rsa = new RSACryptoServiceProvider(rsa.KeySize, cspparams);
rsa.ImportCspBlob(privateKeyBlob);
}
// compute the hash of message.
MemoryStream istrm = new MemoryStream(dataToSign.Array, dataToSign.Offset, dataToSign.Count, false);
using (SHA256 hash = new SHA256CryptoServiceProvider())
{
byte[] digest = hash.ComputeHash(istrm);
istrm.Close();
return(rsa.SignHash(digest, "SHA256"));
}
}
public bool checkLogin(string username, string password)
{
Model1 db = new Model1();
SHA256 md5 = new SHA256CryptoServiceProvider();
Byte[] originalBytes = ASCIIEncoding.Default.GetBytes(password);
Byte[] encodedBytes = md5.ComputeHash(originalBytes);
password = BitConverter.ToString(encodedBytes);
List <Customer> login_finded = (from log in db.Customers where log.UserName == username && log.Password == password select log).ToList();
if (login_finded.Count == 1)
{
return(false);
}
else
{
return(true);
}
}
private byte[][] GetHashKeys(string key)
{
byte[][] result = new byte[2][];
Encoding enc = Encoding.UTF8;
SHA256 sha2 = new SHA256CryptoServiceProvider();
byte[] rawKey = enc.GetBytes(key);
byte[] rawIV = enc.GetBytes(key);
byte[] hashKey = sha2.ComputeHash(rawKey);
byte[] hashIV = sha2.ComputeHash(rawIV);
Array.Resize(ref hashIV, 16);
result[0] = hashKey;
result[1] = hashIV;
str_hashKey = BitConverter.ToString(hashKey);
return(result);
}
public static string EncryptTeamGroupSN(int TeamGroupSN)
{
if (TeamGroupSN == 0)
{
return("");
}
else
{
string org = string.Format("SN={0}", TeamGroupSN);
SHA256 sha256 = new SHA256CryptoServiceProvider(); //建立一個SHA256
byte[] source = Encoding.Default.GetBytes(org); //將字串轉為Byte[]
byte[] crypto = sha256.ComputeHash(source); //進行SHA256加密
string result = Convert.ToBase64String(crypto); //把加密後的字串從Byte[]轉為字串
result = result.Replace("+", "");
result = result.Replace("=", "");
result = result.Replace("/", "");
string left = result.Substring(0, 3);
string right = result.Substring(3, 4);
return(string.Format("{0}{1}-{2}", left, TeamGroupSN, right).ToUpper());
}
}
public string encriptarPassword(string input)
{
SHA256CryptoServiceProvider provider = new SHA256CryptoServiceProvider();
byte[] inputBytes = Encoding.UTF8.GetBytes(input);
byte[] hashedBytes = provider.ComputeHash(inputBytes);
StringBuilder output = new StringBuilder();
for (int i = 0; i < hashedBytes.Length; i++)
{
output.Append(hashedBytes[i].ToString("x2").ToLower());
}
return(output.ToString());
}
private void DecryptFiveTimes()
{
byte[] data = Convert.FromBase64String(textBox2.Text);
using (SHA256CryptoServiceProvider SHA256 = new SHA256CryptoServiceProvider())
{
byte[] keys = SHA256.ComputeHash(UTF8Encoding.UTF8.GetBytes(OneTimePass));
using (AesCryptoServiceProvider AES = new AesCryptoServiceProvider()
{
Key = keys, Mode = CipherMode.CBC, Padding = PaddingMode.PKCS7
})
{
string initVector = "#xlZ*SDrxl8iDy%z";
byte[] initVectorBytes = Encoding.ASCII.GetBytes(initVector);
AES.IV = initVectorBytes;
ICryptoTransform transform = AES.CreateDecryptor();
byte[] results = transform.TransformFinalBlock(data, 0, data.Length);
textBox2.Clear();
textBox4.Text = UTF8Encoding.UTF8.GetString(results);
}
}
}
public byte[] createPinHashEnc(string pin, byte[] sharedSecret)
{
// AES256-CBC(sharedSecret, IV=0, LEFT(SHA-256(PIN), 16))
// pinsha = SHA-256(PIN) ->32byte
byte[] pinbyte = Encoding.ASCII.GetBytes(pin);
SHA256 sha = new SHA256CryptoServiceProvider();
byte[] pinsha = sha.ComputeHash(pinbyte);
// pinsha16 = LEFT 16(pinsha)
byte[] pinsha16 = pinsha.ToList().Skip(0).Take(16).ToArray();
// pinHashEnc = AES256-CBC(sharedSecret, IV=0, pinsha16)
string key = Common.BytesToHexString(sharedSecret);
string data = Common.BytesToHexString(pinsha16);
var pinHashEnc = AES256CBC.Encrypt(sharedSecret, pinsha16);
return(pinHashEnc);
}
/// <summary>
/// 密碼加密
/// </summary>
/// <param name="password">使用者輸入密碼</param>
/// <returns>(原密碼+TK)後經過SHA256加密</returns>
public string HashPassword(string password)
{
password = string.Format("{0}{1}", password, TK);
SHA256 sha256 = new SHA256CryptoServiceProvider(); //建立一個SHA256
byte[] source = Encoding.UTF8.GetBytes(password); //將字串轉為Byte[]
byte[] crypto = sha256.ComputeHash(source); //進行SHA256加密
string hashpassword = string.Empty;
foreach (byte bt in crypto)
{
if (crypto.Length != 0)
{
hashpassword = hashpassword + bt.ToString("x2");
}
}
return(hashpassword);
}
// 文字列のハッシュ値（SHA256）を計算・取得する
static string GetHashedTextString(string inputString)
{
// パスワードをUTF-8エンコードでバイト配列として取り出す
byte[] byteValues = Encoding.UTF8.GetBytes(inputString);
// SHA256のハッシュ値を計算する
SHA256 crypto256 = new SHA256CryptoServiceProvider();
byte[] hash256Value = crypto256.ComputeHash(byteValues);
// SHA256の計算結果をUTF8で文字列として取り出す
StringBuilder hashedText = new StringBuilder();
for (int i = 0; i < hash256Value.Length; i++)
{
// 16進の数値を文字列として取り出す
hashedText.AppendFormat("{0:X2}", hash256Value[i]);
}
return(hashedText.ToString());
}
/// <summary>
/// SHA256加密
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public string SHA256_Encryption(string str)//SHA256
{
if (!string.IsNullOrEmpty(str))
{
//實體化SHA256類別
SHA256CryptoServiceProvider SHA256 = new SHA256CryptoServiceProvider();
//將字串編碼成 UTF8 位元組陣列
var bytes = System.Text.Encoding.UTF8.GetBytes(str);
//加密(SHA256) 並且將結果放到ans變數內
string Ans = BitConverter.ToString(SHA256.ComputeHash(bytes));
//Return
return(Ans);
}
else
{
return("");
}
}
public bool Login([FromBody] dynamic _user)
{
IserviceUser spu = new serviceUser();
SHA256 hash = new SHA256CryptoServiceProvider();
Byte[] originalBytes = ASCIIEncoding.Default.GetBytes(_user.password.ToString());
Byte[] encodedBytes = hash.ComputeHash(originalBytes);
_user.password = BitConverter.ToString(encodedBytes);
if (spu.AuthUser(_user.username.ToString(), _user.password.ToString()))
{
FormsAuthentication.SetAuthCookie(_user.username.ToString(), false);
return(true);
}
else
{
return(false);
}
}
private void button1_Click(object sender, EventArgs e)
{
byte[] lpPublicKey = bytBase64_decode(richTextBox3.Text); //GSYCGAATBase64Decode(&lpPublicKey, m_lpPublicKeyString, m_dwPublicKeyStringLength)
byte[] lpEncryptedSecret = bytBase64_decode(richTextBox4.Text); //GSYCGAATBase64Decode(&lpEncryptedSecret, m_strEncryptedSecretString, iLength)
byte[] lpPrivatekey = CS_DH.ComputeKey(BigNumber.FromArray(lpPublicKey)); //lpPublicKeyBN = BN_bin2bn(lpPublicKey, iPublicKeyLength, NULL) + DH_compute_key(lpPrivatekey, lpPublicKeyBN, pDH)
SHA256 sha256 = new SHA256CryptoServiceProvider();
byte[] bytSecureHashAlgorithmCode = sha256.ComputeHash(lpPrivatekey); //GSYCGAATSHA256(bytSecureHashAlgorithmCode, lpPrivatekey, iPrivatekeyLength);
byte[] bytAESKey = new byte[16];
Array.Copy(bytSecureHashAlgorithmCode, 16, bytAESKey, 0, bytAESKey.Length); //memcpy(bytAESKey, &(bytSecureHashAlgorithmCode[GSYCGAAT_SHA256_CODE_LENGTH / 2]), GSYCGAAT_AES_KEY_LENGTH);
SyrisAES.KeySize keysize;
keysize = SyrisAES.KeySize.Bits128;
Array.Copy(bytAESKey, 0, SyrisAES.AESKey, 0, SyrisAES.AESKey.Length);
SyrisAES a = new SyrisAES(keysize);
byte[] outputByteArray = new byte[16];
a.UnAES(lpEncryptedSecret, outputByteArray); //GSYCGAATAES128ECBDecrypt((*lpSecret), lpSecretCipher, GSYCGAAT_AES_UNIT_LENGTH, bytAESKey)
richTextBox5.Text = ToHexString(outputByteArray); //GSYCGAATBinaryToHEXString(strSecretCodeString, m_bytSecretCode, GSYCGAAT_SECRET_LENGTH);
}
private byte[] computeHashKey(string keyData)
{
byte[] keyBytes = Encoding.ASCII.GetBytes(textBoxEncryptionKey.Text);
HashAlgorithm hashAlgorithm;
if (comboBoxHashAlgorithm.Text == "SHA-256")
{
hashAlgorithm = new SHA256CryptoServiceProvider();
return(hashAlgorithm.ComputeHash(keyBytes));
}
else if (comboBoxHashAlgorithm.Text == "SHA-512")
{
hashAlgorithm = new SHA512CryptoServiceProvider();
return(hashAlgorithm.ComputeHash(keyBytes));
}
else
{
hashAlgorithm = new MD5CryptoServiceProvider();
return(hashAlgorithm.ComputeHash(keyBytes));
}
}
public static string HashPass(string password)
{
SHA256 sha = new SHA256CryptoServiceProvider();
//compute hash from the bytes of text
sha.ComputeHash(ASCIIEncoding.ASCII.GetBytes(password));
//get hash result after compute it
byte[] result = sha.Hash;
StringBuilder strBuilder = new StringBuilder();
for (int i = 0; i < result.Length; i++)
{
//change it into 2 hexadecimal digits
//for each byte
strBuilder.Append(result[i].ToString("x2"));
}
return(strBuilder.ToString());
}
private static Byte[] ComputeHash(Byte[] input, Byte[] salt, bool useSalt = true)
{
HashAlgorithm algorithm = new SHA256CryptoServiceProvider();
Byte[] hashedBytes = null;
if (useSalt)
{
// Combine salt and input bytes
Byte[] saltedInput = new Byte[salt.Length + input.Length];
salt.CopyTo(saltedInput, 0);
input.CopyTo(saltedInput, salt.Length);
hashedBytes = algorithm.ComputeHash(saltedInput);
}
else
{
hashedBytes = algorithm.ComputeHash(input);
}
return(hashedBytes);
}
public string D(string password, byte[] encryptedBytes)
{
var sha256CryptoServiceProvider = new SHA256CryptoServiceProvider();
var hash = sha256CryptoServiceProvider.ComputeHash(Encoding.UTF8.GetBytes(password));
var key = new byte[KEY_SIZE];
var iv = new byte[KEY_SIZE];
Buffer.BlockCopy(hash, 0, key, 0, KEY_SIZE);
Buffer.BlockCopy(hash, KEY_SIZE, iv, 0, KEY_SIZE);
using (var cipher = new AesCryptoServiceProvider().CreateDecryptor(key, iv))
using (var source = new MemoryStream(encryptedBytes))
using (var output = new MemoryStream())
{
using (var cryptoStream = new CryptoStream(source, cipher, CryptoStreamMode.Read))
{
cryptoStream.CopyTo(output);
}
return(Encoding.UTF8.GetString(output.ToArray()));
}
}
private string GetHashed(string password)
{
if (string.IsNullOrEmpty(password))
{
throw new ArgumentException("password is null or empty");
}
UTF8Encoding encoder = new UTF8Encoding();
SHA256CryptoServiceProvider sha256hasher = new SHA256CryptoServiceProvider();
byte[] hashed256bytes = sha256hasher.ComputeHash(encoder.GetBytes(password));
StringBuilder output = new StringBuilder();
for (int i = 0; i < hashed256bytes.Length; i++)
{
output.Append(hashed256bytes[i].ToString("X2"));
}
return(output.ToString());
}
/// <summary>
///
/// </summary>
/// <param name="Path"></param>
/// <param name="Uppercase"></param>
/// <param name="Error"></param>
/// <returns></returns>
public static string FILEtoSHA256(string Path, bool Uppercase = false, string Error = Constants.ErrorMessage)
{
try
{
if (File.Exists(Path))
{
using SHA256 SHA256 = new SHA256CryptoServiceProvider();
using FileStream Stream = File.OpenRead(Path);
byte[] Hash = SHA256.ComputeHash(Stream);
return(Uppercase == false?BitConverter.ToString(Hash).Replace("-", "").ToLowerInvariant() : BitConverter.ToString(Hash).Replace("-", "").ToUpperInvariant());
}
else
{
return(Error);
}
}
catch
{
return(Error + Constants.ErrorTitle + "HH-FTS2!)");
}
}
//=============================================================================
//private byte[][] GetHashKeys(string key)
//{
// byte[][] result = new byte[2][];
// Encoding enc = Encoding.UTF8;
// SHA256 sha2 = new SHA256CryptoServiceProvider();
// byte[] rawKey = enc.GetBytes(key);
// byte[] rawIV = enc.GetBytes(key);
// //byte[] rawIV = enc.GetBytes(DateTime.Now.ToString());
// byte[] hashKey = sha2.ComputeHash(rawIV);
// byte[] hashIV = sha2.ComputeHash(rawIV);
// Array.Resize(ref hashIV, 16);
// result[0] = hashKey;
// result[1] = hashIV;
// return result;
//}
private byte[][] GetHashKeys(string key, string dateTime)
{
byte[][] result = new byte[2][];
Encoding enc = Encoding.UTF8;
SHA256 sha2 = new SHA256CryptoServiceProvider();
byte[] rawKey = enc.GetBytes(key);
byte[] rawIV = enc.GetBytes(dateTime);
//byte[] rawIV = enc.GetBytes(DateTime.Now.ToString());
byte[] hashKey = sha2.ComputeHash(rawKey);
byte[] hashIV = sha2.ComputeHash(rawIV);
Array.Resize(ref hashIV, 16);
result[0] = hashKey;
result[1] = hashIV;
return(result);
}
/// <summary>
/// Calculates an integer hash value based on the consistent identity hash of a string.
/// </summary>
/// <param name="text">The string to hash.</param>
/// <returns>An integer hash for the string.</returns>
public static int CalculateIdHash(string text)
{
SHA256 sha = new SHA256CryptoServiceProvider(); // This is one implementation of the abstract class SHA1.
int hash = 0;
try
{
byte[] data = Encoding.Unicode.GetBytes(text);
byte[] result = sha.ComputeHash(data);
for (int i = 0; i < result.Length; i += 4)
{
int tmp = (result[i] << 24) | (result[i + 1] << 16) | (result[i + 2] << 8) | (result[i + 3]);
hash = hash ^ tmp;
}
}
finally
{
sha.Dispose();
}
return(hash);
}
public string aesDecrypt(string sourceHexStr, string cryptKey, string cryptIV)
{
AesCryptoServiceProvider aes = new AesCryptoServiceProvider();
MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider(); // MD5 Hash計算
SHA256CryptoServiceProvider sha256 = new SHA256CryptoServiceProvider(); // SHA256 Hash計算
byte[] key = md5.ComputeHash(Encoding.UTF8.GetBytes(cryptKey)); // 計算AES的key
byte[] iv = md5.ComputeHash(Encoding.UTF8.GetBytes(cryptIV)); // 計算AES的IV
byte[] dataByteArray = Enumerable.Range(0, sourceHexStr.Length)
.Where(x => x % 2 == 0)
.Select(x => Convert.ToByte(sourceHexStr.Substring(x, 2), 16))
.ToArray(); // 將輸入的Hex字串轉為byte
aes.Key = key;
aes.IV = iv;
ICryptoTransform cryptoTransform = aes.CreateDecryptor(aes.Key, aes.IV); // decrypt
byte[] outputData = cryptoTransform.TransformFinalBlock(dataByteArray, 0, dataByteArray.Length); //將decrypt後的array存到output
return(Encoding.UTF8.GetString(outputData)); //轉成UTF的string return
}
private byte[][] GetHashKeys()
{
var key = _encryptionKeyProvider.GetKey();
var result = new byte[2][];
var enc = Encoding.UTF8;
var sha2 = new SHA256CryptoServiceProvider();
var rawKey = enc.GetBytes(key);
var rawIV = enc.GetBytes(key);
var hashKey = sha2.ComputeHash(rawKey);
var hashIV = sha2.ComputeHash(rawIV);
Array.Resize(ref hashIV, 16);
result[0] = hashKey;
result[1] = hashIV;
return(result);
}
private void Photo_Click(object sender, RoutedEventArgs e)
{
try {
GetFileData(out theBackendData.photoFile);
if (theBackendData.hashType == "SHA1")
{
SHA1 sha = new SHA1CryptoServiceProvider();
theBackendData.photo_hash = sha.ComputeHash(theBackendData.photoFile);
}
else if (theBackendData.hashType == "SHA256")
{
SHA256 sha = new SHA256CryptoServiceProvider();
theBackendData.photo_hash = sha.ComputeHash(theBackendData.photoFile);
}
}
catch (Exception ex)
{
MessageBox.Show("Error: Could not read file from disk. Error message: " + ex.Message);
}
}
/// <summary>
/// Signs JWT token using the private key and returns the serialized assertion.
/// </summary>
/// <param name="payload">the JWT payload to sign.</param>
private string CreateAssertionFromPayload(JsonWebSignature.Payload payload)
{
string serializedHeader = CreateSerializedHeader();
string serializedPayload = NewtonsoftJsonSerializer.Instance.Serialize(payload);
StringBuilder assertion = new StringBuilder();
assertion.Append(UrlSafeBase64Encode(serializedHeader))
.Append(".")
.Append(UrlSafeBase64Encode(serializedPayload));
// Sign the header and the payload.
var hashAlg = new SHA256CryptoServiceProvider();
byte[] assertionHash = hashAlg.ComputeHash(Encoding.ASCII.GetBytes(assertion.ToString()));
var signature = UrlSafeBase64Encode(key.SignHash(assertionHash, "2.16.840.1.101.3.4.2.1" /* SHA256 OIG */));
assertion.Append(".").Append(signature);
return(assertion.ToString());
}
/// <summary>
/// 任意のアルゴリズムでハッシュ値を取得し、16 進数表記文字列として返します。
/// </summary>
/// <param name="originalString">
/// ハッシュ値を取得する文字列。
/// </param>
/// <param name="crypto">
/// ハッシュ値を求める任意の <see cref="HashAlgorithm"/>。<c>null</c> の場合、<see cref="SHA256CryptoServiceProvider"/> を利用します。
/// </param>
/// <param name="encoding">
/// ハッシュ値を取得する際の文字コード。<c>null</c> の場合、<see cref="Encoding.UTF8"/> でエンコーディングします。
/// </param>
/// <returns>
/// ハッシュ値を 16 進数表記文字列化した文字列。
/// </returns>
private static string ComputeHashString(this string originalString, HashAlgorithm crypto, Encoding encoding)
{
if (string.IsNullOrEmpty(originalString))
{
return(null);
}
if (encoding == null)
{
encoding = Encoding.UTF8;
}
if (crypto == null)
{
crypto = new SHA256CryptoServiceProvider();
}
byte[] source = encoding.GetBytes(originalString);
return(crypto.ComputeHash(source).ToHexString());
}
public byte[] E(string password, string input)
{
var sha256CryptoServiceProvider = new SHA256CryptoServiceProvider();
var hash = sha256CryptoServiceProvider.ComputeHash(Encoding.UTF8.GetBytes(password));
var key = new byte[KEY_SIZE];
var iv = new byte[KEY_SIZE];
Buffer.BlockCopy(hash, 0, key, 0, KEY_SIZE);
Buffer.BlockCopy(hash, KEY_SIZE, iv, 0, KEY_SIZE);
using (var cipher = new AesCryptoServiceProvider().CreateEncryptor(key, iv))
using (var output = new MemoryStream())
{
using (var cryptoStream = new CryptoStream(output, cipher, CryptoStreamMode.Write))
{
var inputBytes = Encoding.UTF8.GetBytes(input);
cryptoStream.Write(inputBytes, 0, inputBytes.Length);
}
return(output.ToArray());
}
}
internal static string GetInstanceIdInternal(HttpContextBase context, string machineName)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
string identifier = context.Request.ServerVariables["LOCAL_ADDR"];
if (String.IsNullOrEmpty(identifier))
{
identifier = machineName;
}
using (var sha1 = new SHA256CryptoServiceProvider())
{
byte[] tokenBytes = Encoding.Unicode.GetBytes(identifier);
byte[] hashBytes = sha1.ComputeHash(tokenBytes);
return(ConvertToString(hashBytes));
}
}
public static string GetSHA256(this string input)
{
var hash = new SHA256CryptoServiceProvider();
// Convert the input string to a byte array and compute the hash.
byte[] data = hash.ComputeHash(Encoding.UTF8.GetBytes(input));
// Create a new Stringbuilder to collect the bytes
// and create a string.
StringBuilder sb = new StringBuilder();
// Loop through each byte of the hashed data
// and format each one as a hexadecimal string.
for (int i = 0; i < data.Length; i++)
{
sb.Append(data[i].ToString("x2"));
}
// Return the hexadecimal string.
return(sb.ToString());
}
public async Task AnalyzeDocumentAsync(Document document, SyntaxNode bodyOpt, InvocationReasons reasons, CancellationToken cancellationToken)
{
try
{
// do nothing if this document is not currently open.
// to prevent perf from getting too poor for large projects, only examine open documents.
if (!document.IsOpen())
{
return;
}
// Only analyzing C# for now
if (document.Project.Language != LanguageNames.CSharp)
{
return;
}
List<CompilationErrorDetails> errorDetails = await _errorDetailDiscoverer.GetCompilationErrorDetails(document, bodyOpt, cancellationToken).ConfigureAwait(false);
var errorsToReport = _errorDetailCache.GetErrorsToReportAndRecordErrors(document.Id, errorDetails);
if (errorsToReport != null)
{
using (var hashProvider = new SHA256CryptoServiceProvider())
{
foreach (CompilationErrorDetails errorDetail in errorsToReport)
{
var telemetryEvent = TelemetryHelper.TelemetryService.CreateEvent(TelemetryEventPath);
telemetryEvent.SetStringProperty(TelemetryErrorId, errorDetail.ErrorId);
string projectGuid = _projectGuidCache.GetProjectGuidFromProjectPath(document.Project.FilePath);
telemetryEvent.SetStringProperty(TelemetryProjectGuid, string.IsNullOrEmpty(projectGuid) ? UnspecifiedProjectGuid : projectGuid.ToString());
if (!string.IsNullOrEmpty(errorDetail.UnresolvedMemberName))
{
telemetryEvent.SetStringProperty(TelemetryUnresolvedMemberName, GetHashedString(errorDetail.UnresolvedMemberName, hashProvider));
}
if (!string.IsNullOrEmpty(errorDetail.LeftExpressionDocId))
{
telemetryEvent.SetStringProperty(TelemetryLeftExpressionDocId, GetHashedString(errorDetail.LeftExpressionDocId, hashProvider));
}
if (!IsArrayNullOrEmpty(errorDetail.LeftExpressionBaseTypeDocIds))
{
string telemetryBaseTypes = string.Join(";", errorDetail.LeftExpressionBaseTypeDocIds.Select(docId => GetHashedString(docId, hashProvider)));
telemetryEvent.SetStringProperty(TelemetryBaseTypes, telemetryBaseTypes);
}
if (!IsArrayNullOrEmpty(errorDetail.GenericArguments))
{
string telemetryGenericArguments = string.Join(";", errorDetail.GenericArguments.Select(docId => GetHashedString(docId, hashProvider)));
telemetryEvent.SetStringProperty(TelemetryGenericArguments, telemetryGenericArguments);
}
if (!string.IsNullOrEmpty(errorDetail.MethodName))
{
telemetryEvent.SetStringProperty(TelemetryMethodName, GetHashedString(errorDetail.MethodName, hashProvider));
}
if (!IsArrayNullOrEmpty(errorDetail.ArgumentTypes))
{
string telemetryMisMatchedArgumentTypeDocIds = string.Join(";", errorDetail.ArgumentTypes.Select(docId => GetHashedString(docId, hashProvider)));
telemetryEvent.SetStringProperty(TelemetryMismatchedArgumentTypeDocIds, telemetryMisMatchedArgumentTypeDocIds);
}
TelemetryHelper.DefaultTelemetrySession.PostEvent(telemetryEvent);
}
}
}
}
catch (Exception e)
{
// The telemetry service itself can throw.
// So, to be very careful, put this in a try/catch too.
try
{
var exceptionEvent = TelemetryHelper.TelemetryService.CreateEvent(TelemetryExceptionEventPath);
exceptionEvent.SetStringProperty("Type", e.GetTypeDisplayName());
exceptionEvent.SetStringProperty("Message", e.Message);
exceptionEvent.SetStringProperty("StackTrace", e.StackTrace);
TelemetryHelper.DefaultTelemetrySession.PostEvent(exceptionEvent);
}
catch
{
}
}
}
/// <summary>
/// Signs JWT token using the private key and returns the serialized assertion.
/// </summary>
/// <param name="payload">the JWT payload to sign.</param>
private string CreateAssertionFromPayload(JsonWebSignature.Payload payload)
{
string serializedHeader = CreateSerializedHeader();
string serializedPayload = NewtonsoftJsonSerializer.Instance.Serialize(payload);
StringBuilder assertion = new StringBuilder();
assertion.Append(UrlSafeBase64Encode(serializedHeader))
.Append(".")
.Append(UrlSafeBase64Encode(serializedPayload));
// Sign the header and the payload.
var hashAlg = new SHA256CryptoServiceProvider();
byte[] assertionHash = hashAlg.ComputeHash(Encoding.ASCII.GetBytes(assertion.ToString()));
var signature = UrlSafeBase64Encode(key.SignHash(assertionHash, "2.16.840.1.101.3.4.2.1" /* SHA256 OIG */));
assertion.Append(".").Append(signature);
return assertion.ToString();
}
