Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 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/encryptor.h" |
| 6 | |
| 7 | #include "base/logging.h" |
| 8 | #include "base/sys_byteorder.h" |
| 9 | |
| 10 | namespace crypto { |
| 11 | |
| 12 | ///////////////////////////////////////////////////////////////////////////// |
| 13 | // Encyptor::Counter Implementation. |
| 14 | Encryptor::Counter::Counter(const base::StringPiece& counter) { |
| 15 | CHECK(sizeof(counter_) == counter.length()); |
| 16 | |
| 17 | memcpy(&counter_, counter.data(), sizeof(counter_)); |
| 18 | } |
| 19 | |
| 20 | Encryptor::Counter::~Counter() { |
| 21 | } |
| 22 | |
| 23 | bool Encryptor::Counter::Increment() { |
| 24 | uint64 low_num = base::NetToHost64(counter_.components64[1]); |
| 25 | uint64 new_low_num = low_num + 1; |
| 26 | counter_.components64[1] = base::HostToNet64(new_low_num); |
| 27 | |
| 28 | // If overflow occured then increment the most significant component. |
| 29 | if (new_low_num < low_num) { |
| 30 | counter_.components64[0] = |
| 31 | base::HostToNet64(base::NetToHost64(counter_.components64[0]) + 1); |
| 32 | } |
| 33 | |
| 34 | // TODO(hclam): Return false if counter value overflows. |
| 35 | return true; |
| 36 | } |
| 37 | |
| 38 | void Encryptor::Counter::Write(void* buf) { |
| 39 | uint8* buf_ptr = reinterpret_cast<uint8*>(buf); |
| 40 | memcpy(buf_ptr, &counter_, sizeof(counter_)); |
| 41 | } |
| 42 | |
| 43 | size_t Encryptor::Counter::GetLengthInBytes() const { |
| 44 | return sizeof(counter_); |
| 45 | } |
| 46 | |
| 47 | ///////////////////////////////////////////////////////////////////////////// |
| 48 | // Partial Encryptor Implementation. |
| 49 | |
| 50 | bool Encryptor::SetCounter(const base::StringPiece& counter) { |
| 51 | if (mode_ != CTR) |
| 52 | return false; |
| 53 | if (counter.length() != 16u) |
| 54 | return false; |
| 55 | |
| 56 | counter_.reset(new Counter(counter)); |
| 57 | return true; |
| 58 | } |
| 59 | |
| 60 | bool Encryptor::GenerateCounterMask(size_t plaintext_len, |
| 61 | uint8* mask, |
| 62 | size_t* mask_len) { |
| 63 | DCHECK_EQ(CTR, mode_); |
| 64 | CHECK(mask); |
| 65 | CHECK(mask_len); |
| 66 | |
| 67 | const size_t kBlockLength = counter_->GetLengthInBytes(); |
| 68 | size_t blocks = (plaintext_len + kBlockLength - 1) / kBlockLength; |
| 69 | CHECK(blocks); |
| 70 | |
| 71 | *mask_len = blocks * kBlockLength; |
| 72 | |
| 73 | for (size_t i = 0; i < blocks; ++i) { |
| 74 | counter_->Write(mask); |
| 75 | mask += kBlockLength; |
| 76 | |
| 77 | bool ret = counter_->Increment(); |
| 78 | if (!ret) |
| 79 | return false; |
| 80 | } |
| 81 | return true; |
| 82 | } |
| 83 | |
| 84 | void Encryptor::MaskMessage(const void* plaintext, |
| 85 | size_t plaintext_len, |
| 86 | const void* mask, |
| 87 | void* ciphertext) const { |
| 88 | DCHECK_EQ(CTR, mode_); |
| 89 | const uint8* plaintext_ptr = reinterpret_cast<const uint8*>(plaintext); |
| 90 | const uint8* mask_ptr = reinterpret_cast<const uint8*>(mask); |
| 91 | uint8* ciphertext_ptr = reinterpret_cast<uint8*>(ciphertext); |
| 92 | |
| 93 | for (size_t i = 0; i < plaintext_len; ++i) |
| 94 | ciphertext_ptr[i] = plaintext_ptr[i] ^ mask_ptr[i]; |
| 95 | } |
| 96 | |
| 97 | } // namespace crypto |