From c6c44aa5d1043547cd96134a386609601514ccdb Mon Sep 17 00:00:00 2001 From: Jeffrey Walton Date: Tue, 10 Jul 2018 05:00:02 -0400 Subject: [PATCH] Add PtrAdd and PtrSub helper functions This helps contain UB on pointer subtraction by ensuring a ptrdiff_t is used. The code is a little uglier but it is also more portable. --- adv-simd.h | 684 +++++++++++++++++++++++++------------------------- cryptlib.cpp | 20 +- filters.cpp | 33 ++- misc.h | 26 ++ modes.cpp | 59 ++--- neon-simd.cpp | 11 +- strciphr.cpp | 81 +++--- 7 files changed, 468 insertions(+), 446 deletions(-) diff --git a/adv-simd.h b/adv-simd.h index 4df79e9f..c686cedd 100644 --- a/adv-simd.h +++ b/adv-simd.h @@ -104,12 +104,12 @@ inline size_t AdvancedProcessBlocks64_6x2_NEON(F2 func2, F6 func6, const word32 s_one32x4_2b[] = {0, 2, 0, 2}; #endif - const ptrdiff_t blockSize = 8; - const ptrdiff_t neonBlockSize = 16; + const size_t blockSize = 8; + const size_t neonBlockSize = 16; - ptrdiff_t inIncrement = (flags & (BT_InBlockIsCounter|BT_DontIncrementInOutPointers)) ? 0 : neonBlockSize; - ptrdiff_t xorIncrement = (xorBlocks != NULLPTR) ? neonBlockSize : 0; - ptrdiff_t outIncrement = (flags & BT_DontIncrementInOutPointers) ? 0 : neonBlockSize; + size_t inIncrement = (flags & (BT_InBlockIsCounter|BT_DontIncrementInOutPointers)) ? 0 : neonBlockSize; + size_t xorIncrement = (xorBlocks != NULLPTR) ? neonBlockSize : 0; + size_t outIncrement = (flags & BT_DontIncrementInOutPointers) ? 0 : neonBlockSize; // Clang and Coverity are generating findings using xorBlocks as a flag. const bool xorInput = (xorBlocks != NULLPTR) && (flags & BT_XorInput); @@ -117,9 +117,9 @@ inline size_t AdvancedProcessBlocks64_6x2_NEON(F2 func2, F6 func6, if (flags & BT_ReverseDirection) { - inBlocks += static_cast(length) - neonBlockSize; - xorBlocks += static_cast(length) - neonBlockSize; - outBlocks += static_cast(length) - neonBlockSize; + inBlocks = PtrAdd(inBlocks, length - neonBlockSize); + xorBlocks = PtrAdd(xorBlocks, length - neonBlockSize); + outBlocks = PtrAdd(outBlocks, length - neonBlockSize); inIncrement = 0-inIncrement; xorIncrement = 0-xorIncrement; outIncrement = 0-outIncrement; @@ -153,33 +153,33 @@ inline size_t AdvancedProcessBlocks64_6x2_NEON(F2 func2, F6 func6, else { block0 = vreinterpretq_u32_u8(vld1q_u8(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block1 = vreinterpretq_u32_u8(vld1q_u8(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block2 = vreinterpretq_u32_u8(vld1q_u8(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block3 = vreinterpretq_u32_u8(vld1q_u8(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block4 = vreinterpretq_u32_u8(vld1q_u8(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block5 = vreinterpretq_u32_u8(vld1q_u8(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); } if (xorInput) { block0 = veorq_u32(block0, vreinterpretq_u32_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block1 = veorq_u32(block1, vreinterpretq_u32_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block2 = veorq_u32(block2, vreinterpretq_u32_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block3 = veorq_u32(block3, vreinterpretq_u32_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block4 = veorq_u32(block4, vreinterpretq_u32_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block5 = veorq_u32(block5, vreinterpretq_u32_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); } func6(block0, block1, block2, block3, block4, block5, subKeys, static_cast(rounds)); @@ -187,31 +187,31 @@ inline size_t AdvancedProcessBlocks64_6x2_NEON(F2 func2, F6 func6, if (xorOutput) { block0 = veorq_u32(block0, vreinterpretq_u32_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block1 = veorq_u32(block1, vreinterpretq_u32_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block2 = veorq_u32(block2, vreinterpretq_u32_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block3 = veorq_u32(block3, vreinterpretq_u32_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block4 = veorq_u32(block4, vreinterpretq_u32_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block5 = veorq_u32(block5, vreinterpretq_u32_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); } vst1q_u8(outBlocks, vreinterpretq_u8_u32(block0)); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); vst1q_u8(outBlocks, vreinterpretq_u8_u32(block1)); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); vst1q_u8(outBlocks, vreinterpretq_u8_u32(block2)); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); vst1q_u8(outBlocks, vreinterpretq_u8_u32(block3)); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); vst1q_u8(outBlocks, vreinterpretq_u8_u32(block4)); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); vst1q_u8(outBlocks, vreinterpretq_u8_u32(block5)); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); length -= 6*neonBlockSize; } @@ -238,17 +238,17 @@ inline size_t AdvancedProcessBlocks64_6x2_NEON(F2 func2, F6 func6, else { block0 = vreinterpretq_u32_u8(vld1q_u8(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block1 = vreinterpretq_u32_u8(vld1q_u8(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); } if (xorInput) { block0 = veorq_u32(block0, vreinterpretq_u32_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block1 = veorq_u32(block1, vreinterpretq_u32_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); } func2(block0, block1, subKeys, static_cast(rounds)); @@ -256,15 +256,15 @@ inline size_t AdvancedProcessBlocks64_6x2_NEON(F2 func2, F6 func6, if (xorOutput) { block0 = veorq_u32(block0, vreinterpretq_u32_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block1 = veorq_u32(block1, vreinterpretq_u32_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); } vst1q_u8(outBlocks, vreinterpretq_u8_u32(block0)); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); vst1q_u8(outBlocks, vreinterpretq_u8_u32(block1)); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); length -= 2*neonBlockSize; } @@ -316,9 +316,9 @@ inline size_t AdvancedProcessBlocks64_6x2_NEON(F2 func2, F6 func6, vst1_u8(const_cast(outBlocks), vget_low_u8(vreinterpretq_u8_u32(block))); - inBlocks += inIncrement; - outBlocks += outIncrement; - xorBlocks += xorIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); + outBlocks = PtrAdd(outBlocks, outIncrement); + xorBlocks = PtrAdd(xorBlocks, xorIncrement); length -= blockSize; } } @@ -352,12 +352,12 @@ inline size_t AdvancedProcessBlocks128_6x1_NEON(F1 func1, F6 func6, const word32 s_one32x4[] = {0, 0, 0, 1}; #endif - const ptrdiff_t blockSize = 16; - // const ptrdiff_t neonBlockSize = 16; + const size_t blockSize = 16; + // const size_t neonBlockSize = 16; - ptrdiff_t inIncrement = (flags & (BT_InBlockIsCounter|BT_DontIncrementInOutPointers)) ? 0 : blockSize; - ptrdiff_t xorIncrement = (xorBlocks != NULLPTR) ? blockSize : 0; - ptrdiff_t outIncrement = (flags & BT_DontIncrementInOutPointers) ? 0 : blockSize; + size_t inIncrement = (flags & (BT_InBlockIsCounter|BT_DontIncrementInOutPointers)) ? 0 : blockSize; + size_t xorIncrement = (xorBlocks != NULLPTR) ? blockSize : 0; + size_t outIncrement = (flags & BT_DontIncrementInOutPointers) ? 0 : blockSize; // Clang and Coverity are generating findings using xorBlocks as a flag. const bool xorInput = (xorBlocks != NULLPTR) && (flags & BT_XorInput); @@ -365,9 +365,9 @@ inline size_t AdvancedProcessBlocks128_6x1_NEON(F1 func1, F6 func6, if (flags & BT_ReverseDirection) { - inBlocks += static_cast(length) - blockSize; - xorBlocks += static_cast(length) - blockSize; - outBlocks += static_cast(length) - blockSize; + inBlocks = PtrAdd(inBlocks, length - blockSize); + xorBlocks = PtrAdd(xorBlocks, length - blockSize); + outBlocks = PtrAdd(outBlocks, length - blockSize); inIncrement = 0-inIncrement; xorIncrement = 0-xorIncrement; outIncrement = 0-outIncrement; @@ -394,33 +394,33 @@ inline size_t AdvancedProcessBlocks128_6x1_NEON(F1 func1, F6 func6, else { block0 = vreinterpretq_u64_u8(vld1q_u8(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block1 = vreinterpretq_u64_u8(vld1q_u8(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block2 = vreinterpretq_u64_u8(vld1q_u8(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block3 = vreinterpretq_u64_u8(vld1q_u8(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block4 = vreinterpretq_u64_u8(vld1q_u8(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block5 = vreinterpretq_u64_u8(vld1q_u8(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); } if (xorInput) { block0 = veorq_u64(block0, vreinterpretq_u64_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block1 = veorq_u64(block1, vreinterpretq_u64_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block2 = veorq_u64(block2, vreinterpretq_u64_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block3 = veorq_u64(block3, vreinterpretq_u64_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block4 = veorq_u64(block4, vreinterpretq_u64_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block5 = veorq_u64(block5, vreinterpretq_u64_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); } func6(block0, block1, block2, block3, block4, block5, subKeys, static_cast(rounds)); @@ -428,31 +428,31 @@ inline size_t AdvancedProcessBlocks128_6x1_NEON(F1 func1, F6 func6, if (xorOutput) { block0 = veorq_u64(block0, vreinterpretq_u64_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block1 = veorq_u64(block1, vreinterpretq_u64_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block2 = veorq_u64(block2, vreinterpretq_u64_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block3 = veorq_u64(block3, vreinterpretq_u64_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block4 = veorq_u64(block4, vreinterpretq_u64_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block5 = veorq_u64(block5, vreinterpretq_u64_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); } vst1q_u8(outBlocks, vreinterpretq_u8_u64(block0)); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); vst1q_u8(outBlocks, vreinterpretq_u8_u64(block1)); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); vst1q_u8(outBlocks, vreinterpretq_u8_u64(block2)); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); vst1q_u8(outBlocks, vreinterpretq_u8_u64(block3)); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); vst1q_u8(outBlocks, vreinterpretq_u8_u64(block4)); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); vst1q_u8(outBlocks, vreinterpretq_u8_u64(block5)); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); length -= 6*blockSize; } @@ -476,9 +476,9 @@ inline size_t AdvancedProcessBlocks128_6x1_NEON(F1 func1, F6 func6, vst1q_u8(outBlocks, vreinterpretq_u8_u64(block)); - inBlocks += inIncrement; - outBlocks += outIncrement; - xorBlocks += xorIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); + outBlocks = PtrAdd(outBlocks, outIncrement); + xorBlocks = PtrAdd(xorBlocks, xorIncrement); length -= blockSize; } @@ -513,12 +513,12 @@ inline size_t AdvancedProcessBlocks128_4x1_NEON(F1 func1, F4 func4, const word32 s_one32x4[] = {0, 0, 0, 1}; #endif - const ptrdiff_t blockSize = 16; - // const ptrdiff_t neonBlockSize = 16; + const size_t blockSize = 16; + // const size_t neonBlockSize = 16; - ptrdiff_t inIncrement = (flags & (BT_InBlockIsCounter|BT_DontIncrementInOutPointers)) ? 0 : blockSize; - ptrdiff_t xorIncrement = (xorBlocks != NULLPTR) ? blockSize : 0; - ptrdiff_t outIncrement = (flags & BT_DontIncrementInOutPointers) ? 0 : blockSize; + size_t inIncrement = (flags & (BT_InBlockIsCounter|BT_DontIncrementInOutPointers)) ? 0 : blockSize; + size_t xorIncrement = (xorBlocks != NULLPTR) ? blockSize : 0; + size_t outIncrement = (flags & BT_DontIncrementInOutPointers) ? 0 : blockSize; // Clang and Coverity are generating findings using xorBlocks as a flag. const bool xorInput = (xorBlocks != NULLPTR) && (flags & BT_XorInput); @@ -526,9 +526,9 @@ inline size_t AdvancedProcessBlocks128_4x1_NEON(F1 func1, F4 func4, if (flags & BT_ReverseDirection) { - inBlocks += static_cast(length) - blockSize; - xorBlocks += static_cast(length) - blockSize; - outBlocks += static_cast(length) - blockSize; + inBlocks = PtrAdd(inBlocks, length - blockSize); + xorBlocks = PtrAdd(xorBlocks, length - blockSize); + outBlocks = PtrAdd(outBlocks, length - blockSize); inIncrement = 0-inIncrement; xorIncrement = 0-xorIncrement; outIncrement = 0-outIncrement; @@ -553,25 +553,25 @@ inline size_t AdvancedProcessBlocks128_4x1_NEON(F1 func1, F4 func4, else { block0 = vreinterpretq_u64_u8(vld1q_u8(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block1 = vreinterpretq_u64_u8(vld1q_u8(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block2 = vreinterpretq_u64_u8(vld1q_u8(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block3 = vreinterpretq_u64_u8(vld1q_u8(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); } if (xorInput) { block0 = veorq_u64(block0, vreinterpretq_u64_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block1 = veorq_u64(block1, vreinterpretq_u64_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block2 = veorq_u64(block2, vreinterpretq_u64_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block3 = veorq_u64(block3, vreinterpretq_u64_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); } func4((V&)block0, (V&)block1, (V&)block2, (V&)block3, subKeys, static_cast(rounds)); @@ -579,23 +579,23 @@ inline size_t AdvancedProcessBlocks128_4x1_NEON(F1 func1, F4 func4, if (xorOutput) { block0 = veorq_u64(block0, vreinterpretq_u64_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block1 = veorq_u64(block1, vreinterpretq_u64_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block2 = veorq_u64(block2, vreinterpretq_u64_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block3 = veorq_u64(block3, vreinterpretq_u64_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); } vst1q_u8(outBlocks, vreinterpretq_u8_u64(block0)); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); vst1q_u8(outBlocks, vreinterpretq_u8_u64(block1)); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); vst1q_u8(outBlocks, vreinterpretq_u8_u64(block2)); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); vst1q_u8(outBlocks, vreinterpretq_u8_u64(block3)); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); length -= 4*blockSize; } @@ -618,9 +618,9 @@ inline size_t AdvancedProcessBlocks128_4x1_NEON(F1 func1, F4 func4, vst1q_u8(outBlocks, vreinterpretq_u8_u64(block)); - inBlocks += inIncrement; - outBlocks += outIncrement; - xorBlocks += xorIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); + outBlocks = PtrAdd(outBlocks, outIncrement); + xorBlocks = PtrAdd(xorBlocks, xorIncrement); length -= blockSize; } @@ -651,12 +651,12 @@ inline size_t AdvancedProcessBlocks128_6x2_NEON(F2 func2, F6 func6, const word32 s_one32x4[] = {0, 0, 0, 1}; #endif - const ptrdiff_t blockSize = 16; - // const ptrdiff_t neonBlockSize = 16; + const size_t blockSize = 16; + // const size_t neonBlockSize = 16; - ptrdiff_t inIncrement = (flags & (BT_InBlockIsCounter|BT_DontIncrementInOutPointers)) ? 0 : blockSize; - ptrdiff_t xorIncrement = (xorBlocks != NULLPTR) ? blockSize : 0; - ptrdiff_t outIncrement = (flags & BT_DontIncrementInOutPointers) ? 0 : blockSize; + size_t inIncrement = (flags & (BT_InBlockIsCounter|BT_DontIncrementInOutPointers)) ? 0 : blockSize; + size_t xorIncrement = (xorBlocks != NULLPTR) ? blockSize : 0; + size_t outIncrement = (flags & BT_DontIncrementInOutPointers) ? 0 : blockSize; // Clang and Coverity are generating findings using xorBlocks as a flag. const bool xorInput = (xorBlocks != NULLPTR) && (flags & BT_XorInput); @@ -664,9 +664,9 @@ inline size_t AdvancedProcessBlocks128_6x2_NEON(F2 func2, F6 func6, if (flags & BT_ReverseDirection) { - inBlocks += static_cast(length) - blockSize; - xorBlocks += static_cast(length) - blockSize; - outBlocks += static_cast(length) - blockSize; + inBlocks = PtrAdd(inBlocks, length - blockSize); + xorBlocks = PtrAdd(xorBlocks, length - blockSize); + outBlocks = PtrAdd(outBlocks, length - blockSize); inIncrement = 0-inIncrement; xorIncrement = 0-xorIncrement; outIncrement = 0-outIncrement; @@ -693,33 +693,33 @@ inline size_t AdvancedProcessBlocks128_6x2_NEON(F2 func2, F6 func6, else { block0 = vreinterpretq_u64_u8(vld1q_u8(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block1 = vreinterpretq_u64_u8(vld1q_u8(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block2 = vreinterpretq_u64_u8(vld1q_u8(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block3 = vreinterpretq_u64_u8(vld1q_u8(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block4 = vreinterpretq_u64_u8(vld1q_u8(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block5 = vreinterpretq_u64_u8(vld1q_u8(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); } if (xorInput) { block0 = veorq_u64(block0, vreinterpretq_u64_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block1 = veorq_u64(block1, vreinterpretq_u64_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block2 = veorq_u64(block2, vreinterpretq_u64_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block3 = veorq_u64(block3, vreinterpretq_u64_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block4 = veorq_u64(block4, vreinterpretq_u64_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block5 = veorq_u64(block5, vreinterpretq_u64_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); } func6(block0, block1, block2, block3, block4, block5, subKeys, static_cast(rounds)); @@ -727,31 +727,31 @@ inline size_t AdvancedProcessBlocks128_6x2_NEON(F2 func2, F6 func6, if (xorOutput) { block0 = veorq_u64(block0, vreinterpretq_u64_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block1 = veorq_u64(block1, vreinterpretq_u64_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block2 = veorq_u64(block2, vreinterpretq_u64_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block3 = veorq_u64(block3, vreinterpretq_u64_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block4 = veorq_u64(block4, vreinterpretq_u64_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block5 = veorq_u64(block5, vreinterpretq_u64_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); } vst1q_u8(outBlocks, vreinterpretq_u8_u64(block0)); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); vst1q_u8(outBlocks, vreinterpretq_u8_u64(block1)); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); vst1q_u8(outBlocks, vreinterpretq_u8_u64(block2)); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); vst1q_u8(outBlocks, vreinterpretq_u8_u64(block3)); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); vst1q_u8(outBlocks, vreinterpretq_u8_u64(block4)); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); vst1q_u8(outBlocks, vreinterpretq_u8_u64(block5)); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); length -= 6*blockSize; } @@ -771,17 +771,17 @@ inline size_t AdvancedProcessBlocks128_6x2_NEON(F2 func2, F6 func6, else { block0 = vreinterpretq_u64_u8(vld1q_u8(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block1 = vreinterpretq_u64_u8(vld1q_u8(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); } if (xorInput) { block0 = veorq_u64(block0, vreinterpretq_u64_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block1 = veorq_u64(block1, vreinterpretq_u64_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); } func2(block0, block1, subKeys, static_cast(rounds)); @@ -789,15 +789,15 @@ inline size_t AdvancedProcessBlocks128_6x2_NEON(F2 func2, F6 func6, if (xorOutput) { block0 = veorq_u64(block0, vreinterpretq_u64_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block1 = veorq_u64(block1, vreinterpretq_u64_u8(vld1q_u8(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); } vst1q_u8(outBlocks, vreinterpretq_u8_u64(block0)); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); vst1q_u8(outBlocks, vreinterpretq_u8_u64(block1)); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); length -= 2*blockSize; } @@ -821,9 +821,9 @@ inline size_t AdvancedProcessBlocks128_6x2_NEON(F2 func2, F6 func6, vst1q_u8(outBlocks, vreinterpretq_u8_u64(block)); - inBlocks += inIncrement; - outBlocks += outIncrement; - xorBlocks += xorIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); + outBlocks = PtrAdd(outBlocks, outIncrement); + xorBlocks = PtrAdd(xorBlocks, xorIncrement); length -= blockSize; } @@ -883,12 +883,12 @@ inline size_t AdvancedProcessBlocks64_2x1_SSE(F1 func1, F2 func2, // Avoid casting byte* to double*. Clang and GCC do not agree. double temp[2]; - const ptrdiff_t blockSize = 8; - const ptrdiff_t xmmBlockSize = 16; + const size_t blockSize = 8; + const size_t xmmBlockSize = 16; - ptrdiff_t inIncrement = (flags & (BT_InBlockIsCounter|BT_DontIncrementInOutPointers)) ? 0 : xmmBlockSize; - ptrdiff_t xorIncrement = (xorBlocks != NULLPTR) ? xmmBlockSize : 0; - ptrdiff_t outIncrement = (flags & BT_DontIncrementInOutPointers) ? 0 : xmmBlockSize; + size_t inIncrement = (flags & (BT_InBlockIsCounter|BT_DontIncrementInOutPointers)) ? 0 : xmmBlockSize; + size_t xorIncrement = (xorBlocks != NULLPTR) ? xmmBlockSize : 0; + size_t outIncrement = (flags & BT_DontIncrementInOutPointers) ? 0 : xmmBlockSize; // Clang and Coverity are generating findings using xorBlocks as a flag. const bool xorInput = (xorBlocks != NULLPTR) && (flags & BT_XorInput); @@ -896,9 +896,9 @@ inline size_t AdvancedProcessBlocks64_2x1_SSE(F1 func1, F2 func2, if (flags & BT_ReverseDirection) { - inBlocks += static_cast(length) - xmmBlockSize; - xorBlocks += static_cast(length) - xmmBlockSize; - outBlocks += static_cast(length) - xmmBlockSize; + inBlocks = PtrAdd(inBlocks, length - xmmBlockSize); + xorBlocks = PtrAdd(xorBlocks, length - xmmBlockSize); + outBlocks = PtrAdd(outBlocks, length - xmmBlockSize); inIncrement = 0-inIncrement; xorIncrement = 0-xorIncrement; outIncrement = 0-outIncrement; @@ -930,17 +930,17 @@ inline size_t AdvancedProcessBlocks64_2x1_SSE(F1 func1, F2 func2, else { block0 = _mm_loadu_si128(CONST_M128_CAST(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block1 = _mm_loadu_si128(CONST_M128_CAST(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); } if (xorInput) { block0 = _mm_xor_si128(block0, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block1 = _mm_xor_si128(block1, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); } func2(block0, block1, subKeys, static_cast(rounds)); @@ -948,15 +948,15 @@ inline size_t AdvancedProcessBlocks64_2x1_SSE(F1 func1, F2 func2, if (xorOutput) { block0 = _mm_xor_si128(block0, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block1 = _mm_xor_si128(block1, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); } _mm_storeu_si128(M128_CAST(outBlocks), block0); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); _mm_storeu_si128(M128_CAST(outBlocks), block1); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); length -= 2*xmmBlockSize; } @@ -1006,9 +1006,9 @@ inline size_t AdvancedProcessBlocks64_2x1_SSE(F1 func1, F2 func2, _mm_store_sd(temp, _mm_castsi128_pd(block)); std::memcpy(outBlocks, temp, blockSize); - inBlocks += inIncrement; - outBlocks += outIncrement; - xorBlocks += xorIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); + outBlocks = PtrAdd(outBlocks, outIncrement); + xorBlocks = PtrAdd(xorBlocks, xorIncrement); length -= blockSize; } } @@ -1042,12 +1042,12 @@ inline size_t AdvancedProcessBlocks64_6x2_SSE(F2 func2, F6 func6, // Avoid casting byte* to double*. Clang and GCC do not agree. double temp[2]; - const ptrdiff_t blockSize = 8; - const ptrdiff_t xmmBlockSize = 16; + const size_t blockSize = 8; + const size_t xmmBlockSize = 16; - ptrdiff_t inIncrement = (flags & (BT_InBlockIsCounter|BT_DontIncrementInOutPointers)) ? 0 : xmmBlockSize; - ptrdiff_t xorIncrement = (xorBlocks != NULLPTR) ? xmmBlockSize : 0; - ptrdiff_t outIncrement = (flags & BT_DontIncrementInOutPointers) ? 0 : xmmBlockSize; + size_t inIncrement = (flags & (BT_InBlockIsCounter|BT_DontIncrementInOutPointers)) ? 0 : xmmBlockSize; + size_t xorIncrement = (xorBlocks != NULLPTR) ? xmmBlockSize : 0; + size_t outIncrement = (flags & BT_DontIncrementInOutPointers) ? 0 : xmmBlockSize; // Clang and Coverity are generating findings using xorBlocks as a flag. const bool xorInput = (xorBlocks != NULLPTR) && (flags & BT_XorInput); @@ -1055,9 +1055,9 @@ inline size_t AdvancedProcessBlocks64_6x2_SSE(F2 func2, F6 func6, if (flags & BT_ReverseDirection) { - inBlocks += static_cast(length) - xmmBlockSize; - xorBlocks += static_cast(length) - xmmBlockSize; - outBlocks += static_cast(length) - xmmBlockSize; + inBlocks = PtrAdd(inBlocks, length - xmmBlockSize); + xorBlocks = PtrAdd(xorBlocks, length - xmmBlockSize); + outBlocks = PtrAdd(outBlocks, length - xmmBlockSize); inIncrement = 0-inIncrement; xorIncrement = 0-xorIncrement; outIncrement = 0-outIncrement; @@ -1093,33 +1093,33 @@ inline size_t AdvancedProcessBlocks64_6x2_SSE(F2 func2, F6 func6, else { block0 = _mm_loadu_si128(CONST_M128_CAST(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block1 = _mm_loadu_si128(CONST_M128_CAST(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block2 = _mm_loadu_si128(CONST_M128_CAST(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block3 = _mm_loadu_si128(CONST_M128_CAST(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block4 = _mm_loadu_si128(CONST_M128_CAST(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block5 = _mm_loadu_si128(CONST_M128_CAST(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); } if (xorInput) { block0 = _mm_xor_si128(block0, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block1 = _mm_xor_si128(block1, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block2 = _mm_xor_si128(block2, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block3 = _mm_xor_si128(block3, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block4 = _mm_xor_si128(block4, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block5 = _mm_xor_si128(block5, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); } func6(block0, block1, block2, block3, block4, block5, subKeys, static_cast(rounds)); @@ -1127,31 +1127,31 @@ inline size_t AdvancedProcessBlocks64_6x2_SSE(F2 func2, F6 func6, if (xorOutput) { block0 = _mm_xor_si128(block0, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block1 = _mm_xor_si128(block1, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block2 = _mm_xor_si128(block2, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block3 = _mm_xor_si128(block3, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block4 = _mm_xor_si128(block4, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block5 = _mm_xor_si128(block5, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); } _mm_storeu_si128(M128_CAST(outBlocks), block0); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); _mm_storeu_si128(M128_CAST(outBlocks), block1); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); _mm_storeu_si128(M128_CAST(outBlocks), block2); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); _mm_storeu_si128(M128_CAST(outBlocks), block3); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); _mm_storeu_si128(M128_CAST(outBlocks), block4); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); _mm_storeu_si128(M128_CAST(outBlocks), block5); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); length -= 6*xmmBlockSize; } @@ -1180,17 +1180,17 @@ inline size_t AdvancedProcessBlocks64_6x2_SSE(F2 func2, F6 func6, else { block0 = _mm_loadu_si128(CONST_M128_CAST(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block1 = _mm_loadu_si128(CONST_M128_CAST(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); } if (xorInput) { block0 = _mm_xor_si128(block0, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block1 = _mm_xor_si128(block1, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); } func2(block0, block1, subKeys, static_cast(rounds)); @@ -1198,15 +1198,15 @@ inline size_t AdvancedProcessBlocks64_6x2_SSE(F2 func2, F6 func6, if (xorOutput) { block0 = _mm_xor_si128(block0, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block1 = _mm_xor_si128(block1, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); } _mm_storeu_si128(M128_CAST(outBlocks), block0); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); _mm_storeu_si128(M128_CAST(outBlocks), block1); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); length -= 2*xmmBlockSize; } @@ -1259,9 +1259,9 @@ inline size_t AdvancedProcessBlocks64_6x2_SSE(F2 func2, F6 func6, _mm_store_sd(temp, _mm_castsi128_pd(block)); std::memcpy(outBlocks, temp, blockSize); - inBlocks += inIncrement; - outBlocks += outIncrement; - xorBlocks += xorIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); + outBlocks = PtrAdd(outBlocks, outIncrement); + xorBlocks = PtrAdd(xorBlocks, xorIncrement); length -= blockSize; } } @@ -1290,12 +1290,12 @@ inline size_t AdvancedProcessBlocks128_6x2_SSE(F2 func2, F6 func6, CRYPTOPP_ALIGN_DATA(16) const word32 s_one32x4[] = {0, 0, 0, 1<<24}; - const ptrdiff_t blockSize = 16; - // const ptrdiff_t xmmBlockSize = 16; + const size_t blockSize = 16; + // const size_t xmmBlockSize = 16; - ptrdiff_t inIncrement = (flags & (BT_InBlockIsCounter|BT_DontIncrementInOutPointers)) ? 0 : blockSize; - ptrdiff_t xorIncrement = (xorBlocks != NULLPTR) ? blockSize : 0; - ptrdiff_t outIncrement = (flags & BT_DontIncrementInOutPointers) ? 0 : blockSize; + size_t inIncrement = (flags & (BT_InBlockIsCounter|BT_DontIncrementInOutPointers)) ? 0 : blockSize; + size_t xorIncrement = (xorBlocks != NULLPTR) ? blockSize : 0; + size_t outIncrement = (flags & BT_DontIncrementInOutPointers) ? 0 : blockSize; // Clang and Coverity are generating findings using xorBlocks as a flag. const bool xorInput = (xorBlocks != NULLPTR) && (flags & BT_XorInput); @@ -1303,9 +1303,9 @@ inline size_t AdvancedProcessBlocks128_6x2_SSE(F2 func2, F6 func6, if (flags & BT_ReverseDirection) { - inBlocks += static_cast(length) - blockSize; - xorBlocks += static_cast(length) - blockSize; - outBlocks += static_cast(length) - blockSize; + inBlocks = PtrAdd(inBlocks, length - blockSize); + xorBlocks = PtrAdd(xorBlocks, length - blockSize); + outBlocks = PtrAdd(outBlocks, length - blockSize); inIncrement = 0-inIncrement; xorIncrement = 0-xorIncrement; outIncrement = 0-outIncrement; @@ -1330,33 +1330,33 @@ inline size_t AdvancedProcessBlocks128_6x2_SSE(F2 func2, F6 func6, else { block0 = _mm_loadu_si128(CONST_M128_CAST(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block1 = _mm_loadu_si128(CONST_M128_CAST(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block2 = _mm_loadu_si128(CONST_M128_CAST(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block3 = _mm_loadu_si128(CONST_M128_CAST(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block4 = _mm_loadu_si128(CONST_M128_CAST(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block5 = _mm_loadu_si128(CONST_M128_CAST(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); } if (xorInput) { block0 = _mm_xor_si128(block0, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block1 = _mm_xor_si128(block1, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block2 = _mm_xor_si128(block2, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block3 = _mm_xor_si128(block3, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block4 = _mm_xor_si128(block4, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block5 = _mm_xor_si128(block5, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); } func6(block0, block1, block2, block3, block4, block5, subKeys, static_cast(rounds)); @@ -1364,31 +1364,31 @@ inline size_t AdvancedProcessBlocks128_6x2_SSE(F2 func2, F6 func6, if (xorOutput) { block0 = _mm_xor_si128(block0, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block1 = _mm_xor_si128(block1, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block2 = _mm_xor_si128(block2, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block3 = _mm_xor_si128(block3, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block4 = _mm_xor_si128(block4, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block5 = _mm_xor_si128(block5, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); } _mm_storeu_si128(M128_CAST(outBlocks), block0); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); _mm_storeu_si128(M128_CAST(outBlocks), block1); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); _mm_storeu_si128(M128_CAST(outBlocks), block2); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); _mm_storeu_si128(M128_CAST(outBlocks), block3); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); _mm_storeu_si128(M128_CAST(outBlocks), block4); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); _mm_storeu_si128(M128_CAST(outBlocks), block5); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); length -= 6*blockSize; } @@ -1406,17 +1406,17 @@ inline size_t AdvancedProcessBlocks128_6x2_SSE(F2 func2, F6 func6, else { block0 = _mm_loadu_si128(CONST_M128_CAST(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block1 = _mm_loadu_si128(CONST_M128_CAST(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); } if (xorInput) { block0 = _mm_xor_si128(block0, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block1 = _mm_xor_si128(block1, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); } func2(block0, block1, subKeys, static_cast(rounds)); @@ -1424,15 +1424,15 @@ inline size_t AdvancedProcessBlocks128_6x2_SSE(F2 func2, F6 func6, if (xorOutput) { block0 = _mm_xor_si128(block0, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block1 = _mm_xor_si128(block1, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); } _mm_storeu_si128(M128_CAST(outBlocks), block0); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); _mm_storeu_si128(M128_CAST(outBlocks), block1); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); length -= 2*blockSize; } @@ -1456,9 +1456,9 @@ inline size_t AdvancedProcessBlocks128_6x2_SSE(F2 func2, F6 func6, _mm_storeu_si128(M128_CAST(outBlocks), block); - inBlocks += inIncrement; - outBlocks += outIncrement; - xorBlocks += xorIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); + outBlocks = PtrAdd(outBlocks, outIncrement); + xorBlocks = PtrAdd(xorBlocks, xorIncrement); length -= blockSize; } @@ -1486,12 +1486,12 @@ inline size_t AdvancedProcessBlocks128_4x1_SSE(F1 func1, F4 func4, CRYPTOPP_ALIGN_DATA(16) const word32 s_one32x4[] = {0, 0, 0, 1<<24}; - const ptrdiff_t blockSize = 16; - // const ptrdiff_t xmmBlockSize = 16; + const size_t blockSize = 16; + // const size_t xmmBlockSize = 16; - ptrdiff_t inIncrement = (flags & (BT_InBlockIsCounter|BT_DontIncrementInOutPointers)) ? 0 : blockSize; - ptrdiff_t xorIncrement = (xorBlocks != NULLPTR) ? blockSize : 0; - ptrdiff_t outIncrement = (flags & BT_DontIncrementInOutPointers) ? 0 : blockSize; + size_t inIncrement = (flags & (BT_InBlockIsCounter|BT_DontIncrementInOutPointers)) ? 0 : blockSize; + size_t xorIncrement = (xorBlocks != NULLPTR) ? blockSize : 0; + size_t outIncrement = (flags & BT_DontIncrementInOutPointers) ? 0 : blockSize; // Clang and Coverity are generating findings using xorBlocks as a flag. const bool xorInput = (xorBlocks != NULLPTR) && (flags & BT_XorInput); @@ -1499,9 +1499,9 @@ inline size_t AdvancedProcessBlocks128_4x1_SSE(F1 func1, F4 func4, if (flags & BT_ReverseDirection) { - inBlocks += static_cast(length) - blockSize; - xorBlocks += static_cast(length) - blockSize; - outBlocks += static_cast(length) - blockSize; + inBlocks = PtrAdd(inBlocks, length - blockSize); + xorBlocks = PtrAdd(xorBlocks, length - blockSize); + outBlocks = PtrAdd(outBlocks, length - blockSize); inIncrement = 0-inIncrement; xorIncrement = 0-xorIncrement; outIncrement = 0-outIncrement; @@ -1524,25 +1524,25 @@ inline size_t AdvancedProcessBlocks128_4x1_SSE(F1 func1, F4 func4, else { block0 = _mm_loadu_si128(CONST_M128_CAST(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block1 = _mm_loadu_si128(CONST_M128_CAST(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block2 = _mm_loadu_si128(CONST_M128_CAST(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block3 = _mm_loadu_si128(CONST_M128_CAST(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); } if (xorInput) { block0 = _mm_xor_si128(block0, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block1 = _mm_xor_si128(block1, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block2 = _mm_xor_si128(block2, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block3 = _mm_xor_si128(block3, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); } func4(block0, block1, block2, block3, subKeys, static_cast(rounds)); @@ -1550,23 +1550,23 @@ inline size_t AdvancedProcessBlocks128_4x1_SSE(F1 func1, F4 func4, if (xorOutput) { block0 = _mm_xor_si128(block0, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block1 = _mm_xor_si128(block1, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block2 = _mm_xor_si128(block2, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block3 = _mm_xor_si128(block3, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); } _mm_storeu_si128(M128_CAST(outBlocks), block0); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); _mm_storeu_si128(M128_CAST(outBlocks), block1); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); _mm_storeu_si128(M128_CAST(outBlocks), block2); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); _mm_storeu_si128(M128_CAST(outBlocks), block3); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); length -= 4*blockSize; } @@ -1589,9 +1589,9 @@ inline size_t AdvancedProcessBlocks128_4x1_SSE(F1 func1, F4 func4, _mm_storeu_si128(M128_CAST(outBlocks), block); - inBlocks += inIncrement; - outBlocks += outIncrement; - xorBlocks += xorIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); + outBlocks = PtrAdd(outBlocks, outIncrement); + xorBlocks = PtrAdd(xorBlocks, xorIncrement); length -= blockSize; } @@ -1624,12 +1624,12 @@ inline size_t AdvancedProcessBlocks64_4x1_SSE(F1 func1, F4 func4, // Avoid casting byte* to double*. Clang and GCC do not agree. double temp[2]; - const ptrdiff_t blockSize = 8; - const ptrdiff_t xmmBlockSize = 16; + const size_t blockSize = 8; + const size_t xmmBlockSize = 16; - ptrdiff_t inIncrement = (flags & (BT_InBlockIsCounter | BT_DontIncrementInOutPointers)) ? 0 : xmmBlockSize; - ptrdiff_t xorIncrement = (xorBlocks != NULLPTR) ? xmmBlockSize : 0; - ptrdiff_t outIncrement = (flags & BT_DontIncrementInOutPointers) ? 0 : xmmBlockSize; + size_t inIncrement = (flags & (BT_InBlockIsCounter | BT_DontIncrementInOutPointers)) ? 0 : xmmBlockSize; + size_t xorIncrement = (xorBlocks != NULLPTR) ? xmmBlockSize : 0; + size_t outIncrement = (flags & BT_DontIncrementInOutPointers) ? 0 : xmmBlockSize; // Clang and Coverity are generating findings using xorBlocks as a flag. const bool xorInput = (xorBlocks != NULLPTR) && (flags & BT_XorInput); @@ -1637,9 +1637,9 @@ inline size_t AdvancedProcessBlocks64_4x1_SSE(F1 func1, F4 func4, if (flags & BT_ReverseDirection) { - inBlocks += static_cast(length)-xmmBlockSize; - xorBlocks += static_cast(length)-xmmBlockSize; - outBlocks += static_cast(length)-xmmBlockSize; + inBlocks = PtrAdd(inBlocks, length - xmmBlockSize); + xorBlocks = PtrAdd(xorBlocks, length - xmmBlockSize); + outBlocks = PtrAdd(outBlocks, length - xmmBlockSize); inIncrement = 0 - inIncrement; xorIncrement = 0 - xorIncrement; outIncrement = 0 - outIncrement; @@ -1673,25 +1673,25 @@ inline size_t AdvancedProcessBlocks64_4x1_SSE(F1 func1, F4 func4, else { block0 = _mm_loadu_si128(CONST_M128_CAST(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block1 = _mm_loadu_si128(CONST_M128_CAST(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block2 = _mm_loadu_si128(CONST_M128_CAST(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block3 = _mm_loadu_si128(CONST_M128_CAST(inBlocks)); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); } if (xorInput) { block0 = _mm_xor_si128(block0, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block1 = _mm_xor_si128(block1, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block2 = _mm_xor_si128(block2, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block3 = _mm_xor_si128(block3, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); } func4(block0, block1, block2, block3, subKeys, static_cast(rounds)); @@ -1699,23 +1699,23 @@ inline size_t AdvancedProcessBlocks64_4x1_SSE(F1 func1, F4 func4, if (xorOutput) { block0 = _mm_xor_si128(block0, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block1 = _mm_xor_si128(block1, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block2 = _mm_xor_si128(block2, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block3 = _mm_xor_si128(block3, _mm_loadu_si128(CONST_M128_CAST(xorBlocks))); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); } _mm_storeu_si128(M128_CAST(outBlocks), block0); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); _mm_storeu_si128(M128_CAST(outBlocks), block1); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); _mm_storeu_si128(M128_CAST(outBlocks), block2); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); _mm_storeu_si128(M128_CAST(outBlocks), block3); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); length -= 4 * xmmBlockSize; } @@ -1765,9 +1765,9 @@ inline size_t AdvancedProcessBlocks64_4x1_SSE(F1 func1, F4 func4, _mm_store_sd(temp, _mm_castsi128_pd(block)); std::memcpy(outBlocks, temp, blockSize); - inBlocks += inIncrement; - outBlocks += outIncrement; - xorBlocks += xorIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); + outBlocks = PtrAdd(outBlocks, outIncrement); + xorBlocks = PtrAdd(xorBlocks, xorIncrement); length -= blockSize; } } @@ -1809,12 +1809,12 @@ inline size_t AdvancedProcessBlocks128_6x1_ALTIVEC(F1 func1, F6 func6, const uint32x4_p s_one = {0,0,0,1}; #endif - const ptrdiff_t blockSize = 16; - // const ptrdiff_t vexBlockSize = 16; + const size_t blockSize = 16; + // const size_t vexBlockSize = 16; - ptrdiff_t inIncrement = (flags & (BT_InBlockIsCounter|BT_DontIncrementInOutPointers)) ? 0 : blockSize; - ptrdiff_t xorIncrement = (xorBlocks != NULLPTR) ? blockSize : 0; - ptrdiff_t outIncrement = (flags & BT_DontIncrementInOutPointers) ? 0 : blockSize; + size_t inIncrement = (flags & (BT_InBlockIsCounter|BT_DontIncrementInOutPointers)) ? 0 : blockSize; + size_t xorIncrement = (xorBlocks != NULLPTR) ? blockSize : 0; + size_t outIncrement = (flags & BT_DontIncrementInOutPointers) ? 0 : blockSize; // Clang and Coverity are generating findings using xorBlocks as a flag. const bool xorInput = (xorBlocks != NULLPTR) && (flags & BT_XorInput); @@ -1822,9 +1822,9 @@ inline size_t AdvancedProcessBlocks128_6x1_ALTIVEC(F1 func1, F6 func6, if (flags & BT_ReverseDirection) { - inBlocks += static_cast(length) - blockSize; - xorBlocks += static_cast(length) - blockSize; - outBlocks += static_cast(length) - blockSize; + inBlocks = PtrAdd(inBlocks, length - blockSize); + xorBlocks = PtrAdd(xorBlocks, length - blockSize); + outBlocks = PtrAdd(outBlocks, length - blockSize); inIncrement = 0-inIncrement; xorIncrement = 0-xorIncrement; outIncrement = 0-outIncrement; @@ -1850,33 +1850,33 @@ inline size_t AdvancedProcessBlocks128_6x1_ALTIVEC(F1 func1, F6 func6, else { block0 = VectorLoad(inBlocks); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block1 = VectorLoad(inBlocks); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block2 = VectorLoad(inBlocks); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block3 = VectorLoad(inBlocks); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block4 = VectorLoad(inBlocks); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); block5 = VectorLoad(inBlocks); - inBlocks += inIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); } if (xorInput) { block0 = VectorXor(block0, VectorLoad(xorBlocks)); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block1 = VectorXor(block1, VectorLoad(xorBlocks)); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block2 = VectorXor(block2, VectorLoad(xorBlocks)); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block3 = VectorXor(block3, VectorLoad(xorBlocks)); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block4 = VectorXor(block4, VectorLoad(xorBlocks)); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block5 = VectorXor(block5, VectorLoad(xorBlocks)); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); } func6(block0, block1, block2, block3, block4, block5, subKeys, rounds); @@ -1884,31 +1884,31 @@ inline size_t AdvancedProcessBlocks128_6x1_ALTIVEC(F1 func1, F6 func6, if (xorOutput) { block0 = VectorXor(block0, VectorLoad(xorBlocks)); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block1 = VectorXor(block1, VectorLoad(xorBlocks)); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block2 = VectorXor(block2, VectorLoad(xorBlocks)); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block3 = VectorXor(block3, VectorLoad(xorBlocks)); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block4 = VectorXor(block4, VectorLoad(xorBlocks)); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); block5 = VectorXor(block5, VectorLoad(xorBlocks)); - xorBlocks += xorIncrement; + xorBlocks = PtrAdd(xorBlocks, xorIncrement); } VectorStore(block0, outBlocks); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); VectorStore(block1, outBlocks); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); VectorStore(block2, outBlocks); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); VectorStore(block3, outBlocks); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); VectorStore(block4, outBlocks); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); VectorStore(block5, outBlocks); - outBlocks += outIncrement; + outBlocks = PtrAdd(outBlocks, outIncrement); length -= 6*blockSize; } @@ -1931,9 +1931,9 @@ inline size_t AdvancedProcessBlocks128_6x1_ALTIVEC(F1 func1, F6 func6, VectorStore(block, outBlocks); - inBlocks += inIncrement; - outBlocks += outIncrement; - xorBlocks += xorIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); + outBlocks = PtrAdd(outBlocks, outIncrement); + xorBlocks = PtrAdd(xorBlocks, xorIncrement); length -= blockSize; } diff --git a/cryptlib.cpp b/cryptlib.cpp index 0f38cc76..8c1de4e2 100644 --- a/cryptlib.cpp +++ b/cryptlib.cpp @@ -150,16 +150,16 @@ size_t BlockTransformation::AdvancedProcessBlocks(const byte *inBlocks, const by CRYPTOPP_ASSERT(outBlocks); CRYPTOPP_ASSERT(length); - const ptrdiff_t blockSize = BlockSize(); - ptrdiff_t inIncrement = (flags & (BT_InBlockIsCounter|BT_DontIncrementInOutPointers)) ? 0 : blockSize; - ptrdiff_t xorIncrement = xorBlocks ? blockSize : 0; - ptrdiff_t outIncrement = (flags & BT_DontIncrementInOutPointers) ? 0 : blockSize; + const unsigned int blockSize = BlockSize(); + size_t inIncrement = (flags & (BT_InBlockIsCounter|BT_DontIncrementInOutPointers)) ? 0 : blockSize; + size_t xorIncrement = xorBlocks ? blockSize : 0; + size_t outIncrement = (flags & BT_DontIncrementInOutPointers) ? 0 : blockSize; if (flags & BT_ReverseDirection) { - inBlocks += static_cast(length - blockSize); - xorBlocks += static_cast(length - blockSize); - outBlocks += static_cast(length - blockSize); + inBlocks = PtrAdd(inBlocks, length - blockSize); + xorBlocks = PtrAdd(xorBlocks, length - blockSize); + outBlocks = PtrAdd(outBlocks, length - blockSize); inIncrement = 0-inIncrement; xorIncrement = 0-xorIncrement; outIncrement = 0-outIncrement; @@ -184,9 +184,9 @@ size_t BlockTransformation::AdvancedProcessBlocks(const byte *inBlocks, const by if (flags & BT_InBlockIsCounter) const_cast(inBlocks)[blockSize-1]++; - inBlocks += inIncrement; - outBlocks += outIncrement; - xorBlocks += xorIncrement; + inBlocks = PtrAdd(inBlocks, inIncrement); + outBlocks = PtrAdd(outBlocks, outIncrement); + xorBlocks = PtrAdd(xorBlocks, xorIncrement); length -= blockSize; } diff --git a/filters.cpp b/filters.cpp index 3bd0c3df..52cbd345 100644 --- a/filters.cpp +++ b/filters.cpp @@ -189,7 +189,7 @@ size_t MeterFilter::PutMaybeModifiable(byte *begin, size_t length, int messageEn FILTER_OUTPUT_MAYBE_MODIFIABLE(1, m_begin, t = (size_t)SaturatingSubtract(m_rangesToSkip.front().position, m_currentMessageBytes), false, modifiable); CRYPTOPP_ASSERT(t < m_length); - m_begin += t; + m_begin = PtrAdd(m_begin, t); m_length -= t; m_currentMessageBytes += t; m_totalBytes += t; @@ -203,7 +203,7 @@ size_t MeterFilter::PutMaybeModifiable(byte *begin, size_t length, int messageEn m_rangesToSkip.pop_front(); } - m_begin += t; + m_begin = PtrAdd(m_begin, t); m_length -= t; m_currentMessageBytes += t; m_totalBytes += t; @@ -277,7 +277,7 @@ byte *FilterWithBufferedInput::BlockQueue::GetContigousBlocks(size_t &numberOfBy { numberOfBytes = STDMIN(numberOfBytes, STDMIN(size_t(m_buffer.end()-m_begin), m_size)); byte *ptr = m_begin; - m_begin += numberOfBytes; + m_begin = PtrAdd(m_begin, numberOfBytes); m_size -= numberOfBytes; if (m_size == 0 || m_begin == m_buffer.end()) m_begin = m_buffer; @@ -308,7 +308,7 @@ void FilterWithBufferedInput::BlockQueue::Put(const byte *inString, size_t lengt size_t len = STDMIN(length, size_t(m_buffer.end()-end)); memcpy(end, inString, len); if (len < length) - memcpy(m_buffer, inString+len, length-len); + memcpy(m_buffer, PtrAdd(inString, len), length-len); m_size += length; } @@ -364,7 +364,7 @@ size_t FilterWithBufferedInput::PutMaybeModifiable(byte *inString, size_t length CRYPTOPP_ASSERT(m_queue.CurrentSize() == 0); m_queue.ResetQueue(m_blockSize, (2*m_blockSize+m_lastSize-2)/m_blockSize); - inString += len; + inString = PtrAdd(inString, len); newLength -= m_firstSize; m_firstInputDone = true; } @@ -385,7 +385,7 @@ size_t FilterWithBufferedInput::PutMaybeModifiable(byte *inString, size_t length { size_t len = newLength - m_lastSize; NextPutMaybeModifiable(inString, len, modifiable); - inString += len; + inString = PtrAdd(inString, len); newLength -= len; } } @@ -402,7 +402,7 @@ size_t FilterWithBufferedInput::PutMaybeModifiable(byte *inString, size_t length CRYPTOPP_ASSERT(m_queue.CurrentSize() < m_blockSize); size_t len = m_blockSize - m_queue.CurrentSize(); m_queue.Put(inString, len); - inString += len; + inString = PtrAdd(inString, len); NextPutModifiable(m_queue.GetBlock(), m_blockSize); newLength -= m_blockSize; } @@ -411,7 +411,7 @@ size_t FilterWithBufferedInput::PutMaybeModifiable(byte *inString, size_t length { size_t len = RoundDownToMultipleOf(newLength - m_lastSize, m_blockSize); NextPutMaybeModifiable(inString, len, modifiable); - inString += len; + inString = PtrAdd(inString, len); newLength -= len; } } @@ -463,7 +463,7 @@ void FilterWithBufferedInput::NextPutMultiple(const byte *inString, size_t lengt { CRYPTOPP_ASSERT(length >= m_blockSize); NextPutSingle(inString); - inString += m_blockSize; + inString = PtrAdd(inString, m_blockSize); length -= m_blockSize; } } @@ -679,7 +679,7 @@ void StreamTransformationFilter::NextPutMultiple(const byte *inString, size_t le len = length; m_cipher.ProcessString(space, inString, len); AttachedTransformation()->PutModifiable(space, len); - inString += len; + inString = PtrAdd(inString, len); length -= len; } while (length > 0); @@ -719,8 +719,8 @@ void StreamTransformationFilter::LastPut(const byte *inString, size_t length) { const size_t leftOver = length % m_mandatoryBlockSize; space = HelpCreatePutSpace(*AttachedTransformation(), DEFAULT_CHANNEL, m_reservedBufferSize); - length -= leftOver; + if (length) { // Process full blocks @@ -1196,7 +1196,7 @@ size_t StringStore::TransferTo2(BufferedTransformation &target, lword &transferB { lword position = 0; size_t blockedBytes = CopyRangeTo2(target, position, transferBytes, channel, blocking); - m_count += (size_t)position; + m_count += static_cast(position); transferBytes = position; return blockedBytes; } @@ -1205,9 +1205,9 @@ size_t StringStore::CopyRangeTo2(BufferedTransformation &target, lword &begin, l { size_t i = UnsignedMin(m_length, m_count+begin); size_t len = UnsignedMin(m_length-i, end-begin); - size_t blockedBytes = target.ChannelPut2(channel, m_store+i, len, 0, blocking); + size_t blockedBytes = target.ChannelPut2(channel, PtrAdd(m_store, i), len, 0, blocking); if (!blockedBytes) - begin += len; + begin = PtrAdd(begin, len); return blockedBytes; } @@ -1240,7 +1240,7 @@ size_t NullStore::CopyRangeTo2(BufferedTransformation &target, lword &begin, lwo size_t blockedBytes = target.ChannelPut2(channel, nullBytes, len, 0, blocking); if (blockedBytes) return blockedBytes; - begin += len; + begin = PtrAdd(begin, len); } return 0; } @@ -1249,8 +1249,7 @@ size_t NullStore::TransferTo2(BufferedTransformation &target, lword &transferByt { lword begin = 0; size_t blockedBytes = NullStore::CopyRangeTo2(target, begin, transferBytes, channel, blocking); - transferBytes = begin; - m_size -= begin; + transferBytes = begin; m_size -= begin; return blockedBytes; } diff --git a/misc.h b/misc.h index 59b2646b..dc75bdef 100644 --- a/misc.h +++ b/misc.h @@ -360,6 +360,32 @@ template // ************** misc functions *************** +/// \brief Create a pointer with an offset +/// \tparam PTR a pointer type +/// \tparam OFF a size type +/// \param pointer a pointer +/// \param offset a offset into the pointer +/// \details PtrAdd can be used to squash Clang and GCC +/// UBsan findings for pointer addition and subtraction. +template +inline PTR PtrAdd(PTR pointer, OFF offset) +{ + return pointer+static_cast(offset); +} + +/// \brief Create a pointer with an offset +/// \tparam PTR a pointer type +/// \tparam OFF a size type +/// \param pointer a pointer +/// \param offset a offset into the pointer +/// \details PtrSub can be used to squash Clang and GCC +/// UBsan findings for pointer addition and subtraction. +template +inline PTR PtrSub(PTR pointer, OFF offset) +{ + return pointer-static_cast(offset); +} + #if (!__STDC_WANT_SECURE_LIB__ && !defined(_MEMORY_S_DEFINED)) || defined(CRYPTOPP_WANT_SECURE_LIB) /// \brief Bounds checking replacement for memcpy() diff --git a/modes.cpp b/modes.cpp index 2a4f0cf9..fa9e38fa 100644 --- a/modes.cpp +++ b/modes.cpp @@ -36,21 +36,22 @@ void CFB_ModePolicy::Iterate(byte *output, const byte *input, CipherDir dir, siz CRYPTOPP_ASSERT(m_cipher->IsForwardTransformation()); CRYPTOPP_ASSERT(m_register.size() == BlockSize()); CRYPTOPP_ASSERT(m_temp.size() == BlockSize()); + CRYPTOPP_ASSERT(iterationCount > 0); - const ptrdiff_t s = BlockSize(); + const unsigned int s = BlockSize(); if (dir == ENCRYPTION) { m_cipher->ProcessAndXorBlock(m_register, input, output); if (iterationCount > 1) - m_cipher->AdvancedProcessBlocks(output, input+s, output+s, (iterationCount-1)*s, 0); - memcpy(m_register, output+(iterationCount-1)*s, s); + m_cipher->AdvancedProcessBlocks(output, PtrAdd(input,s), PtrAdd(output,s), (iterationCount-1)*s, 0); + memcpy(m_register, PtrAdd(output,(iterationCount-1)*s), s); } else { // make copy first in case of in-place decryption - memcpy(m_temp, input+(iterationCount-1)*s, s); + memcpy(m_temp, PtrAdd(input,(iterationCount-1)*s), s); if (iterationCount > 1) - m_cipher->AdvancedProcessBlocks(input, input+s, output+s, (iterationCount-1)*s, BlockTransformation::BT_ReverseDirection); + m_cipher->AdvancedProcessBlocks(input, PtrAdd(input,s), PtrAdd(output,s), (iterationCount-1)*s, BlockTransformation::BT_ReverseDirection); m_cipher->ProcessAndXorBlock(m_register, input, output); memcpy(m_register, m_temp, s); } @@ -62,8 +63,8 @@ void CFB_ModePolicy::TransformRegister() CRYPTOPP_ASSERT(m_register.size() == BlockSize()); CRYPTOPP_ASSERT(m_temp.size() == BlockSize()); - m_cipher->ProcessBlock(m_register, m_temp); const ptrdiff_t updateSize = BlockSize()-m_feedbackSize; + m_cipher->ProcessBlock(m_register, m_temp); memmove_s(m_register, m_register.size(), m_register+m_feedbackSize, updateSize); memcpy_s(m_register+updateSize, m_register.size()-updateSize, m_temp, m_feedbackSize); } @@ -94,19 +95,20 @@ byte* CFB_ModePolicy::GetRegisterBegin() { CRYPTOPP_ASSERT(!m_register.empty()); CRYPTOPP_ASSERT(BlockSize() >= m_feedbackSize); - return m_register + static_cast(BlockSize() - m_feedbackSize); + return PtrAdd(m_register.begin(), BlockSize() - m_feedbackSize); } void OFB_ModePolicy::WriteKeystream(byte *keystreamBuffer, size_t iterationCount) { CRYPTOPP_ASSERT(m_cipher->IsForwardTransformation()); CRYPTOPP_ASSERT(m_register.size() == BlockSize()); + CRYPTOPP_ASSERT(iterationCount > 0); - const ptrdiff_t s = BlockSize(); + const unsigned int s = BlockSize(); m_cipher->ProcessBlock(m_register, keystreamBuffer); if (iterationCount > 1) - m_cipher->AdvancedProcessBlocks(keystreamBuffer, NULLPTR, keystreamBuffer+s, s*(iterationCount-1), 0); - memcpy(m_register, keystreamBuffer+s*(iterationCount-1), s); + m_cipher->AdvancedProcessBlocks(keystreamBuffer, NULLPTR, PtrAdd(keystreamBuffer, s), s*(iterationCount-1), 0); + memcpy(m_register, PtrAdd(keystreamBuffer, (iterationCount-1)*s), s); } void OFB_ModePolicy::CipherResynchronize(byte *keystreamBuffer, const byte *iv, size_t length) @@ -140,8 +142,8 @@ void CTR_ModePolicy::OperateKeystream(KeystreamOperation /*operation*/, byte *ou CRYPTOPP_ASSERT(m_cipher->IsForwardTransformation()); CRYPTOPP_ASSERT(m_counterArray.size() == BlockSize()); - const ptrdiff_t s = BlockSize(); - const ptrdiff_t inputIncrement = input ? s : 0; + const unsigned int s = BlockSize(); + const unsigned int inputIncrement = input ? s : 0; while (iterationCount) { @@ -151,8 +153,8 @@ void CTR_ModePolicy::OperateKeystream(KeystreamOperation /*operation*/, byte *ou if ((m_counterArray[s-1] = lsb + (byte)blocks) == 0) IncrementCounterBy256(); - output += blocks*s; - input += blocks*inputIncrement; + output = PtrAdd(output, blocks*s); + input = PtrAdd(input, blocks*inputIncrement); iterationCount -= blocks; } } @@ -197,18 +199,18 @@ void CBC_Encryption::ProcessData(byte *outString, const byte *inString, size_t l CRYPTOPP_ASSERT(m_register.size() == BlockSize()); if (!length) return; - const ptrdiff_t blockSize = BlockSize(); + const unsigned int blockSize = BlockSize(); m_cipher->AdvancedProcessBlocks(inString, m_register, outString, blockSize, BlockTransformation::BT_XorInput); if (length > blockSize) - m_cipher->AdvancedProcessBlocks(inString+blockSize, outString, outString+blockSize, length-blockSize, BlockTransformation::BT_XorInput); - memcpy(m_register, outString + length - blockSize, blockSize); + m_cipher->AdvancedProcessBlocks(PtrAdd(inString,blockSize), outString, PtrAdd(outString,blockSize), length-blockSize, BlockTransformation::BT_XorInput); + memcpy(m_register, PtrAdd(outString, length - blockSize), blockSize); } size_t CBC_CTS_Encryption::ProcessLastBlock(byte *outString, size_t outLength, const byte *inString, size_t inLength) { CRYPTOPP_UNUSED(outLength); const size_t used = inLength; - const ptrdiff_t blockSize = static_cast(BlockSize()); + const unsigned int blockSize = BlockSize(); if (inLength <= BlockSize()) { @@ -222,16 +224,17 @@ size_t CBC_CTS_Encryption::ProcessLastBlock(byte *outString, size_t outLength, c else { // steal from next to last block - xorbuf(m_register, inString, BlockSize()); + xorbuf(m_register, inString, blockSize); m_cipher->ProcessBlock(m_register); - inString += blockSize; inLength -= blockSize; - memcpy(outString+blockSize, m_register, inLength); + inString = PtrAdd(inString, blockSize); + inLength -= blockSize; + memcpy(PtrAdd(outString, blockSize), m_register, inLength); } // output last full ciphertext block xorbuf(m_register, inString, inLength); m_cipher->ProcessBlock(m_register); - memcpy(outString, m_register, BlockSize()); + memcpy(outString, m_register, blockSize); return used; } @@ -248,10 +251,10 @@ void CBC_Decryption::ProcessData(byte *outString, const byte *inString, size_t l if (!length) {return;} // save copy now in case of in-place decryption - const ptrdiff_t blockSize = BlockSize(); - memcpy(m_temp, inString+length-blockSize, blockSize); + const unsigned int blockSize = BlockSize(); + memcpy(m_temp, PtrAdd(inString,length-blockSize), blockSize); if (length > blockSize) - m_cipher->AdvancedProcessBlocks(inString+blockSize, inString, outString+blockSize, length-blockSize, BlockTransformation::BT_ReverseDirection|BlockTransformation::BT_AllowParallel); + m_cipher->AdvancedProcessBlocks(PtrAdd(inString,blockSize), inString, PtrAdd(outString,blockSize), length-blockSize, BlockTransformation::BT_ReverseDirection|BlockTransformation::BT_AllowParallel); m_cipher->ProcessAndXorBlock(inString, m_register, outString); m_register.swap(m_temp); } @@ -262,7 +265,7 @@ size_t CBC_CTS_Decryption::ProcessLastBlock(byte *outString, size_t outLength, c const byte *pn1, *pn2; const size_t used = inLength; const bool stealIV = inLength <= BlockSize(); - const ptrdiff_t blockSize = static_cast(BlockSize()); + const unsigned int blockSize = BlockSize(); if (stealIV) { @@ -271,7 +274,7 @@ size_t CBC_CTS_Decryption::ProcessLastBlock(byte *outString, size_t outLength, c } else { - pn1 = inString + blockSize; + pn1 = PtrAdd(inString, blockSize); pn2 = inString; inLength -= blockSize; } @@ -287,7 +290,7 @@ size_t CBC_CTS_Decryption::ProcessLastBlock(byte *outString, size_t outLength, c } else { - memcpy(outString+blockSize, m_temp, inLength); + memcpy(PtrAdd(outString, blockSize), m_temp, inLength); // decrypt next to last plaintext block memcpy(m_temp, pn1, inLength); m_cipher->ProcessBlock(m_temp); diff --git a/neon-simd.cpp b/neon-simd.cpp index 2dd1fa27..af336115 100644 --- a/neon-simd.cpp +++ b/neon-simd.cpp @@ -82,11 +82,12 @@ bool CPU_ProbeARMv7() else { // ARMv7 added movt and movw - int a; - asm volatile("movw %0,%1 \n" - "movt %0,%1 \n" - : "=r"(a) : "i"(0x1234)); - result = (a == 0x12341234); + //int a; + //asm volatile("movw %0,%1 \n" + // "movt %0,%1 \n" + // : "=r"(a) : "i"(0x1234)); + //result = (a == 0x12341234); + return true; } sigprocmask(SIG_SETMASK, (sigset_t*)&oldMask, NULLPTR); diff --git a/strciphr.cpp b/strciphr.cpp index 8d72b347..2864671b 100644 --- a/strciphr.cpp +++ b/strciphr.cpp @@ -35,26 +35,23 @@ void AdditiveCipherTemplate::GenerateBlock(byte *outString, size_t length) { if (m_leftOver > 0) { - size_t len = STDMIN(m_leftOver, length); - memcpy(outString, KeystreamBufferEnd()-m_leftOver, len); - length -= len; - m_leftOver -= len; - outString += len; + const size_t len = STDMIN(m_leftOver, length); + memcpy(outString, PtrSub(KeystreamBufferEnd(), m_leftOver), len); - if (!length) - return; + length -= len; m_leftOver -= len; + outString = PtrAdd(outString, len); + if (!length) {return;} } - CRYPTOPP_ASSERT(m_leftOver == 0); PolicyInterface &policy = this->AccessPolicy(); unsigned int bytesPerIteration = policy.GetBytesPerIteration(); if (length >= bytesPerIteration) { - size_t iterations = length / bytesPerIteration; + const size_t iterations = length / bytesPerIteration; policy.WriteKeystream(outString, iterations); - outString += iterations * bytesPerIteration; length -= iterations * bytesPerIteration; + outString = PtrAdd(outString, iterations * bytesPerIteration); } if (length > 0) @@ -73,35 +70,31 @@ void AdditiveCipherTemplate::ProcessData(byte *outString, const byte *inStrin { if (m_leftOver > 0) { - size_t len = STDMIN(m_leftOver, length); + const size_t len = STDMIN(m_leftOver, length); xorbuf(outString, inString, KeystreamBufferEnd()-m_leftOver, len); - length -= len; - m_leftOver -= len; - inString += len; - outString += len; - if (!length) - return; + length -= len; m_leftOver -= len; + inString = PtrAdd(inString, len); + outString = PtrAdd(outString, len); + + if (!length) {return;} } - CRYPTOPP_ASSERT(m_leftOver == 0); PolicyInterface &policy = this->AccessPolicy(); unsigned int bytesPerIteration = policy.GetBytesPerIteration(); if (policy.CanOperateKeystream() && length >= bytesPerIteration) { - size_t iterations = length / bytesPerIteration; + const size_t iterations = length / bytesPerIteration; unsigned int alignment = policy.GetAlignment(); KeystreamOperation operation = KeystreamOperation((IsAlignedOn(inString, alignment) * 2) | (int)IsAlignedOn(outString, alignment)); - policy.OperateKeystream(operation, outString, inString, iterations); - inString += iterations * bytesPerIteration; - outString += iterations * bytesPerIteration; + inString = PtrAdd(inString, iterations * bytesPerIteration); + outString = PtrAdd(outString, iterations * bytesPerIteration); length -= iterations * bytesPerIteration; - if (!length) - return; + if (!length) {return;} } size_t bufferByteSize = m_buffer.size(); @@ -111,9 +104,10 @@ void AdditiveCipherTemplate::ProcessData(byte *outString, const byte *inStrin { policy.WriteKeystream(m_buffer, bufferIterations); xorbuf(outString, inString, KeystreamBufferBegin(), bufferByteSize); + length -= bufferByteSize; - inString += bufferByteSize; - outString += bufferByteSize; + inString = PtrAdd(inString, bufferByteSize); + outString = PtrAdd(outString, bufferByteSize); } if (length > 0) @@ -181,6 +175,7 @@ void CFB_CipherTemplate::Resynchronize(const byte *iv, int length) template void CFB_CipherTemplate::ProcessData(byte *outString, const byte *inString, size_t length) { + CRYPTOPP_ASSERT(outString); CRYPTOPP_ASSERT(inString); CRYPTOPP_ASSERT(length % this->MandatoryBlockSize() == 0); PolicyInterface &policy = this->AccessPolicy(); @@ -190,30 +185,28 @@ void CFB_CipherTemplate::ProcessData(byte *outString, const byte *inString if (m_leftOver) { - size_t len = STDMIN(m_leftOver, length); - CombineMessageAndShiftRegister(outString, reg + bytesPerIteration - m_leftOver, inString, len); - m_leftOver -= len; - length -= len; - inString += len; - outString += len; + const size_t len = STDMIN(m_leftOver, length); + CombineMessageAndShiftRegister(outString, PtrAdd(reg, bytesPerIteration - m_leftOver), inString, len); + + m_leftOver -= len; length -= len; + inString = PtrAdd(inString, len); + outString = PtrAdd(outString, len); + + if (!length) {return;} } - if (!length) - return; - - CRYPTOPP_ASSERT(m_leftOver == 0); - if (policy.CanIterate() && length >= bytesPerIteration && IsAlignedOn(outString, alignment)) { + const CipherDir cipherDir = GetCipherDir(*this); if (IsAlignedOn(inString, alignment)) - policy.Iterate(outString, inString, GetCipherDir(*this), length / bytesPerIteration); + policy.Iterate(outString, inString, cipherDir, length / bytesPerIteration); else { memcpy(outString, inString, length); - policy.Iterate(outString, outString, GetCipherDir(*this), length / bytesPerIteration); + policy.Iterate(outString, outString, cipherDir, length / bytesPerIteration); } - inString += length - length % bytesPerIteration; - outString += length - length % bytesPerIteration; + inString = PtrAdd(inString, length - length % bytesPerIteration); + outString = PtrAdd(outString, length - length % bytesPerIteration); length %= bytesPerIteration; } @@ -222,8 +215,8 @@ void CFB_CipherTemplate::ProcessData(byte *outString, const byte *inString policy.TransformRegister(); CombineMessageAndShiftRegister(outString, reg, inString, bytesPerIteration); length -= bytesPerIteration; - inString += bytesPerIteration; - outString += bytesPerIteration; + inString = PtrAdd(inString, bytesPerIteration); + outString = PtrAdd(outString, bytesPerIteration); } if (length > 0) @@ -244,7 +237,7 @@ void CFB_EncryptionTemplate::CombineMessageAndShiftRegister(byte *output, template void CFB_DecryptionTemplate::CombineMessageAndShiftRegister(byte *output, byte *reg, const byte *message, size_t length) { - for (unsigned int i=0; i