public static TagRSAParameters CreateNewRSAParameters(KeyStrength strength)
{
var keySize = strength.RSAKeySize();
using var provider = new RSACryptoServiceProvider(keySize);
return(new TagRSAParameters(provider.ExportParameters(true), strength));
}
/// <summary>
/// Returns a string representation for this <see cref="Caffeine{K, V}"/> instance. The exact
/// form of the returned string is not specified.
/// </summary>
/// <returns></returns>
public override string ToString()
{
StringBuilder sb = new StringBuilder(64);
sb.Append(this.GetType().Name).Append('{');
int baseLength = sb.Length;
if (initialCapacity != UNSET_INT)
{
sb.Append("initialCapacity=").Append(initialCapacity).Append(", ");
}
if (maximumSize != UNSET_INT)
{
sb.Append("maximumSize=").Append(maximumSize).Append(", ");
}
if (maximumWeight != UNSET_INT)
{
sb.Append("maximumWeight=").Append(maximumWeight).Append(", ");
}
if (expireAfterWriteNanoseconds != UNSET_INT)
{
sb.Append("expireAfterWrite=").Append(expireAfterWriteNanoseconds).Append("ns, ");
}
if (expireAfterAccessNanoseconds != UNSET_INT)
{
sb.Append("expireAfterAccess=").Append(expireAfterAccessNanoseconds).Append("ns, ");
}
if (expiry != null)
{
sb.Append("expiry, ");
}
if (refreshNanoseconds != UNSET_INT)
{
sb.Append("refreshNanos=").Append(refreshNanoseconds).Append("ns, ");
}
sb.Append("keyStrength=").Append(KeyStrength.ToString()).Append(", ");
sb.Append("valueStrength=").Append(ValueStrength.ToString()).Append(", ");
if (removalListener != null)
{
sb.Append("removalListener, ");
}
if (writer != null)
{
sb.Append("writer, ");
}
sb.Append('}');
return(sb.ToString());
}
public static ECDsaParameters CreateNewECDsaParameters(KeyStrength strength)
{
using var provider = ECDsa.Create();
var curve = ECDsaParameters.ChooseCurve(strength);
provider.GenerateKey(curve);
return(new ECDsaParameters(provider.ExportParameters(true), strength, ECDsaParameters.ChooseHashAlgo(curve)));
}
public static AsymmetricCipherKeyPair CreateAsymmetricKeyPair(KeyStrength keyStrength)
{
RsaKeyPairGenerator keyPairGenerator = new RsaKeyPairGenerator();
keyPairGenerator.Init(new KeyGenerationParameters(new SecureRandom(), GetSchluesselStaerke(keyStrength)));
AsymmetricCipherKeyPair keyPair = keyPairGenerator.GenerateKeyPair();
return(keyPair);
}
public static void CreateAsymmetricKeyPair(KeyStrength keyStrength, out AsymmetricKeyParameter publicKey, out AsymmetricKeyParameter privateKey)
{
publicKey = null;
privateKey = null;
AsymmetricCipherKeyPair keyPair = CreateAsymmetricKeyPair(keyStrength);
privateKey = keyPair.Private as AsymmetricKeyParameter;
publicKey = keyPair.Public as AsymmetricKeyParameter;
}
public static string GenerateSecureKey(KeyStrength keyStrength)
{
int numBytes = (int)Math.Ceiling((double)keyStrength / 8.0);
RNGCryptoServiceProvider crypto = new RNGCryptoServiceProvider();
byte[] bytes = new byte[numBytes];
crypto.GetBytes(bytes);
return BytesToHexString(bytes);
}
public CustomKeyInformation(byte[] blob)
{
// Validate the input
Validator.AssertNotNull(blob, "blob");
Validator.AssertMinLength(blob, MinLength, "blob");
// Parse:
// An 8 - bit unsigned integer that must be set to 1:
this.Version = blob[VersionOffset];
// An 8-bit unsigned integer that specifies zero or more bit-flag values.
this.Flags = (KeyFlags)blob[FlagsOffset];
if (blob.Length <= VolumeTypeOffset)
{
// This structure has two possible representations. In the first representation, only the Version and Flags fields are present; in this case the structure has a total size of two bytes.In the second representation, all additional fields shown below are also present; in this case, the structure's total size is variable. Differentiating between the two representations must be inferred using only the total size.
return;
}
// An 8-bit unsigned integer that specifies one of the volume types.
this.VolumeType = (VolumeType)blob[VolumeTypeOffset];
if (blob.Length <= SupportsNotificationOffset)
{
return;
}
// An 8 - bit unsigned integer that specifies whether the device associated with this credential supports notification.
this.SupportsNotification = blob[SupportsNotificationOffset] != 0;
if (blob.Length <= FekKeyVersionOffset)
{
return;
}
// An 8-bit unsigned integer that specifies the version of the File Encryption Key (FEK). This field must be set to 1.
this.FekKeyVersion = blob[FekKeyVersionOffset];
if (blob.Length <= KeyStrengthOffset)
{
return;
}
// An 8 - bit unsigned integer that specifies the strength of the NGC key.
this.Strength = (KeyStrength)blob[KeyStrengthOffset];
// TODO: Read Reserved: 10 bytes reserved for future use.
// TODO: Read EncodedExtendedCKI: Extended custom key information.
}
/// <summary>
/// Generar llave privada
/// </summary>
/// <param name="filename">Ruta para la llave</param>
/// <param name="strength">Fuerza de la llave privada</param>
/// <param name="maxWait">Máximo tiempo a esperar por el proceso de creación</param>
/// <returns>Retorna el nombre del archivo generado o <see cref="null"/> en caso que no se haya podido generar en el tiempo establecido</returns>
public static string GenerateKey(string filename, KeyStrength strength = KeyStrength.Bits2048, int maxWait = 2000)
{
Process sslProcess = CreateProcess()
.WithArguments($"genrsa -out \"{filename}\" {(int)strength}");
sslProcess.Start();
if (sslProcess.WaitForExit(maxWait))
{
return(filename);
}
else
{
sslProcess.Kill();
Files.DeleteIfExists(filename);
return(null);
}
}
public void CreateECKeySerializeDeserializeSignAndVerify(KeyStrength keyStrength)
{
var parameters = ECDsaHelper.CreateNewECDsaParameters(keyStrength);
var key = new TagPubECKey(parameters);
var bytes = key.EncodedBytes;
TestContext.WriteLine(bytes.AsLiteral());
using var ms = new MemoryStream(bytes);
var tag = ms.Decode <TagPubKey>();
Assert.NotNull(tag);
Assert.AreEqual(key, tag);
CollectionAssert.AreEqual(bytes, tag.EncodedBytes);
var signatureBytes = ECDsaHelper.HashAndSign(bytes, parameters.Parameters, parameters.HashAlgorithm.ToName());
var signature = new TagSignature(Algorithm.EcDSA, signatureBytes);
Assert.IsTrue(key.Verify(bytes, signature), "Signature failed!");
}
public Parts(KeyPurpose[] purposes, string name, string description, TagPubKey pubKey, KeyStrength strength, BaseKeyId keyId, IEnumerable <AppPermissions> permissions)
{
if (string.IsNullOrWhiteSpace(name))
{
throw new ArgumentNullException(nameof(name));
}
Version = InterlockKeyVersion;
Name = name;
Purposes = purposes.Required();
PublicKey = pubKey.Required();
Description = description;
Strength = strength;
if (Actionable && permissions.None())
{
Purposes = Purposes.Where(pu => pu != KeyPurpose.Action).ToArray(); // Remove Action Purpose
}
Permissions = permissions;
Identity = new KeyId(TagHash.HashSha256Of(_hashable));
Id = keyId ?? Identity;
}
public static int GetSchluesselStaerke(KeyStrength keyStrength)
{
switch (keyStrength)
{
case KeyStrength.ks128:
{
return(128);
}
case KeyStrength.ks256:
{
return(256);
}
case KeyStrength.ks512:
{
return(512);
}
case KeyStrength.ks1024:
{
return(1024);
}
case KeyStrength.ks2048:
{
return(2048);
}
case KeyStrength.ks4096:
{
return(4096);
}
default:
{
return(2048);
}
}
}
public static ECCurve ChooseCurve(KeyStrength strength) => strength switch
{
public static string CreateAESKey(KeyStrength schluesselStaerke)
{
int anzahlZeichen = GetSchluesselStaerke(schluesselStaerke) / 8;
return(GeneriereZeichenfolge(anzahlZeichen));
}
public TagRSAParameters(RSAParameters parameters, KeyStrength strength) : base(ILTagId.RSAParameters, new KeyParameters(parameters, strength))
{
}
public KeyParameters(RSAParameters parameters, KeyStrength strength)
{
Parameters = parameters;
Strength = strength;
}
public InterlockSigningKeyData Create(KeyPurpose[] purposes, IEnumerable <AppPermissions> permissions, Algorithm algorithm, KeyStrength strength, string name, string description, string password) => FindProviderFor(algorithm, ksp => ksp.SupportsKeyCreation, "and key creation").Create(purposes, permissions, algorithm, strength, name, description, password);
public static int ECDsaKeySize(this KeyStrength strength) => 192 + (64 * (int)strength);
public InterlockUpdatableSigningKeyData(KeyPurpose[] purposes, string name, byte[] encrypted, TagPubKey pubKey, KeyStrength strength, DateTimeOffset creationTime, string description = null, BaseKeyId keyId = null)
: this(new UpdatableParts(purposes, name, encrypted, pubKey, description, strength, keyId)) => LastSignatureTimeStamp = creationTime;
public UpdatableParts(KeyPurpose[] purposes, string name, byte[] encrypted, TagPubKey pubKey, string description, KeyStrength strength, BaseKeyId keyId)
: base(purposes, name, description, pubKey, strength, keyId, null)
{
Version = InterlockUpdatableSigningKeyVersion;
Encrypted = encrypted;
LastSignatureTimeStamp = DateTimeOffsetExtensions.TimeZero;
SignaturesWithCurrentKey = 0;
}
public InterlockSigningKeyData(KeyPurpose[] purposes, IEnumerable <AppPermissions> permissions, string name, byte[] encrypted, TagPubKey pubKey, KeyStrength strength, string description = null, BaseKeyId keyId = null, EncryptedContentType encryptedContentType = EncryptedContentType.EncryptedKey)
: this(new InterlockSigningKeyParts(purposes, permissions, name, encrypted, pubKey, description, strength, encryptedContentType, keyId))
{
}
public InterlockSigningKeyParts(KeyPurpose[] purposes, IEnumerable <AppPermissions> permissions, string name, byte[] encrypted, TagPubKey pubKey, string description, KeyStrength strength, EncryptedContentType encryptedContentType, BaseKeyId keyId)
: base(purposes, name, description, pubKey, strength, keyId, permissions)
{
Version = InterlockSigningKeyVersion;
Encrypted = encrypted;
EncryptedContentType = encryptedContentType;
}
public X509Certificate2 CreateCertificate(string name, string password, string file, Algorithm algorithm, KeyStrength strength) => FindProviderFor(algorithm, ksp => ksp.SupportsCertificateImport, "certificate creation").CreateCertificate(name, password, file, algorithm, strength);
IKeyParameters IKeyPhasedCreationProvider.CreateKeyParameters(Algorithm algorithm, KeyStrength strength) => FindPhasedProvider(algorithm).CreateKeyParameters(algorithm, strength);
InterlockSigningKeyData IKeyPhasedCreationProvider.CreateUsing(IKeyParameters emergencyKeyParameters, KeyStrength strength, BaseKeyId identity, string name, string description, string password, IEnumerable <AppPermissions> permissions, params KeyPurpose[] purposes) => FindPhasedProvider(emergencyKeyParameters.PublicKey.Algorithm).CreateUsing(emergencyKeyParameters, strength, identity, name, description, password, permissions, purposes);
public static int RSAKeySize(this KeyStrength strength) => 2048 + (1024 * (int)strength);
