| /* |
| * Copyright 2014 Google Inc. All rights reserved. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include "securemessage/public_key_proto_util.h" |
| |
| using std::unique_ptr; |
| |
| namespace securemessage { |
| |
| unique_ptr<GenericPublicKey> PublicKeyProtoUtil::EncodePublicKey( |
| const CryptoOps::PublicKey& key) { |
| switch (key.algorithm()) { |
| case CryptoOps::KeyAlgorithm::ECDSA_KEY: { |
| unique_ptr<EcP256PublicKey> ec_key = EncodeEcPublicKey(key); |
| if (ec_key == nullptr) { |
| return nullptr; |
| } |
| |
| unique_ptr<GenericPublicKey> result(new GenericPublicKey()); |
| result->set_type(PublicKeyType::EC_P256); |
| result->mutable_ec_p256_public_key()->CopyFrom(*ec_key); |
| return result; |
| } |
| case CryptoOps::KeyAlgorithm::RSA_KEY: { |
| unique_ptr<SimpleRsaPublicKey> rsa_key = EncodeRsaPublicKey(key); |
| if (rsa_key == nullptr) { |
| return nullptr; |
| } |
| |
| unique_ptr<GenericPublicKey> result(new GenericPublicKey()); |
| result->set_type(PublicKeyType::RSA2048); |
| result->mutable_rsa2048_public_key()->CopyFrom(*rsa_key); |
| return result; |
| } |
| default: |
| return nullptr; |
| } |
| } |
| |
| unique_ptr<EcP256PublicKey> PublicKeyProtoUtil::EncodeEcPublicKey( |
| const CryptoOps::PublicKey& key) { |
| string x; |
| string y; |
| if (!CryptoOps::ExportEcP256Key(key, &x, &y)) { |
| return nullptr; |
| } |
| |
| auto result = unique_ptr<EcP256PublicKey>(new EcP256PublicKey()); |
| result->set_x(x); |
| result->set_y(y); |
| return result; |
| } |
| |
| unique_ptr<SimpleRsaPublicKey> PublicKeyProtoUtil::EncodeRsaPublicKey( |
| const CryptoOps::PublicKey& key) { |
| string n; |
| int32_t e; |
| if (!CryptoOps::ExportRsa2048Key(key, &n, &e)) { |
| return nullptr; |
| } |
| |
| auto result = unique_ptr<SimpleRsaPublicKey>(new SimpleRsaPublicKey()); |
| result->set_n(n); |
| result->set_e(e); |
| return result; |
| } |
| |
| unique_ptr<CryptoOps::PublicKey> PublicKeyProtoUtil::ParsePublicKey( |
| const GenericPublicKey& key) { |
| switch (key.type()) { |
| case EC_P256: { |
| if (!key.has_ec_p256_public_key()) { |
| return nullptr; |
| } |
| return ParseEcPublicKey(key.ec_p256_public_key()); |
| } |
| case RSA2048: { |
| if (!key.has_rsa2048_public_key()) { |
| return nullptr; |
| } |
| return ParseRsaPublicKey(key.rsa2048_public_key()); |
| } |
| default: |
| return nullptr; |
| } |
| } |
| |
| unique_ptr<CryptoOps::PublicKey> PublicKeyProtoUtil::ParseEcPublicKey( |
| const EcP256PublicKey& key) { |
| return CryptoOps::ImportEcP256Key(key.x(), key.y()); |
| } |
| |
| unique_ptr<CryptoOps::PublicKey> PublicKeyProtoUtil::ParseRsaPublicKey( |
| const SimpleRsaPublicKey& key) { |
| return CryptoOps::ImportRsa2048Key(key.n(), key.e()); |
| } |
| |
| } // namespace securemessage |