crypto/signature_creator_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "crypto/signature_creator.h"
   6
   7 #include <stdint.h>
   8
   9 #include <memory>
  10 #include <string>
  11 #include <vector>
  12
  13 #include "base/sha1.h"
  14 #include "crypto/rsa_private_key.h"
  15 #include "crypto/sha2.h"
  16 #include "crypto/signature_verifier.h"
  17 #include "testing/gtest/include/gtest/gtest.h"
  18
  19 TEST(SignatureCreatorTest, BasicTest) {
  20   // Do a verify round trip.
  21   std::unique_ptr<crypto::RSAPrivateKey> key_original(
  22       crypto::RSAPrivateKey::Create(1024));
  23   ASSERT_TRUE(key_original.get());
  24
  25   std::vector<uint8_t> key_info;
  26   key_original->ExportPrivateKey(&key_info);
  27   std::unique_ptr<crypto::RSAPrivateKey> key(
  28       crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(key_info));
  29   ASSERT_TRUE(key.get());
  30
  31   std::unique_ptr<crypto::SignatureCreator> signer(
  32       crypto::SignatureCreator::Create(key.get(),
  33                                        crypto::SignatureCreator::SHA1));
  34   ASSERT_TRUE(signer.get());
  35
  36   std::string data("Hello, World!");
  37   ASSERT_TRUE(signer->Update(reinterpret_cast<const uint8_t*>(data.c_str()),
  38                              data.size()));
  39
  40   std::vector<uint8_t> signature;
  41   ASSERT_TRUE(signer->Final(&signature));
  42
  43   std::vector<uint8_t> public_key_info;
  44   ASSERT_TRUE(key_original->ExportPublicKey(&public_key_info));
  45
  46   crypto::SignatureVerifier verifier;
  47   ASSERT_TRUE(verifier.VerifyInit(
  48       crypto::SignatureVerifier::RSA_PKCS1_SHA1, &signature.front(),
  49       signature.size(), &public_key_info.front(), public_key_info.size()));
  50
  51   verifier.VerifyUpdate(reinterpret_cast<const uint8_t*>(data.c_str()),
  52                         data.size());
  53   ASSERT_TRUE(verifier.VerifyFinal());
  54 }
  55
  56 TEST(SignatureCreatorTest, SignDigestTest) {
  57   // Do a verify round trip.
  58   std::unique_ptr<crypto::RSAPrivateKey> key_original(
  59       crypto::RSAPrivateKey::Create(1024));
  60   ASSERT_TRUE(key_original.get());
  61
  62   std::vector<uint8_t> key_info;
  63   key_original->ExportPrivateKey(&key_info);
  64   std::unique_ptr<crypto::RSAPrivateKey> key(
  65       crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(key_info));
  66   ASSERT_TRUE(key.get());
  67
  68   std::string data("Hello, World!");
  69   std::string sha1 = base::SHA1HashString(data);
  70   // Sign sha1 of the input data.
  71   std::vector<uint8_t> signature;
  72   ASSERT_TRUE(crypto::SignatureCreator::Sign(
  73       key.get(), crypto::SignatureCreator::SHA1,
  74       reinterpret_cast<const uint8_t*>(sha1.c_str()), sha1.size(), &signature));
  75
  76   std::vector<uint8_t> public_key_info;
  77   ASSERT_TRUE(key_original->ExportPublicKey(&public_key_info));
  78
  79   // Verify the input data.
  80   crypto::SignatureVerifier verifier;
  81   ASSERT_TRUE(verifier.VerifyInit(
  82       crypto::SignatureVerifier::RSA_PKCS1_SHA1, &signature.front(),
  83       signature.size(), &public_key_info.front(), public_key_info.size()));
  84
  85   verifier.VerifyUpdate(reinterpret_cast<const uint8_t*>(data.c_str()),
  86                         data.size());
  87   ASSERT_TRUE(verifier.VerifyFinal());
  88 }
  89
  90 TEST(SignatureCreatorTest, SignSHA256DigestTest) {
  91   // Do a verify round trip.
  92   std::unique_ptr<crypto::RSAPrivateKey> key_original(
  93       crypto::RSAPrivateKey::Create(1024));
  94   ASSERT_TRUE(key_original.get());
  95
  96   std::vector<uint8_t> key_info;
  97   key_original->ExportPrivateKey(&key_info);
  98   std::unique_ptr<crypto::RSAPrivateKey> key(
  99       crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(key_info));
 100   ASSERT_TRUE(key.get());
 101
 102   std::string data("Hello, World!");
 103   std::string sha256 = crypto::SHA256HashString(data);
 104   // Sign sha256 of the input data.
 105   std::vector<uint8_t> signature;
 106   ASSERT_TRUE(crypto::SignatureCreator::Sign(
 107       key.get(), crypto::SignatureCreator::HashAlgorithm::SHA256,
 108       reinterpret_cast<const uint8_t*>(sha256.c_str()), sha256.size(),
 109       &signature));
 110
 111   std::vector<uint8_t> public_key_info;
 112   ASSERT_TRUE(key_original->ExportPublicKey(&public_key_info));
 113
 114   // Verify the input data.
 115   crypto::SignatureVerifier verifier;
 116   ASSERT_TRUE(verifier.VerifyInit(
 117       crypto::SignatureVerifier::RSA_PKCS1_SHA256, &signature.front(),
 118       signature.size(), &public_key_info.front(), public_key_info.size()));
 119
 120   verifier.VerifyUpdate(reinterpret_cast<const uint8_t*>(data.c_str()),
 121                         data.size());
 122   ASSERT_TRUE(verifier.VerifyFinal());
 123 }