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);