public static new Streebog512 Create(string algorithmName) => (Streebog512)CryptoConfig.CreateFromName(algorithmName);
internal static bool IsSupportedAlgorithm([NotNull] this SecurityKey key, [NotNull] string algorithm)
{
// Note: SecurityKey currently doesn't support IsSupportedAlgorithm.
// To work around this limitation, this static extension tries to
// determine whether the given security key supports the specified
// algorithm via CryptoConfig when available or using a pre-defined table.
var symmetricSecurityKey = key as SymmetricSecurityKey;
if (symmetricSecurityKey != null)
{
#if DNX451
try {
var instance = CryptoConfig.CreateFromName(algorithm);
if (instance is SymmetricAlgorithm || instance is KeyedHashAlgorithm)
{
return(true);
}
}
// Ignore the InvalidOperationException thrown by CryptoConfig.
catch (InvalidOperationException) { }
#endif
switch (algorithm)
{
case SecurityAlgorithms.HmacSha256Signature:
case SecurityAlgorithms.HMAC_SHA256:
case SecurityAlgorithms.HMAC_SHA384:
case SecurityAlgorithms.HMAC_SHA512:
return(true);
case SecurityAlgorithms.Aes128Encryption:
case SecurityAlgorithms.Aes128KeyWrap:
return(symmetricSecurityKey.KeySize >= 128 &&
symmetricSecurityKey.KeySize <= 256);
case SecurityAlgorithms.Aes192Encryption:
case SecurityAlgorithms.Aes192KeyWrap:
return(symmetricSecurityKey.KeySize >= 192 &&
symmetricSecurityKey.KeySize <= 256);
case SecurityAlgorithms.Aes256Encryption:
case SecurityAlgorithms.Aes256KeyWrap:
return(symmetricSecurityKey.KeySize == 256);
default:
return(false);
}
}
else if (key is AsymmetricSecurityKey)
{
#if DNX451
try {
var instance = CryptoConfig.CreateFromName(algorithm);
if (instance is AsymmetricAlgorithm || instance is SignatureDescription)
{
return(true);
}
}
// Ignore the InvalidOperationException thrown by CryptoConfig.
catch (InvalidOperationException) { }
#endif
switch (algorithm)
{
case SecurityAlgorithms.RsaSha256Signature:
case SecurityAlgorithms.RsaSha384Signature:
case SecurityAlgorithms.RsaSha512Signature:
case SecurityAlgorithms.RSA_SHA256:
case SecurityAlgorithms.RSA_SHA384:
case SecurityAlgorithms.RSA_SHA512:
case SecurityAlgorithms.RsaOaepKeyWrap:
case SecurityAlgorithms.RsaV15KeyWrap: {
if (key is RsaSecurityKey)
{
return(true);
}
var x509SecurityKey = key as X509SecurityKey;
if (x509SecurityKey != null)
{
#if DNX451
return(x509SecurityKey.Certificate.PublicKey.Key is RSA);
#else
return(x509SecurityKey.Certificate.GetRSAPublicKey() != null);
#endif
}
return(false);
}
#if DNXCORE50
// Note: the ECDsa type exists on .NET 4.5.1 but not on Mono 4.3.
// To prevent this code path from throwing an exception
// on Mono, the following algorithms are ignored on DNX451.
case SecurityAlgorithms.ECDSA_SHA256:
case SecurityAlgorithms.ECDSA_SHA384:
case SecurityAlgorithms.ECDSA_SHA512: {
if (key is ECDsaSecurityKey)
{
return(true);
}
var x509SecurityKey = key as X509SecurityKey;
if (x509SecurityKey != null)
{
return(x509SecurityKey.Certificate.GetECDsaPublicKey() != null);
}
return(false);
}
#endif
default:
return(false);
}
}
// If the security key doesn't inherit from SymmetricSecurityKey
// or AsymmetricSecurityKey, it must be treated as an invalid key
// and false must be returned to indicate that it cannot be used
// with the specified algorithm.
return(false);
}
/// <summary>
/// Verifies the manifest against it's recorded signature
/// </summary>
/// <returns><c>true</c>, if manifest was verifyed, <c>false</c> otherwise.</returns>
/// <param name="manifest">Manifest.</param>
protected bool VerifyPackage(AppletPackage package)
{
// First check: Hash - Make sure the HASH is ok
if (Convert.ToBase64String(SHA256.Create().ComputeHash(package.Manifest)) != Convert.ToBase64String(package.Meta.Hash))
{
throw new InvalidOperationException($"Package contents of {package.Meta.Id} appear to be corrupt!");
}
if (package.Meta.Signature != null)
{
this.m_tracer.TraceInfo("Will verify package {0}", package.Meta.Id.ToString());
// Get the public key - first, is the publisher in the trusted publishers store?
var x509Store = new X509Store(StoreName.TrustedPublisher, StoreLocation.LocalMachine);
try
{
x509Store.Open(OpenFlags.ReadOnly);
var cert = x509Store.Certificates.Find(X509FindType.FindByThumbprint, package.Meta.PublicKeyToken, false);
// Not in the central store, perhaps the cert is embedded?
if (cert.Count == 0)
{
// Embedded CER
if (package.PublicKey != null)
{
// Attempt to load
cert = new X509Certificate2Collection(new X509Certificate2(package.PublicKey));
// The embedded certificate is not in trusted publisher store and/or not valid
if (!ApplicationContext.Current.Configuration.GetSection <AppletConfigurationSection>().Security.TrustedPublishers.Contains(cert[0].Thumbprint) && !cert[0].Verify())
{
if (!ApplicationContext.Current.Confirm(String.Format(Strings.locale_untrustedPublisherPrompt, package.Meta.Names.First().Value, this.ExtractDNPart(cert[0].Subject, "CN"))))
{
return(false);
}
else
{
ApplicationContext.Current.Configuration.GetSection <AppletConfigurationSection>().Security.TrustedPublishers.Add(cert[0].Thumbprint);
ApplicationContext.Current.SaveConfiguration();
}
}
}
else
{
this.m_tracer.TraceError($"Cannot find public key of publisher information for {package.Meta.PublicKeyToken} or the local certificate is invalid");
throw new SecurityException(Strings.locale_invalidSignature);
}
}
// Certificate is not yet valid or expired
if ((cert[0].NotAfter <DateTime.Now || cert[0].NotBefore> DateTime.Now) &&
!ApplicationContext.Current.Confirm(String.Format(Strings.locale_certificateExpired, this.ExtractDNPart(cert[0].Subject, "CN"), cert[0].NotAfter)))
{
this.m_tracer.TraceError($"Cannot find public key of publisher information for {package.Meta.PublicKeyToken} or the local certificate is invalid");
throw new SecurityException(Strings.locale_invalidSignature);
}
RSACryptoServiceProvider rsa = cert[0].PublicKey.Key as RSACryptoServiceProvider;
var retVal = rsa.VerifyData(package.Manifest, CryptoConfig.MapNameToOID("SHA1"), package.Meta.Signature);
if (!retVal)
{
throw new SecurityException(Strings.locale_invalidSignature);
}
return(retVal);
}
finally
{
x509Store.Close();
}
}
else if (ApplicationContext.Current.Configuration.GetSection <AppletConfigurationSection>().Security.AllowUnsignedApplets)
{
return(ApplicationContext.Current.Confirm(String.Format(Strings.locale_unsignedAppletPrompt, package.Meta.Names.First().Value)));
}
else
{
this.m_tracer.TraceError("Package {0} v.{1} (publisher: {2}) is not signed and cannot be installed", package.Meta.Id, package.Meta.Version, package.Meta.Author);
throw new SecurityException(String.Format(Strings.locale_unsignedAppletsNotAllowed, package.Meta.Id));
}
}
public static string CreateSignature(string subject, string storeNameValue, string storeLocationValue)
{
SHA1Managed sha1 = null;
RSACryptoServiceProvider csp = null;
//try
//{
// This would be the subject which should be part of header, please note that this string is used for find the certificate on client machine
//string subject = "Workspace.ceb.com";
// current (universal) date time value has to be attached while creating the signature
string message = string.Format("{0}{1}", Utils.Constants.WorkspaceSignature, string.Format("{0:d/M/yyyyHH:mm}", DateTime.Now.ToUniversalTime()));
message = message.Replace("-", "/");
// Find the certificate we'll use to sign
AsymmetricAlgorithm privateKey = null;
//Get Private Key from Applciation object. If its null, then open the X509 store and get private key.
//privateKey = HttpContext.Current.Application[Utils.Constants.PrivateKeyFromCertificate] as AsymmetricAlgorithm;
//if (privateKey == null)
//{
StoreName storeName;
StoreLocation storeLocation;
//try to parse
Enum.TryParse(storeNameValue, true, out storeName);
if (!Enum.IsDefined(typeof(StoreName), storeName)) //If it was failed to parse then the variable storeName is not set as defined
{
throw new Exception(Utils.Constants.CertStoreNameNotFoundExceptionMessage);
}
//try to parse
Enum.TryParse(storeLocationValue, true, out storeLocation);
if (!Enum.IsDefined(typeof(StoreLocation), storeLocation)) //If it was failed to parse then the variable storeLocation is not set as defined
{
throw new Exception(Utils.Constants.CertStoreLocationNotFoundExceptionMessage);
}
// Access Personal (MY) certificate store of current user
X509Store my = new X509Store(storeName, storeLocation);
my.Open(OpenFlags.ReadOnly);
foreach (X509Certificate2 cert in my.Certificates)
{
if (cert.Subject.Contains(subject))
{
// We found it.
privateKey = cert.PrivateKey;
break;
}
}
//}
// Get its associated CSP and private key
csp = (RSACryptoServiceProvider)privateKey;
if (csp == null)
{
//throw new Exception(Utils.Constants.CertNotFoundExceptionMessage);
}
// Hash the data
sha1 = new SHA1Managed();
UnicodeEncoding encoding = new UnicodeEncoding();
byte[] data = encoding.GetBytes(message);
byte[] hash = sha1.ComputeHash(data);
// Sign the hash
byte[] encryptedData = csp.SignHash(hash, CryptoConfig.MapNameToOID("SHA1"));
return(Convert.ToBase64String(encryptedData));
}
public bool VerifyData(byte[] dataToCheck, byte[] signedData)
{
var key = (RSACryptoServiceProvider)Certyficate.PublicKey.Key;
return(key.VerifyData(dataToCheck, CryptoConfig.MapNameToOID("SHA256"), signedData));
}
public static string ToMd5(string clearString)
{
byte[] bytes = Encoding.Unicode.GetBytes(clearString);
return(BitConverter.ToString(((HashAlgorithm)CryptoConfig.CreateFromName("MD5")).ComputeHash(bytes)));
}
public static void AddAlgorithm_EmptyString_Throws()
{
AssertExtensions.Throws <ArgumentException>(null, () => CryptoConfig.AddAlgorithm(typeof(CryptoConfigTests), string.Empty));
}
/// <summary>
/// Initializes a new instance of the <see cref="SymmetricCryptoService"/> class.
/// </summary>
/// <param name="options">The options.</param>
public CryptoHash(string key, HashAlgorithm algorithm)
{
this._encryptionOptions = new CryptoConfig(true, key);
this._algorithm = algorithm;
}
public static void AddAlgorithm_CreateFromName_ReturnsMapped()
{
CryptoConfig.AddAlgorithm(typeof(AesCryptoServiceProvider), "AESFancy");
Assert.Equal(typeof(AesCryptoServiceProvider).FullName, CryptoConfig.CreateFromName("AESFancy").GetType().FullName);
}
public static void AddAlgorithm_NonVisibleType()
{
AssertExtensions.Throws <ArgumentException>("algorithm", () => CryptoConfig.AddAlgorithm(typeof(AESFancy), "AESFancy"));
}
public static void AddOID_NullNames_Throws()
{
AssertExtensions.Throws <ArgumentNullException>("names", () => CryptoConfig.AddOID(string.Empty, null));
}
public static void AddOID_NullOid_Throws()
{
AssertExtensions.Throws <ArgumentNullException>("oid", () => CryptoConfig.AddOID(null, string.Empty));
}
public static void AddOID_EmptyNamesArray()
{
CryptoConfig.AddOID("1.3.14.3.2.28", new string[0]);
// There is no verifiable behavior in this case. We only check that we don't throw.
}
/// <summary>
/// Initializes a new instance of the <see cref="SymmetricCryptoService"/> class.
/// </summary>
/// <param name="options">The options.</param>
public CryptoSym(string key, SymmetricAlgorithm algorithm)
{
_encryptionOptions = new CryptoConfig(true, key);
_algorithm = algorithm;
}
public static void AddAlgorithm_EmptyNamesArray()
{
CryptoConfig.AddAlgorithm(typeof(AesCryptoServiceProvider), new string[0]);
// There is no verifiable behavior in this case. We only check that we don't throw.
}
/// <summary>
/// Parses a string in the format of <see cref="Encode" /> and returns an <see cref="EncryptedItem" /> with the
/// component parts.
/// </summary>
/// <param name="input">a string from a prior <see cref="Encode" /></param>
/// <returns>a populated <see cref="EncryptedItem" /></returns>
public static EncryptedItem Parse(string input)
{
Match m = _prefixPattern.Match(input);
if (! m.Success)
{
throw new CryptographicException("the ciphertext string does not begin with a suitably formatted algorithm marker, e.g. {AES-256-CBC}");
}
var config = new CryptoConfig(m.Groups[1].Value, int.Parse(m.Groups[2].Value));
if (m.Groups[3].Success)
{
config.Mode = (CipherMode) Enum.Parse(typeof (CipherMode), m.Groups[3].Value);
}
if (m.Groups[4].Success)
{
config.Padding = (PaddingMode) Enum.Parse(typeof (PaddingMode), m.Groups[4].Value);
}
string remainder = input.Substring(m.Length);
return new EncryptedItem(config, Convert.FromBase64String(remainder));
}
public static void AddAlgorithm_NullAlgorithm_Throws()
{
AssertExtensions.Throws <ArgumentNullException>("algorithm", () => CryptoConfig.AddAlgorithm(null, string.Empty));
}
public static void AddOID_EmptyString_Throws()
{
AssertExtensions.Throws <ArgumentException>(null, () => CryptoConfig.AddOID(string.Empty, string.Empty));
}
public static void AddAlgorithm_NullNames_Throws()
{
AssertExtensions.Throws <ArgumentNullException>("names", () => CryptoConfig.AddAlgorithm(typeof(CryptoConfigTests), null));
}
public static X509Chain Create()
{
return((X509Chain)CryptoConfig.CreateFromName("X509Chain"));
}
private void button1_Click(object sender, EventArgs e)
{
if (textBox1.Text == "" || textBox2.Text == "" || textBox3.Text == "")
{
MessageBox.Show("Fields cannot be blank!");
}
else
{
#region AES
string UserEncrypted = AesCryp.Encrypt(textBox1.Text);
string GenerateAesKey = RandomString();
AesCryp.Key = GenerateAesKey;
string PasswordEncrypted = AesCryp.Encrypt(textBox2.Text);
string ResetEncrypted = AesCryp.Encrypt(textBox3.Text);
AesCryp.Key = "5j2gfx0y5m9mb1x6ejtz384p9b4hf5nq";
string EncryptedAesKey = AesCryp.Encrypt(GenerateAesKey);
#endregion AES
#region MD5
string username = UserEncrypted;
byte[] encodedPassword = new UTF8Encoding().GetBytes(username);
byte[] hash = ((HashAlgorithm)CryptoConfig.CreateFromName("MD5")).ComputeHash(encodedPassword);
string encoded = BitConverter.ToString(hash).Replace("-", string.Empty).ToLower();
#endregion MD5
if (Directory.Exists(@"Users\" + encoded))
{
#region UserExistsWindow
MessageBox.Show("User Already Exists");
#endregion UserExistsWindow
}
else
{
#region CreateSaltFile
Directory.CreateDirectory(@"Users\" + encoded);
int mySalt = SaltHash.CreateRandomSalt();
string stringsalt = mySalt.ToString();
string saltencrypted = AesCryp.Encrypt(stringsalt);
File.WriteAllText("Users\\" + encoded + "\\salt.txt", saltencrypted);
#endregion CreateSaltFile
#region SaltHash
string readSalt = File.ReadAllText("Users\\" + encoded + "\\salt.txt");
string decryptSalt = AesCryp.Decrypt(readSalt);
int x = 0;
Int32.TryParse(decryptSalt, out x);
SaltHash usr = new SaltHash(UserEncrypted, x);
string strHashedUsername = usr.ComputeSaltedHash();
SaltHash pwd = new SaltHash(PasswordEncrypted, x);
string strHashedPassword = pwd.ComputeSaltedHash();
SaltHash rst = new SaltHash(ResetEncrypted, x);
string strHashedReset = rst.ComputeSaltedHash();
string encryptUsername = AesCryp.Encrypt(strHashedUsername);
#endregion SaltHash
#region Create&Write
File.WriteAllText("Users\\" + encoded + "\\password.txt", strHashedPassword);
File.WriteAllText("Users\\" + encoded + "\\reset.txt", strHashedReset);
File.AppendAllText("Users\\" + encoded + "\\salt.txt", Environment.NewLine);
File.AppendAllText("Users\\" + encoded + "\\salt.txt", EncryptedAesKey);
File.AppendAllText("Users\\" + encoded + "\\salt.txt", Environment.NewLine);
File.AppendAllText("Users\\" + encoded + "\\salt.txt", encryptUsername);
Directory.CreateDirectory("Users\\" + encoded + "\\Combos");
MessageBox.Show("User Created Succefully!");
#endregion Create&Write
}
}
}
new static public RC2 Create(String AlgName)
{
return((RC2)CryptoConfig.CreateFromName(AlgName));
}
internal GenericHashResult ComputeFileHash(Enums.HashAlgorithm hashAlgorithm, string filePathToComputeHash,
long offset = 0, long count = 0)
{
if (!File.Exists(filePathToComputeHash))
{
return(new GenericHashResult()
{
Success = false,
Message = $"{MessageStrings.Common_FileNotFound} \"{filePathToComputeHash}\"."
});
}
GenericHashResult result = null;
HashAlgorithm hashAlg = null;
#if CORERT
switch (hashAlgorithm)
{
case Enums.HashAlgorithm.MD5:
hashAlg = MD5.Create();
break;
case Enums.HashAlgorithm.SHA1:
hashAlg = SHA1.Create();
break;
case Enums.HashAlgorithm.SHA256:
hashAlg = SHA256.Create();
break;
case Enums.HashAlgorithm.SHA384:
hashAlg = SHA384.Create();
break;
case Enums.HashAlgorithm.SHA512:
hashAlg = SHA512.Create();
break;
case Enums.HashAlgorithm.BCrypt:
default:
break;
}
#else
hashAlg = (HashAlgorithm)CryptoConfig.CreateFromName(hashAlgorithm.ToString());
#endif
try
{
byte[] hash = null;
using (var fStream = new FileStream(filePathToComputeHash, FileMode.Open, FileAccess.Read, FileShare.None))
{
//offset = (offset == 0 ? 0 : offset);
count = (count == 0 ? fStream.Length : count);
fStream.Position = offset;
var buffer = new byte[(1024 * 4)];
var amount = (count - offset);
using (hashAlg)
{
var percentageDone = 0;
while (amount > 0)
{
var bytesRead = fStream.Read(buffer, 0, (int)Math.Min(buffer.Length, amount));
if (bytesRead > 0)
{
amount -= bytesRead;
if (amount > 0)
{
hashAlg.TransformBlock(buffer, 0, bytesRead, buffer, 0);
}
else
{
hashAlg.TransformFinalBlock(buffer, 0, bytesRead);
}
var tmpPercentageDone = (int)(fStream.Position * 100 / count);
if (tmpPercentageDone != percentageDone)
{
percentageDone = tmpPercentageDone;
RaiseOnHashProgress(percentageDone, (percentageDone != 100 ? $"Computing hash ({percentageDone}%)..." : $"Hash computed ({percentageDone}%)."));
}
}
else
{
throw new InvalidOperationException();
}
}
hash = hashAlg.Hash;
}
}
result = new GenericHashResult()
{
Success = true,
Message = MessageStrings.Hash_ComputeSuccess,
HashString = Encoding.HighPerformanceHexadecimal.ToHexString(hash),
HashBytes = hash
};
}
catch (Exception ex)
{
result = new GenericHashResult()
{
Success = false,
Message = ex.ToString()
};
}
return(result);
}
static public AsymmetricAlgorithm Create(String algName)
{
return((AsymmetricAlgorithm)CryptoConfig.CreateFromName(algName));
}
internal GenericHashResult ComputeHash(Enums.HashAlgorithm hashAlgorithm, byte[] bytesToComputeHash,
int offset = 0, int count = 0)
{
if (bytesToComputeHash == null || bytesToComputeHash.Length <= 0)
{
return(new GenericHashResult()
{
Success = false,
Message = MessageStrings.Hash_InputRequired
});
}
GenericHashResult result = null;
try
{
HashAlgorithm hashAlg = null;
#if CORERT
switch (hashAlgorithm)
{
case Enums.HashAlgorithm.MD5:
hashAlg = MD5.Create();
break;
case Enums.HashAlgorithm.SHA1:
hashAlg = SHA1.Create();
break;
case Enums.HashAlgorithm.SHA256:
hashAlg = SHA256.Create();
break;
case Enums.HashAlgorithm.SHA384:
hashAlg = SHA384.Create();
break;
case Enums.HashAlgorithm.SHA512:
hashAlg = SHA512.Create();
break;
case Enums.HashAlgorithm.BCrypt:
default:
break;
}
#else
hashAlg = (HashAlgorithm)CryptoConfig.CreateFromName(hashAlgorithm.ToString());
#endif
using (hashAlg)
{
//offset = (offset == 0 ? 0 : offset);
count = (count == 0 ? bytesToComputeHash.Length : count);
var hash = hashAlg.ComputeHash(bytesToComputeHash, offset, count);
result = new GenericHashResult()
{
Success = true,
Message = MessageStrings.Hash_ComputeSuccess,
HashBytes = hash,
HashString = Encoding.HighPerformanceHexadecimal.ToHexString(hash)
};
}
}
catch (Exception ex)
{
return(new GenericHashResult()
{
Success = false,
Message = ex.ToString()
});
}
return(result);
}
public bool verifyotp()
{
if (skipotp)
{
return(true);
}
// check if is a fmuv2 and bootloader >= 4 else fail;
// 9 = fmuv2
// 5 = px4 1.x
if (board_type == 9) // &&up.bl_rev >= 4
{
try
{
// get the device sn
byte[] sn = __get_sn();
string line = "";
line = "SN: ";
for (int s = 0; s < sn.Length; s += 1)
{
line += sn[s].ToString("X2");
}
print(line);
// 20 bytes - sha1
Array.Resize(ref sn, 20);
if (ByteArrayCompare(sn, new byte[] { 0x00, 0x23, 0x00, 0x30, 0x35, 0x32, 0x47, 0x18, 0x36, 0x34, 0x30, 0x32, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }))
{
print("Libre bootloader");
}
object obj = new otp();
byte[] test = __read_otp();
ByteArrayToStructure(test, ref obj);
otp otp = (otp)obj;
print("id: " + otp.id_type.ToString("X"));
print("vid: " + otp.vid.ToString("X"));
print("pid: " + otp.pid.ToString("X"));
if (otp.h1 == 'P' &&
otp.h2 == 'X' &&
otp.h3 == '4' &&
otp.h4 == '\0')
{
// no vendor checks yet
byte[] sig = otp.signature;
line = "";
for (int s = 0; s < 512; s += 1)
{
line += test[s].ToString("X2");
if (s % 16 == 15)
{
print(line);
line = "";
}
}
/*
* byte[] PEMbuffer = Convert.FromBase64String(@"");
*/
// RSACryptoServiceProvider rsa = DecodeRsaPrivateKey(PEMbuffer);
// RSAParameters rsapublic = rsa.ExportParameters(false);
foreach (var cert in certs)
{
byte[] pubpem = Convert.FromBase64String(cert.Value);
AsymmetricKeyParameter asymmetricKeyParameter = PublicKeyFactory.CreateKey(pubpem);
RsaKeyParameters rsaKeyParameters = (RsaKeyParameters)asymmetricKeyParameter;
RSAParameters rsaParameters = new RSAParameters();
rsaParameters.Modulus = rsaKeyParameters.Modulus.ToByteArrayUnsigned();
rsaParameters.Exponent = rsaKeyParameters.Exponent.ToByteArrayUnsigned();
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
rsa.ImportParameters(rsaParameters);
bool valid = rsa.VerifyHash(sn, CryptoConfig.MapNameToOID("SHA1"), otp.signature);
if (valid)
{
print("Valid Key");
return(true);
}
}
print("Invalid Key");
throw new InvalidKeyException("Invalid Board");
}
else
{
print("Failed Header Check");
throw new FormatException("Failed Header Check");
}
}
catch
{
print("Failed to read Certificate of Authenticity");
throw;
}
}
// not board type 9
return(true);
}
public static void AddOID_NotSupported()
{
Assert.Throws <PlatformNotSupportedException>(() => CryptoConfig.AddOID(string.Empty, string.Empty));
}
/// <include file='doc\KeyedHashAlgorithm.uex' path='docs/doc[@for="KeyedHashAlgorithm.Create1"]/*' />
new static public KeyedHashAlgorithm Create(String algName)
{
return((KeyedHashAlgorithm)CryptoConfig.CreateFromName(algName));
}
public static void AddAlgorithm_NotSupported()
{
Assert.Throws <PlatformNotSupportedException>(() => CryptoConfig.AddAlgorithm(typeof(CryptoConfigTests), string.Empty));
}
/// <summary>
/// Default options
/// </summary>
public CryptoSym()
{
_encryptionOptions = new CryptoConfig();
_algorithm = CryptographyUtils.CreateSymmAlgoTripleDes();
}
public static void EncodeOID_Compat()
{
string actual = CryptoConfig.EncodeOID("-1.2.-3").ByteArrayToHex();
Assert.Equal("0602DAFD", actual); // Negative values not checked
}
/// <summary>
/// Initializes a new instance of the <see cref="SymmetricCryptoService"/> class.
/// </summary>
/// <param name="options">The options.</param>
public CryptoSym(CryptoConfig options, SymmetricAlgorithm algorithm)
{
_encryptionOptions = options;
_algorithm = algorithm;
}
new static public SHA512 Create(String hashName)
{
return((SHA512)CryptoConfig.CreateFromName(hashName));
}
/// <summary>
/// Default options
/// </summary>
public CryptoHash()
{
this._encryptionOptions = new CryptoConfig();
this._algorithm = CryptographyUtils.CreateHashAlgoMd5();
}
public byte[] SingDate(byte[] dataToSign)
{
return(Provider.SignData(dataToSign, CryptoConfig.MapNameToOID(Algorithm)));
}
/// <summary>
/// Initializes a new instance of the <see cref="SymmetricCryptoService"/> class.
/// </summary>
/// <param name="options">The options.</param>
public CryptoHash(CryptoConfig options, HashAlgorithm algorithm)
{
this._encryptionOptions = options;
this._algorithm = algorithm;
}
public static void AddOID_MapNameToOID_ReturnsMapped()
{
CryptoConfig.AddOID("1.3.14.3.2.28", "SHAFancy");
Assert.Equal("1.3.14.3.2.28", CryptoConfig.MapNameToOID("SHAFancy"));
}
