/** * initialise the RSA engine. * * @param forEncryption true if we are encrypting, false otherwise. * @param param the necessary RSA key parameters. */ public void init( bool forEncryption, CipherParameters param) { this.key = (RSAKeyParameters)param; this.forEncryption = forEncryption; }
public static RSA LoadDevelopment(string path, bool createIfMissing) { var fileExists = File.Exists(path); if (!fileExists && !createIfMissing) { throw new InvalidOperationException($"Couldn't find the file '{path}' and creation of a development key was not requested."); } if (fileExists) { var rsa = JsonConvert.DeserializeObject <RSAKeyParameters>(File.ReadAllText(path)); return(rsa.GetRSA()); } else { var parameters = RSAKeyParameters.Create(); var directory = Path.GetDirectoryName(path); if (!Directory.Exists(directory)) { Directory.CreateDirectory(directory); } File.WriteAllText(path, JsonConvert.SerializeObject(parameters)); return(parameters.GetRSA()); } }
public virtual void init(bool forSigning, CipherParameters param) { RSAKeyParameters kParam = null; if (param is ParametersWithRandom) { ParametersWithRandom p = (ParametersWithRandom)param; kParam = (RSAKeyParameters)p.getParameters(); random = p.getRandom(); } else { kParam = (RSAKeyParameters)param; if (forSigning) { random = new SecureRandom(); } } cipher.init(forSigning, kParam); emBits = kParam.getModulus().bitLength() - 1; block = new byte[(emBits + 7) / 8]; reset(); }
public ScrambledKeyPair(AsymmetricCipherKeyPair pPair) { _pair = pPair; AsymmetricKeyParameter publicKey = pPair.getPublic(); RSAKeyParameters rsaKeyParameters = publicKey as RSAKeyParameters; if (rsaKeyParameters != null) { ScrambledModulus = ScrambleModulus(rsaKeyParameters.getModulus()); } PrivateKey = pPair.getPrivate(); }
private RSAKeyParameters generateKeys() { RSAKeyPairGenerator kpg = new RSAKeyPairGenerator(); RSAKeyGenerationParameters parms = new RSAKeyGenerationParameters( BigInteger.valueOf(0x11), new SecureRandom(), keySize, certainty); kpg.init(parms); AsymmetricCipherKeyPair pair = kpg.generateKeyPair(); privateKey = (RSAKeyParameters)pair.getPrivate(); return((RSAKeyParameters)pair.getPublic()); }
public virtual void init(bool forSigning, CipherParameters param) { RSAKeyParameters kParam = (RSAKeyParameters)param; cipher.init(forSigning, kParam); keyBits = kParam.getModulus().bitLength(); block = new byte[(keyBits + 7) / 8]; mBuf = new byte[block.Length - 1]; reset(); }
public void createKeyPair(string country, string organization, string locality, string stateOrProvince, string emailAddress, string commonName) { RSAKeyParameters publicKey = generateKeys(); certificate = generateCertificate(country, organization, locality, stateOrProvince, emailAddress, commonName, privateKey, publicKey); if (!certificate.isValid()) { throw new Exception("Invalid certificate"); } }
public static RSAKeyParameters GetParameters(RSA key) { var result = new RSAKeyParameters(); var rawParameters = key.ExportParameters(includePrivateParameters: true); if (rawParameters.D != null) { result.D = Convert.ToBase64String(rawParameters.D); } if (rawParameters.DP != null) { result.DP = Convert.ToBase64String(rawParameters.DP); } if (rawParameters.DQ != null) { result.DQ = Convert.ToBase64String(rawParameters.DQ); } if (rawParameters.Exponent != null) { result.E = Convert.ToBase64String(rawParameters.Exponent); } if (rawParameters.InverseQ != null) { result.IQ = Convert.ToBase64String(rawParameters.InverseQ); } if (rawParameters.Modulus != null) { result.M = Convert.ToBase64String(rawParameters.Modulus); } if (rawParameters.P != null) { result.P = Convert.ToBase64String(rawParameters.P); } if (rawParameters.Q != null) { result.Q = Convert.ToBase64String(rawParameters.Q); } return(result); }
/// <summary> Initialise the signer. /// /// </summary> /// <param name="forSigning">true if for signing, false if for verification. /// </param> /// <param name="param">parameters for signature generation/verification. If the /// parameters are for generation they should be a ParametersWithRandom, /// a ParametersWithSalt, or just an RSAKeyParameters object. If RSAKeyParameters /// are passed in a SecureRandom will be created. /// </param> /// <exception cref="ArgumentException"> IllegalArgumentException if wrong parameter type or a fixed /// salt is passed in which is the wrong length. /// </exception> public virtual void init(bool forSigning, CipherParameters param) { RSAKeyParameters kParam = null; int lengthOfSalt = saltLength; if (param is ParametersWithRandom) { ParametersWithRandom p = (ParametersWithRandom)param; kParam = (RSAKeyParameters)p.getParameters(); random = p.getRandom(); } else if (param is ParametersWithSalt) { ParametersWithSalt p = (ParametersWithSalt)param; kParam = (RSAKeyParameters)p.getParameters(); standardSalt = p.getSalt(); lengthOfSalt = standardSalt.Length; } else { kParam = (RSAKeyParameters)param; if (forSigning) { random = new SecureRandom(); } } cipher.init(forSigning, kParam); keyBits = kParam.getModulus().bitLength(); block = new byte[(keyBits + 7) / 8]; if (trailer == TRAILER_IMPLICIT) { mBuf = new byte[block.Length - digest.getDigestSize() - lengthOfSalt - 1 - 1]; } else { mBuf = new byte[block.Length - digest.getDigestSize() - lengthOfSalt - 1 - 2]; } reset(); }
public void init( bool forEncryption, CipherParameters param) { RSAKeyParameters kParam = null; if (typeof(ParametersWithRandom).IsInstanceOfType(param)) { ParametersWithRandom rParam = (ParametersWithRandom)param; kParam = (RSAKeyParameters)rParam.getParameters(); } else { kParam = (RSAKeyParameters)param; } engine.init(forEncryption, kParam); bitSize = kParam.getModulus().bitLength(); this.forEncryption = forEncryption; }
private X509Certificate generateCertificate(String country, String organization, String locality, String stateOrProvince, String emailAddress, String commonName, RSAKeyParameters privateKey, RSAKeyParameters publicKey) { string dateString = DateTime.Now.ToString("yyyyMMddHHmmssfff", DateTimeFormatInfo.InvariantInfo); BigInteger serialNumber = new BigInteger(dateString); DateTime notBefore = DateTime.Today.AddDays(-1); DateTime notAfter = DateTime.Today.AddDays(730); Hashtable attrs = new Hashtable(); attrs.Add(X509Name.C, country); // Country attrs.Add(X509Name.O, organization); // Organization attrs.Add(X509Name.L, locality); // Locality attrs.Add(X509Name.ST, stateOrProvince); // State/Province attrs.Add(X509Name.EmailAddress, emailAddress); attrs.Add(X509Name.CN, commonName); // Common Name // Create a certificate X509V3CertificateGenerator certGen = new X509V3CertificateGenerator(); certGen.setSerialNumber(serialNumber); certGen.setIssuerDN(new X509Name(attrs)); certGen.setNotBefore(notBefore); certGen.setNotAfter(notAfter); certGen.setSubjectDN(new X509Name(attrs)); certGen.setPublicKey(publicKey); certGen.setSignatureAlgorithm("SHA256WithRSAEncryption"); X509Certificate certificate = certGen .generateX509Certificate(privateKey); return(certificate); }
public RSACipher(FolaighKeyStore keyStore, string keyName, bool usePrivateKey) { key = keyStore.getKey(keyName, usePrivateKey); }
/// <summary> /// Create a Subject Public Key Info object for a given public key. /// </summary> /// <param name="key">One of ElGammalPublicKeyParameters, DSAPublicKeyParameter, DHPublicKeyParameters, RSAKeyParameters or ECPublicKeyParameters</param> /// <returns>A subject public key info object.</returns> /// <exception cref="Exception">Throw exception if object provided is not one of the above.</exception> public static SubjectPublicKeyInfo CreateSubjectPublicKeyInfo(AsymmetricKeyParameter key) { if (key.isPrivate()) { throw (new Exception("Private key passed - public key expected.")); } if (key is ElGamalPublicKeyParameters) { ElGamalPublicKeyParameters _key = (ElGamalPublicKeyParameters)key; SubjectPublicKeyInfo info = new SubjectPublicKeyInfo( new AlgorithmIdentifier( OIWObjectIdentifiers.elGamalAlgorithm, new ElGamalParameter( _key.getParameters().getP(), _key.getParameters().getG() ).toASN1Object()), new DERInteger(_key.getY())); return(info); } if (key is DSAPublicKeyParameters) { DSAPublicKeyParameters _key = (DSAPublicKeyParameters)key; SubjectPublicKeyInfo info = new SubjectPublicKeyInfo( new AlgorithmIdentifier( X9ObjectIdentifiers.id_dsa, new DSAParameter(_key.getParameters().getP(), _key.getParameters().getQ(), _key.getParameters().getG()).toASN1Object()), new DERInteger(_key.getY()) ); return(info); } if (key is DHPublicKeyParameters) { DHPublicKeyParameters _key = (DHPublicKeyParameters)key; SubjectPublicKeyInfo info = new SubjectPublicKeyInfo( new AlgorithmIdentifier(X9ObjectIdentifiers.dhpublicnumber, new DHParameter(_key.getParameters().getP(), _key.getParameters().getG(), _key.getParameters().getJ()).toASN1Object()), new DERInteger(_key.getY())); return(info); } // End of DH if (key is RSAKeyParameters) { RSAKeyParameters _key = (RSAKeyParameters)key; if (_key.isPrivate()) { throw (new Exception("Private RSA Key provided.")); } SubjectPublicKeyInfo info = new SubjectPublicKeyInfo(new AlgorithmIdentifier(PKCSObjectIdentifiers.rsaEncryption, new DERNull()), new RSAPublicKeyStructure(_key.getModulus(), _key.getExponent()).toASN1Object()); return(info); } // End of RSA. if (key is ECPublicKeyParameters) { ECPublicKeyParameters _key = (ECPublicKeyParameters)key; X9ECParameters ecP = new X9ECParameters( _key.getParameters().getCurve(), _key.getParameters().getG(), _key.getParameters().getN(), _key.getParameters().getH(), _key.getParameters().getSeed()); X962Parameters x962 = new X962Parameters(ecP); ASN1OctetString p = (ASN1OctetString)(new X9ECPoint(_key.getQ()).toASN1Object()); SubjectPublicKeyInfo info = new SubjectPublicKeyInfo(new AlgorithmIdentifier(X9ObjectIdentifiers.id_ecPublicKey, x962.toASN1Object()), p.getOctets()); return(info); } // End of EC throw (new Exception("Class provided no convertable:" + key.GetType())); }
public void addKey(String alias, RSAKeyParameters privateKey, X509Certificate certificate) { store.setKeyEntry(alias, new AsymmetricKeyEntry(privateKey), new X509CertificateEntry[] { new X509CertificateEntry(certificate) }); }