154 lines
7.6 KiB
C++
154 lines
7.6 KiB
C++
////////////////////////////////////////////////////////////////////////////////
|
|
// 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_
|