305 lines · cpp
1//====- SHA1.cpp - Private copy of the SHA1 implementation ---*- C++ -* ======//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.4// See https://llvm.org/LICENSE.txt for license information.5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception6//7//===----------------------------------------------------------------------===//8//9// This code is taken from public domain10// (http://oauth.googlecode.com/svn/code/c/liboauth/src/sha1.c and11// http://cvsweb.netbsd.org/bsdweb.cgi/src/common/lib/libc/hash/sha1/sha1.c?rev=1.6)12// and modified by wrapping it in a C++ interface for LLVM,13// and removing unnecessary code.14//15//===----------------------------------------------------------------------===//16 17#include "llvm/Support/SHA1.h"18#include "llvm/ADT/ArrayRef.h"19#include "llvm/ADT/StringRef.h"20#include "llvm/Support/Endian.h"21#include "llvm/Support/SwapByteOrder.h"22#include <string.h>23 24using namespace llvm;25 26static inline uint32_t rol(uint32_t Number, int Bits) {27 return (Number << Bits) | (Number >> (32 - Bits));28}29 30static inline uint32_t blk0(uint32_t *Buf, int I) { return Buf[I]; }31 32static inline uint32_t blk(uint32_t *Buf, int I) {33 Buf[I & 15] = rol(Buf[(I + 13) & 15] ^ Buf[(I + 8) & 15] ^ Buf[(I + 2) & 15] ^34 Buf[I & 15],35 1);36 return Buf[I & 15];37}38 39static inline void r0(uint32_t &A, uint32_t &B, uint32_t &C, uint32_t &D,40 uint32_t &E, int I, uint32_t *Buf) {41 E += ((B & (C ^ D)) ^ D) + blk0(Buf, I) + 0x5A827999 + rol(A, 5);42 B = rol(B, 30);43}44 45static inline void r1(uint32_t &A, uint32_t &B, uint32_t &C, uint32_t &D,46 uint32_t &E, int I, uint32_t *Buf) {47 E += ((B & (C ^ D)) ^ D) + blk(Buf, I) + 0x5A827999 + rol(A, 5);48 B = rol(B, 30);49}50 51static inline void r2(uint32_t &A, uint32_t &B, uint32_t &C, uint32_t &D,52 uint32_t &E, int I, uint32_t *Buf) {53 E += (B ^ C ^ D) + blk(Buf, I) + 0x6ED9EBA1 + rol(A, 5);54 B = rol(B, 30);55}56 57static inline void r3(uint32_t &A, uint32_t &B, uint32_t &C, uint32_t &D,58 uint32_t &E, int I, uint32_t *Buf) {59 E += (((B | C) & D) | (B & C)) + blk(Buf, I) + 0x8F1BBCDC + rol(A, 5);60 B = rol(B, 30);61}62 63static inline void r4(uint32_t &A, uint32_t &B, uint32_t &C, uint32_t &D,64 uint32_t &E, int I, uint32_t *Buf) {65 E += (B ^ C ^ D) + blk(Buf, I) + 0xCA62C1D6 + rol(A, 5);66 B = rol(B, 30);67}68 69/* code */70#define SHA1_K0 0x5a82799971#define SHA1_K20 0x6ed9eba172#define SHA1_K40 0x8f1bbcdc73#define SHA1_K60 0xca62c1d674 75#define SEED_0 0x6745230176#define SEED_1 0xefcdab8977#define SEED_2 0x98badcfe78#define SEED_3 0x1032547679#define SEED_4 0xc3d2e1f080 81void SHA1::init() {82 InternalState.State[0] = SEED_0;83 InternalState.State[1] = SEED_1;84 InternalState.State[2] = SEED_2;85 InternalState.State[3] = SEED_3;86 InternalState.State[4] = SEED_4;87 InternalState.ByteCount = 0;88 InternalState.BufferOffset = 0;89}90 91void SHA1::hashBlock() {92 uint32_t A = InternalState.State[0];93 uint32_t B = InternalState.State[1];94 uint32_t C = InternalState.State[2];95 uint32_t D = InternalState.State[3];96 uint32_t E = InternalState.State[4];97 98 // 4 rounds of 20 operations each. Loop unrolled.99 r0(A, B, C, D, E, 0, InternalState.Buffer.L);100 r0(E, A, B, C, D, 1, InternalState.Buffer.L);101 r0(D, E, A, B, C, 2, InternalState.Buffer.L);102 r0(C, D, E, A, B, 3, InternalState.Buffer.L);103 r0(B, C, D, E, A, 4, InternalState.Buffer.L);104 r0(A, B, C, D, E, 5, InternalState.Buffer.L);105 r0(E, A, B, C, D, 6, InternalState.Buffer.L);106 r0(D, E, A, B, C, 7, InternalState.Buffer.L);107 r0(C, D, E, A, B, 8, InternalState.Buffer.L);108 r0(B, C, D, E, A, 9, InternalState.Buffer.L);109 r0(A, B, C, D, E, 10, InternalState.Buffer.L);110 r0(E, A, B, C, D, 11, InternalState.Buffer.L);111 r0(D, E, A, B, C, 12, InternalState.Buffer.L);112 r0(C, D, E, A, B, 13, InternalState.Buffer.L);113 r0(B, C, D, E, A, 14, InternalState.Buffer.L);114 r0(A, B, C, D, E, 15, InternalState.Buffer.L);115 r1(E, A, B, C, D, 16, InternalState.Buffer.L);116 r1(D, E, A, B, C, 17, InternalState.Buffer.L);117 r1(C, D, E, A, B, 18, InternalState.Buffer.L);118 r1(B, C, D, E, A, 19, InternalState.Buffer.L);119 120 r2(A, B, C, D, E, 20, InternalState.Buffer.L);121 r2(E, A, B, C, D, 21, InternalState.Buffer.L);122 r2(D, E, A, B, C, 22, InternalState.Buffer.L);123 r2(C, D, E, A, B, 23, InternalState.Buffer.L);124 r2(B, C, D, E, A, 24, InternalState.Buffer.L);125 r2(A, B, C, D, E, 25, InternalState.Buffer.L);126 r2(E, A, B, C, D, 26, InternalState.Buffer.L);127 r2(D, E, A, B, C, 27, InternalState.Buffer.L);128 r2(C, D, E, A, B, 28, InternalState.Buffer.L);129 r2(B, C, D, E, A, 29, InternalState.Buffer.L);130 r2(A, B, C, D, E, 30, InternalState.Buffer.L);131 r2(E, A, B, C, D, 31, InternalState.Buffer.L);132 r2(D, E, A, B, C, 32, InternalState.Buffer.L);133 r2(C, D, E, A, B, 33, InternalState.Buffer.L);134 r2(B, C, D, E, A, 34, InternalState.Buffer.L);135 r2(A, B, C, D, E, 35, InternalState.Buffer.L);136 r2(E, A, B, C, D, 36, InternalState.Buffer.L);137 r2(D, E, A, B, C, 37, InternalState.Buffer.L);138 r2(C, D, E, A, B, 38, InternalState.Buffer.L);139 r2(B, C, D, E, A, 39, InternalState.Buffer.L);140 141 r3(A, B, C, D, E, 40, InternalState.Buffer.L);142 r3(E, A, B, C, D, 41, InternalState.Buffer.L);143 r3(D, E, A, B, C, 42, InternalState.Buffer.L);144 r3(C, D, E, A, B, 43, InternalState.Buffer.L);145 r3(B, C, D, E, A, 44, InternalState.Buffer.L);146 r3(A, B, C, D, E, 45, InternalState.Buffer.L);147 r3(E, A, B, C, D, 46, InternalState.Buffer.L);148 r3(D, E, A, B, C, 47, InternalState.Buffer.L);149 r3(C, D, E, A, B, 48, InternalState.Buffer.L);150 r3(B, C, D, E, A, 49, InternalState.Buffer.L);151 r3(A, B, C, D, E, 50, InternalState.Buffer.L);152 r3(E, A, B, C, D, 51, InternalState.Buffer.L);153 r3(D, E, A, B, C, 52, InternalState.Buffer.L);154 r3(C, D, E, A, B, 53, InternalState.Buffer.L);155 r3(B, C, D, E, A, 54, InternalState.Buffer.L);156 r3(A, B, C, D, E, 55, InternalState.Buffer.L);157 r3(E, A, B, C, D, 56, InternalState.Buffer.L);158 r3(D, E, A, B, C, 57, InternalState.Buffer.L);159 r3(C, D, E, A, B, 58, InternalState.Buffer.L);160 r3(B, C, D, E, A, 59, InternalState.Buffer.L);161 162 r4(A, B, C, D, E, 60, InternalState.Buffer.L);163 r4(E, A, B, C, D, 61, InternalState.Buffer.L);164 r4(D, E, A, B, C, 62, InternalState.Buffer.L);165 r4(C, D, E, A, B, 63, InternalState.Buffer.L);166 r4(B, C, D, E, A, 64, InternalState.Buffer.L);167 r4(A, B, C, D, E, 65, InternalState.Buffer.L);168 r4(E, A, B, C, D, 66, InternalState.Buffer.L);169 r4(D, E, A, B, C, 67, InternalState.Buffer.L);170 r4(C, D, E, A, B, 68, InternalState.Buffer.L);171 r4(B, C, D, E, A, 69, InternalState.Buffer.L);172 r4(A, B, C, D, E, 70, InternalState.Buffer.L);173 r4(E, A, B, C, D, 71, InternalState.Buffer.L);174 r4(D, E, A, B, C, 72, InternalState.Buffer.L);175 r4(C, D, E, A, B, 73, InternalState.Buffer.L);176 r4(B, C, D, E, A, 74, InternalState.Buffer.L);177 r4(A, B, C, D, E, 75, InternalState.Buffer.L);178 r4(E, A, B, C, D, 76, InternalState.Buffer.L);179 r4(D, E, A, B, C, 77, InternalState.Buffer.L);180 r4(C, D, E, A, B, 78, InternalState.Buffer.L);181 r4(B, C, D, E, A, 79, InternalState.Buffer.L);182 183 InternalState.State[0] += A;184 InternalState.State[1] += B;185 InternalState.State[2] += C;186 InternalState.State[3] += D;187 InternalState.State[4] += E;188}189 190void SHA1::addUncounted(uint8_t Data) {191 if constexpr (sys::IsBigEndianHost)192 InternalState.Buffer.C[InternalState.BufferOffset] = Data;193 else194 InternalState.Buffer.C[InternalState.BufferOffset ^ 3] = Data;195 196 InternalState.BufferOffset++;197 if (InternalState.BufferOffset == BLOCK_LENGTH) {198 hashBlock();199 InternalState.BufferOffset = 0;200 }201}202 203void SHA1::writebyte(uint8_t Data) {204 ++InternalState.ByteCount;205 addUncounted(Data);206}207 208void SHA1::update(ArrayRef<uint8_t> Data) {209 InternalState.ByteCount += Data.size();210 211 // Finish the current block.212 if (InternalState.BufferOffset > 0) {213 const size_t Remainder = std::min<size_t>(214 Data.size(), BLOCK_LENGTH - InternalState.BufferOffset);215 for (size_t I = 0; I < Remainder; ++I)216 addUncounted(Data[I]);217 Data = Data.drop_front(Remainder);218 }219 220 // Fast buffer filling for large inputs.221 while (Data.size() >= BLOCK_LENGTH) {222 assert(InternalState.BufferOffset == 0);223 static_assert(BLOCK_LENGTH % 4 == 0);224 constexpr size_t BLOCK_LENGTH_32 = BLOCK_LENGTH / 4;225 for (size_t I = 0; I < BLOCK_LENGTH_32; ++I)226 InternalState.Buffer.L[I] = support::endian::read32be(&Data[I * 4]);227 hashBlock();228 Data = Data.drop_front(BLOCK_LENGTH);229 }230 231 // Finish the remainder.232 for (uint8_t C : Data)233 addUncounted(C);234}235 236void SHA1::update(StringRef Str) {237 update(238 ArrayRef<uint8_t>((uint8_t *)const_cast<char *>(Str.data()), Str.size()));239}240 241void SHA1::pad() {242 // Implement SHA-1 padding (fips180-2 5.1.1)243 244 // Pad with 0x80 followed by 0x00 until the end of the block245 addUncounted(0x80);246 while (InternalState.BufferOffset != 56)247 addUncounted(0x00);248 249 // Append length in the last 8 bytes250 addUncounted(0); // We're only using 32 bit lengths251 addUncounted(0); // But SHA-1 supports 64 bit lengths252 addUncounted(0); // So zero pad the top bits253 addUncounted(InternalState.ByteCount >> 29); // Shifting to multiply by 8254 addUncounted(InternalState.ByteCount >>255 21); // as SHA-1 supports bitstreams as well as256 addUncounted(InternalState.ByteCount >> 13); // byte.257 addUncounted(InternalState.ByteCount >> 5);258 addUncounted(InternalState.ByteCount << 3);259}260 261void SHA1::final(std::array<uint32_t, HASH_LENGTH / 4> &HashResult) {262 // Pad to complete the last block263 pad();264 265 if constexpr (sys::IsBigEndianHost) {266 // Just copy the current state267 for (int i = 0; i < 5; i++) {268 HashResult[i] = InternalState.State[i];269 }270 } else {271 // Swap byte order back272 for (int i = 0; i < 5; i++) {273 HashResult[i] = llvm::byteswap(InternalState.State[i]);274 }275 }276}277 278std::array<uint8_t, 20> SHA1::final() {279 union {280 std::array<uint32_t, HASH_LENGTH / 4> HashResult;281 std::array<uint8_t, HASH_LENGTH> ReturnResult;282 };283 static_assert(sizeof(HashResult) == sizeof(ReturnResult));284 final(HashResult);285 return ReturnResult;286}287 288std::array<uint8_t, 20> SHA1::result() {289 auto StateToRestore = InternalState;290 291 auto Hash = final();292 293 // Restore the state294 InternalState = StateToRestore;295 296 // Return pointer to hash (20 characters)297 return Hash;298}299 300std::array<uint8_t, 20> SHA1::hash(ArrayRef<uint8_t> Data) {301 SHA1 Hash;302 Hash.update(Data);303 return Hash.final();304}305