/// <summary> /// Load the private key with name keyName from the key file directory. /// </summary> /// /// <param name="keyName">The name of the key.</param> /// <returns>The key loaded into a TpmPrivateKey.</returns> internal TpmPrivateKey loadKey(Name keyName) { TpmPrivateKey key = new TpmPrivateKey(); StringBuilder base64 = new StringBuilder(); try { TextReader reader = new FileReader( toFilePath(keyName).FullName); // Use "try/finally instead of "try-with-resources" or "using" // which are not supported before Java 7. try { String line = null; while ((line = reader.readLine()) != null) { base64.append(line); } } finally { reader.close(); } } catch (FileNotFoundException ex) { throw new TpmBackEnd.Error("Error reading private key file: " + ex); } catch (IOException ex_0) { throw new TpmBackEnd.Error("Error reading private key file: " + ex_0); } byte[] pkcs = net.named_data.jndn.util.Common.base64Decode(base64.toString()); try { key.loadPkcs1(ILOG.J2CsMapping.NIO.ByteBuffer.wrap(pkcs), default(KeyType) /* was: null */); } catch (TpmPrivateKey.Error ex_1) { throw new TpmBackEnd.Error("Error decoding private key file: " + ex_1); } return(key); }
/// <summary> /// Save the private key using keyName into the key file directory. /// </summary> /// /// <param name="keyName">The name of the key.</param> /// <param name="key">The private key to save.</param> private void saveKey(Name keyName, TpmPrivateKey key) { String filePath = toFilePath(keyName).FullName; String base64; try { base64 = net.named_data.jndn.util.Common.base64Encode(key.toPkcs1().getImmutableArray(), true); } catch (TpmPrivateKey.Error ex) { throw new TpmBackEnd.Error("Error encoding private key file: " + ex); } try { var writer = (new StreamWriter(filePath)); // Use "try/finally instead of "try-with-resources" or "using" // which are not supported before Java 7. try { writer.Write(base64, 0, base64.Substring(0, base64.Length)); writer.flush(); } finally { writer.close(); } } catch (IOException ex_0) { throw new TpmBackEnd.Error("Error writing private key file: " + ex_0); } }
/// <summary> /// Create a TpmKeyHandleMemory to use the given in-memory key. /// </summary> /// /// <param name="key">The in-memory key.</param> public TpmKeyHandleMemory(TpmPrivateKey key) { if (key == null) { throw new AssertionError("The key is null"); } key_ = key; }
/// <summary> /// Get the handle of the key with name keyName. /// </summary> /// /// <param name="keyName">The name of the key.</param> /// <returns>The handle of the key, or null if the key does not exist.</returns> protected internal override TpmKeyHandle doGetKeyHandle(Name keyName) { TpmPrivateKey key = ILOG.J2CsMapping.Collections.Collections.Get(keys_, keyName); if (key == null) { return(null); } return(new TpmKeyHandleMemory(key)); }
/// <summary> /// Import an encoded private key with name keyName in PKCS #8 format, possibly /// password-encrypted. /// </summary> /// /// <param name="keyName">The name of the key to use in the TPM.</param> /// <param name="pkcs8">unencrypted PKCS #8 PrivateKeyInfo.</param> /// <param name="password">it to decrypt the PKCS #8 EncryptedPrivateKeyInfo. If the password is null, import an unencrypted PKCS #8 PrivateKeyInfo.</param> /// <exception cref="TpmBackEnd.Error">for an error importing the key.</exception> protected internal override void doImportKey(Name keyName, ByteBuffer pkcs8, ByteBuffer password) { try { TpmPrivateKey key = new TpmPrivateKey(); if (password != null) { key.loadEncryptedPkcs8(pkcs8, password); } else { key.loadPkcs8(pkcs8); } // Copy the Name. ILOG.J2CsMapping.Collections.Collections.Put(keys_, new Name(keyName), key); } catch (TpmPrivateKey.Error ex) { throw new TpmBackEnd.Error("Cannot import private key: " + ex); } }
/// <summary> /// Generate a key pair according to keyParams and return a new TpmPrivateKey /// with the private key. You can get the public key with derivePublicKey. /// </summary> /// /// <param name="keyParams">The parameters of the key.</param> /// <returns>A new TpmPrivateKey.</returns> /// <exception cref="System.ArgumentException">if the key type is not supported.</exception> /// <exception cref="TpmPrivateKey.Error">for an invalid key size, or an error generating.</exception> public static TpmPrivateKey generatePrivateKey(KeyParams keyParams) { String keyAlgorithm; int keySize; if (keyParams.getKeyType() == net.named_data.jndn.security.KeyType.RSA) { keyAlgorithm = "RSA"; keySize = ((RsaKeyParams)keyParams).getKeySize(); } else if (keyParams.getKeyType() == net.named_data.jndn.security.KeyType.EC) { keyAlgorithm = "EC"; keySize = ((EcKeyParams)keyParams).getKeySize(); } else { throw new ArgumentException( "Cannot generate a key pair of type " + keyParams.getKeyType()); } KeyPairGenerator generator = null; try { generator = System.KeyPairGenerator.getInstance(keyAlgorithm); } catch (Exception e) { throw new TpmPrivateKey.Error( "TpmPrivateKey: Could not create the key generator: " + e.Message); } generator.initialize(keySize); KeyPair pair = generator.generateKeyPair(); TpmPrivateKey result = new TpmPrivateKey(); result.keyType_ = keyParams.getKeyType(); result.privateKey_ = pair.getPrivate(); return(result); }
/// <summary> /// Import an encoded private key with name keyName in PKCS #8 format, possibly /// password-encrypted. /// </summary> /// /// <param name="keyName">The name of the key to use in the TPM.</param> /// <param name="pkcs8">unencrypted PKCS #8 PrivateKeyInfo.</param> /// <param name="password">it to decrypt the PKCS #8 EncryptedPrivateKeyInfo. If the password is null, import an unencrypted PKCS #8 PrivateKeyInfo.</param> /// <exception cref="TpmBackEnd.Error">for an error importing the key.</exception> protected internal override void doImportKey(Name keyName, ByteBuffer pkcs8, ByteBuffer password) { TpmPrivateKey key = new TpmPrivateKey(); try { if (password != null) { key.loadEncryptedPkcs8(pkcs8, password); } else { key.loadPkcs8(pkcs8); } } catch (TpmPrivateKey.Error ex) { throw new TpmBackEnd.Error("Cannot import private key: " + ex); } saveKey(keyName, key); }