blob: 7aeea64fdfc176ef9bf52cb4ee6ded274cff39f5 [file] [log] [blame]
Yingdi Yude222c72014-08-15 16:06:52 -07001/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
Davide Pesavento94368312017-07-08 22:25:03 -04002/*
Alexander Afanasyev574aa862017-01-10 19:53:28 -08003 * Copyright (c) 2013-2017 Regents of the University of California.
Yingdi Yude222c72014-08-15 16:06:52 -07004 *
5 * This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
6 *
7 * ndn-cxx library is free software: you can redistribute it and/or modify it under the
8 * terms of the GNU Lesser General Public License as published by the Free Software
9 * Foundation, either version 3 of the License, or (at your option) any later version.
10 *
11 * ndn-cxx library is distributed in the hope that it will be useful, but WITHOUT ANY
12 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
13 * PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
14 *
15 * You should have received copies of the GNU General Public License and GNU Lesser
16 * General Public License along with ndn-cxx, e.g., in COPYING.md file. If not, see
17 * <http://www.gnu.org/licenses/>.
18 *
19 * See AUTHORS.md for complete list of ndn-cxx authors and contributors.
20 */
21
Junxiao Shi6938e342017-07-25 21:56:58 +000022#include "sha256.hpp"
Alexander Afanasyev8828ca62015-07-02 13:40:09 -070023#include "string-helper.hpp"
Davide Pesavento94368312017-07-08 22:25:03 -040024#include "../security/detail/openssl.hpp"
25#include "../security/transform/digest-filter.hpp"
26#include "../security/transform/stream-sink.hpp"
27#include "../security/transform/stream-source.hpp"
Yingdi Yude222c72014-08-15 16:06:52 -070028
29namespace ndn {
30namespace util {
31
Davide Pesavento10b24be2017-07-12 23:23:46 -040032const size_t Sha256::DIGEST_SIZE;
33
Davide Pesavento94368312017-07-08 22:25:03 -040034Sha256::Sha256()
35{
36 reset();
37}
38
39Sha256::Sha256(std::istream& is)
40 : m_output(make_unique<OBufferStream>())
41 , m_isEmpty(false)
42 , m_isFinalized(true)
43{
44 namespace tr = security::transform;
45
46 tr::streamSource(is) >> tr::digestFilter(DigestAlgorithm::SHA256) >> tr::streamSink(*m_output);
47}
48
49void
50Sha256::reset()
51{
52 namespace tr = security::transform;
53
54 m_input = make_unique<tr::StepSource>();
55 m_output = make_unique<OBufferStream>();
56 m_isEmpty = true;
57 m_isFinalized = false;
58
59 *m_input >> tr::digestFilter(DigestAlgorithm::SHA256) >> tr::streamSink(*m_output);
60}
61
62ConstBufferPtr
63Sha256::computeDigest()
64{
65 if (!m_isFinalized) {
66 BOOST_ASSERT(m_input != nullptr);
67 m_input->end();
68 m_isFinalized = true;
69 }
70
71 return m_output->buf();
72}
73
74bool
75Sha256::operator==(Sha256& digest)
76{
77 const Buffer& lhs = *computeDigest();
78 const Buffer& rhs = *digest.computeDigest();
79
80 if (lhs.size() != rhs.size()) {
81 return false;
82 }
83
84 // constant-time buffer comparison to mitigate timing attacks
85 return CRYPTO_memcmp(lhs.get(), rhs.get(), lhs.size()) == 0;
86}
87
88Sha256&
89Sha256::operator<<(Sha256& src)
90{
91 auto buf = src.computeDigest();
92 update(buf->get(), buf->size());
93 return *this;
94}
95
96Sha256&
97Sha256::operator<<(const std::string& str)
98{
99 update(reinterpret_cast<const uint8_t*>(str.data()), str.size());
100 return *this;
101}
102
103Sha256&
104Sha256::operator<<(const Block& block)
105{
106 update(block.wire(), block.size());
107 return *this;
108}
109
110Sha256&
111Sha256::operator<<(uint64_t value)
112{
113 update(reinterpret_cast<const uint8_t*>(&value), sizeof(uint64_t));
114 return *this;
115}
116
117void
118Sha256::update(const uint8_t* buffer, size_t size)
119{
120 if (m_isFinalized)
121 BOOST_THROW_EXCEPTION(Error("Digest has been already finalized"));
122
123 BOOST_ASSERT(m_input != nullptr);
124 m_input->write(buffer, size);
125 m_isEmpty = false;
126}
127
128std::string
129Sha256::toString()
130{
131 auto buf = computeDigest();
132 return toHex(*buf);
133}
134
Davide Pesavento10b24be2017-07-12 23:23:46 -0400135ConstBufferPtr
136Sha256::computeDigest(const uint8_t* buffer, size_t size)
137{
138 Sha256 sha256;
139 sha256.update(buffer, size);
140 return sha256.computeDigest();
141}
142
Yingdi Yu9ad2d722014-08-30 16:13:57 -0700143std::ostream&
Davide Pesavento94368312017-07-08 22:25:03 -0400144operator<<(std::ostream& os, Sha256& digest)
145{
146 auto buf = digest.computeDigest();
147 printHex(os, *buf);
148 return os;
149}
Yingdi Yude222c72014-08-15 16:06:52 -0700150
151} // namespace util
152} // namespace ndn