Example #1
0
 /// <summary>
 /// Create an identity by creating a pair of Key-Signing-Key (KSK) for this
 /// identity and a self-signed certificate of the KSK.
 /// </summary>
 ///
 /// <param name="identityName">The name of the identity.</param>
 /// <param name="params"></param>
 /// <returns>The key name of the auto-generated KSK of the identity.</returns>
 /// <exception cref="System.Security.SecurityException">if the identity has already been created.</exception>
 public Name createIdentity(Name identityName, KeyParams paras)
 {
     return(net.named_data.jndn.security.certificate.IdentityCertificate
            .certificateNameToPublicKeyName(createIdentityAndCertificate(
                                                identityName, paras)));
 }
Example #2
0
        /*****************************************
        *          Identity Management          *
        *****************************************/

        /// <summary>
        /// Create an identity by creating a pair of Key-Signing-Key (KSK) for this
        /// identity and a self-signed certificate of the KSK. If a key pair or
        /// certificate for the identity already exists, use it.
        /// </summary>
        ///
        /// <param name="identityName">The name of the identity.</param>
        /// <param name="params"></param>
        /// <returns>The name of the default certificate of the identity.</returns>
        /// <exception cref="System.Security.SecurityException">if the identity has already been created.</exception>
        public Name createIdentityAndCertificate(Name identityName,
                                                 KeyParams paras)
        {
            return(identityManager_.createIdentityAndCertificate(identityName,
                                                                 paras));
        }
Example #3
0
 /// <summary>
 /// Create an identity by creating a pair of Key-Signing-Key (KSK) for this
 /// identity and a self-signed certificate of the KSK.
 /// </summary>
 ///
 /// <param name="identityName">The name of the identity.</param>
 /// <param name="params"></param>
 /// <returns>The key name of the auto-generated KSK of the identity.</returns>
 /// <exception cref="System.Security.SecurityException">if the identity has already been created.</exception>
 public Name createIdentity(Name identityName, KeyParams paras)
 {
     return net.named_data.jndn.security.certificate.IdentityCertificate
             .certificateNameToPublicKeyName(createIdentityAndCertificate(
                     identityName, paras));
 }
Example #4
0
        /*****************************************
         *          Identity Management          *
         *****************************************/
        /// <summary>
        /// Create an identity by creating a pair of Key-Signing-Key (KSK) for this
        /// identity and a self-signed certificate of the KSK. If a key pair or
        /// certificate for the identity already exists, use it.
        /// </summary>
        ///
        /// <param name="identityName">The name of the identity.</param>
        /// <param name="params"></param>
        /// <returns>The name of the default certificate of the identity.</returns>
        /// <exception cref="System.Security.SecurityException">if the identity has already been created.</exception>
        public Name createIdentityAndCertificate(Name identityName,
				KeyParams paras)
        {
            return identityManager_.createIdentityAndCertificate(identityName,
                    paras);
        }
        /// <summary>
        /// Create an identity by creating a pair of Key-Signing-Key (KSK) for this
        /// identity and a self-signed certificate of the KSK. If a key pair or
        /// certificate for the identity already exists, use it.
        /// </summary>
        ///
        /// <param name="identityName">The name of the identity.</param>
        /// <param name="params">The key parameters if a key needs to be generated for the identity.</param>
        /// <returns>The name of the default certificate of the identity.</returns>
        /// <exception cref="System.Security.SecurityException">if the identity has already been created.</exception>
        public Name createIdentityAndCertificate(Name identityName,
				KeyParams paras)
        {
            identityStorage_.addIdentity(identityName);

            Name keyName = null;
            bool generateKey = true;
            try {
                keyName = identityStorage_
                        .getDefaultKeyNameForIdentity(identityName);
                PublicKey key = new PublicKey(identityStorage_.getKey(keyName));
                if (key.getKeyType() == paras.getKeyType())
                    // The key exists and has the same type, so don't need to generate one.
                    generateKey = false;
            } catch (SecurityException ex) {
            }

            if (generateKey) {
                keyName = generateKeyPair(identityName, true, paras);
                identityStorage_.setDefaultKeyNameForIdentity(keyName);
            }

            Name certName = null;
            bool makeCert = true;
            try {
                certName = identityStorage_
                        .getDefaultCertificateNameForKey(keyName);
                // The cert exists, so don't need to make it.
                makeCert = false;
            } catch (SecurityException ex_0) {
            }

            if (makeCert) {
                IdentityCertificate selfCert = selfSign(keyName);
                addCertificateAsIdentityDefault(selfCert);
                certName = selfCert.getName();
            }

            return certName;
        }
        /// <summary>
        /// Generate a key pair for the specified identity.
        /// </summary>
        ///
        /// <param name="identityName">The name of the specified identity.</param>
        /// <param name="isKsk">true for generating a Key-Signing-Key (KSK), false for a Data-Signing-Key (KSK).</param>
        /// <param name="params">The parameters of the key.</param>
        /// <returns>The name of the generated key.</returns>
        private Name generateKeyPair(Name identityName, bool isKsk,
				KeyParams paras)
        {
            ILOG.J2CsMapping.Util.Logging.Logger.getLogger(this.GetType().FullName).log(ILOG.J2CsMapping.Util.Logging.Level.INFO,
                    "Get new key ID");
            Name keyName = identityStorage_.getNewKeyName(identityName, isKsk);

            ILOG.J2CsMapping.Util.Logging.Logger.getLogger(this.GetType().FullName).log(ILOG.J2CsMapping.Util.Logging.Level.INFO,
                    "Generate key pair in private storage");
            privateKeyStorage_.generateKeyPair(keyName, paras);

            ILOG.J2CsMapping.Util.Logging.Logger.getLogger(this.GetType().FullName).log(ILOG.J2CsMapping.Util.Logging.Level.INFO,
                    "Create a key record in public storage");
            PublicKey pubKey = privateKeyStorage_.getPublicKey(keyName);
            identityStorage_.addKey(keyName, paras.getKeyType(),
                    pubKey.getKeyDer());

            return keyName;
        }
        /// <summary>
        /// Generate a pair of asymmetric keys.
        /// </summary>
        ///
        /// <param name="keyName">The name of the key pair.</param>
        /// <param name="params">The parameters of the key.</param>
        /// <exception cref="System.Security.SecurityException"></exception>
        public override void generateKeyPair(Name keyName, KeyParams paras)
        {
            if (doesKeyExist(keyName, net.named_data.jndn.security.KeyClass.PUBLIC))
                throw new SecurityException("Public Key already exists");
            if (doesKeyExist(keyName, net.named_data.jndn.security.KeyClass.PRIVATE))
                throw new SecurityException("Private Key already exists");

            String keyAlgorithm;
            int keySize;
            if (paras.getKeyType() == net.named_data.jndn.security.KeyType.RSA) {
                keyAlgorithm = "RSA";
                keySize = ((RsaKeyParams) paras).getKeySize();
            } else if (paras.getKeyType() == net.named_data.jndn.security.KeyType.ECDSA) {
                keyAlgorithm = "EC";
                keySize = ((EcdsaKeyParams) paras).getKeySize();
            } else
                throw new SecurityException("Cannot generate a key pair of type "
                        + paras.getKeyType());

            KeyPairGenerator generator = null;
            try {
                generator = System.KeyPairGenerator.getInstance(keyAlgorithm);
            } catch (Exception e) {
                throw new SecurityException(
                        "FilePrivateKeyStorage: Could not create the key generator: "
                                + e.Message);
            }

            generator.initialize(keySize);
            KeyPair pair = generator.generateKeyPair();

            setKeyPairForKeyName(keyName, paras.getKeyType(),
                    ILOG.J2CsMapping.NIO.ByteBuffer.wrap(pair.getPublic().getEncoded()),
                    ILOG.J2CsMapping.NIO.ByteBuffer.wrap(pair.getPrivate().getEncoded()));
        }
 /// <summary>
 /// Generate a symmetric key.
 /// </summary>
 ///
 /// <param name="keyName">The name of the key.</param>
 /// <param name="params">The parameters of the key.</param>
 /// <exception cref="System.Security.SecurityException"></exception>
 public override void generateKey(Name keyName, KeyParams paras)
 {
     throw new NotSupportedException(
             "MemoryPrivateKeyStorage.generateKey is not implemented");
 }
 /// <summary>
 /// Generate a pair of asymmetric keys.
 /// </summary>
 ///
 /// <param name="keyName">The name of the key pair.</param>
 /// <param name="params">The parameters of the key.</param>
 /// <exception cref="System.Security.SecurityException"></exception>
 public abstract void generateKeyPair(Name keyName, KeyParams paras);