Export provisioning sdk

Change-Id: I4d47d80444c9507f84896767dc676112ca11e901

common/rsa_util.h

@@ -0,0 +1,153 @@
+////////////////////////////////////////////////////////////////////////////////
+// Copyright 2016 Google Inc.
+//
+// This software is licensed under the terms defined in the Widevine Master
+// License Agreement. For a copy of this agreement, please contact
+// widevine-licensing@google.com.
+////////////////////////////////////////////////////////////////////////////////
+
+//
+// Description:
+//   RSA utility functions for serializing and deserializing RSA keys,
+//   encryption, and signing.
+
+#ifndef COMMON_RSA_UTIL_H_
+#define COMMON_RSA_UTIL_H_
+
+#include <string>
+
+#include "openssl/rsa.h"
+
+namespace widevine {
+namespace rsa_util {
+
+// Serialize RSA private key into DER encoded PKCS#1 RSAPrivateKey.
+// - private_key is the RSA key to be serialized, which must not be NULL.
+// - serialized_private_key is a pointer to the std::string to hold the serialized
+//   PKCS#1 RSAPrivateKey object. Caller retains ownership of the string. This
+//   parameter must not be NULL.
+// Returns true if successful, false otherwise.
+bool SerializeRsaPrivateKey(const RSA* private_key,
+                            std::string* serialized_private_key);
+
+// Deserialize RSA private key from DER encoded PKCS#1 RSAPrivateKey.
+// - serialized_private_key is the DER-encoded PKCS#1 RSAPrivateKey to be
+//   deserialized.
+// - private_key is a pointer to an RSA structure pointer to point to a newly
+//   allocated RSA structure. Caller assumes ownership of the new RSA pointer,
+//   which is not allocated if the method fails. This parameter must not be
+//   NULL.
+// Returns true if successful, false otherwise.
+bool DeserializeRsaPrivateKey(const std::string& serialized_private_key,
+                              RSA** private_key);
+
+// Serialize RSA key into DER encoded PKCS#1 RSAPublicKey.
+// - public_key is the RSA key to be serialized, which must not be NULL.
+// - serialized_public_key is a pointer to the std::string to hold the serialized
+//   PKCS#1 RSAPublicKey object. Caller retains ownership of the string. This
+//   parameter must not be NULL.
+// Returns true if successful, false otherwise.
+bool SerializeRsaPublicKey(const RSA* public_key,
+                           std::string* serialized_public_key);
+
+// Deserialize RSA public key from DER encoded PKCS#1 RSAPublicKey.
+// - serialized_public_key is the DER-encoded PKCS#1 RSAPublicKey to be
+//   deserialized.
+// - public_key is a pointer to an RSA structure pointer to point to a newly
+//   allocated RSA structure. Caller assumes ownership of the new RSA pointer,
+//   which is not allocated if the method fails. This parameter must not be
+//   NULL.
+// Returns true if successful, false otherwise.
+bool DeserializeRsaPublicKey(const std::string& serialized_public_key,
+                             RSA** public_key);
+
+// Serialize RSA private key into DER encoded PKCS#8 PrivateKeyInfo.
+// - private_key is the RSA key to be serialized, which must not be NULL.
+// - serialized_private_key is a pointer to the std::string to hold the serialized
+//   PKCS#8 PrivateKeyInfo object. Caller retains ownership of the string. This
+//   parameter must not be NULL.
+// Returns true if successful, false otherwise.
+bool SerializePrivateKeyInfo(const RSA* private_key,
+                             std::string* serialized_private_key);
+
+// Deserialize RSA private key from DER encoded PKCS#8 PrivateKeyInfo.
+// - serialized_private_key is the DER-encoded PKCS#8 PrivateKeyInfo to be
+//   deserialized.
+// - private_key is a pointer to an RSA structure pointer to point to a newly
+//   allocated RSA structure. Caller assumes ownership of the new RSA pointer,
+//   which is not allocated if the method fails. This parameter must not be
+//   NULL.
+// Returns true if successful, false otherwise.
+bool DeserializePrivateKeyInfo(const std::string& serialized_private_key,
+                               RSA** private_key);
+
+// Convert DER-encoded PKCS#1 RSAPrivateKey to DER-encoded PKCS#8
+// PrivateKeyInfo.
+// - rsa_private_key is the PKCS#1 RSAPrivateKey to be converted.
+// - private_key_info is a pointer to std::string to hold the PKCS#8 PrivateKeyInfo.
+//   The caller retains ownership of this parameter, which must not be NULL.
+// Returns true if successful, false otherwise.
+bool RsaPrivateKeyToPrivateKeyInfo(const std::string& rsa_private_key,
+                                   std::string* private_key_info);
+
+// Convert DER-encoded PKCS#8 PrivateKeyInfo to DER-encoded PKCS#1
+// RSAPrivateKey.
+// - private_key_info is the PKCS#8 PrivateKeyInfo to be converted.
+// - rsa_private_key is a pointer to std::string to hold the PKCS#1 RSAPrivateKey.
+//   The caller retains ownership of this parameter, which must not be NULL.
+// Returns true if successful, false otherwise.
+bool PrivateKeyInfoToRsaPrivateKey(const std::string& private_key_info,
+                                   std::string* rsa_private_key);
+
+
+// Serialize RSA private key into DER encoded PKCS#8 EncryptedPrivateKeyInfo.
+// - private_key is the RSA key to be serialized, which must not be NULL.
+// - passphrase is the password to use for PKCS#5 v2.0 3DES encryption.
+// - serialized_private_key is a pointer to the std::string to hold the serialized
+//   PKCS#8 EncryptedPrivateKeyInfo object. Caller retains ownership of the
+//   string. This parameter must not be NULL.
+// Returns true if successful, false otherwise.
+bool SerializeEncryptedPrivateKeyInfo(const RSA* private_key,
+                                      const std::string& passphrase,
+                                      std::string* serialized_private_key);
+
+// Deserialize RSA private key from DER encoded PKCS#8 EncryptedPrivateKeyInfo.
+// - serialized_private_key is the DER-encoded PKCS#8 EncryptedPrivateKeyInfo to
+//   be deserialized.
+// - passphrase is the password to use for key decryption.
+// - private_key is a pointer to an RSA structure pointer to point to a newly
+//   allocated RSA structure. Caller assumes ownership of the new RSA pointer,
+//   which is not allocated if the method fails. This parameter must not be
+//   NULL.
+// Returns true if successful, false otherwise.
+bool DeserializeEncryptedPrivateKeyInfo(const std::string& serialized_private_key,
+                                        const std::string& passphrase,
+                                        RSA** private_key);
+
+// Convert DER-encoded PKCS#1 RSAPrivateKey to DER-encoded PKCS#8
+// EncryptedPrivateKeyInfo.
+// - rsa_private_key is the PKCS#1 RSAPrivateKey to be converted.
+// - passphrase is the password to use for PKCS#5 v2.1 AES-256-CBC encryption.
+// - private_key_info is a pointer to std::string to hold the PKCS#8
+//   EncryptedPrivateKeyInfo.
+//   The caller retains ownership of this parameter, which must not be NULL.
+// Returns true if successful, false otherwise.
+bool RsaPrivateKeyToEncryptedPrivateKeyInfo(const std::string& rsa_private_key,
+                                            const std::string& passphrase,
+                                            std::string* private_key_info);
+
+// Convert DER-encoded PKCS#8 EncryptedPrivateKeyInfo to DER-encoded PKCS#1
+// RSAPrivateKey.
+// - private_key_info is the PKCS#8 EncryptedPrivateKeyInfo to be converted.
+// - passphrase is the password to use for key decryption.
+// - rsa_private_key is a pointer to std::string to hold the PKCS#1 RSAPrivateKey.
+//   The caller retains ownership of this parameter, which must not be NULL.
+// Returns true if successful, false otherwise.
+bool EncryptedPrivateKeyInfoToRsaPrivateKey(const std::string& private_key_info,
+                                            const std::string& passphrase,
+                                            std::string* rsa_private_key);
+
+}  // namespace rsa_util
+}  // namespace widevine
+
+#endif  // COMMON_RSA_UTIL_H_