public override void Digest(Span <byte> output) { SecurityAssert.AssertBuffer(output, HashSize / 8); SecurityAssert.Assert(WorkBufferEmpty); _y.CopyTo(output); }
public void DecryptBlock(byte[] input, int inputOffset, byte[] output, int outputOffset) { SecurityAssert.Assert(_keyInitialised); SecurityAssert.AssertBuffer(input, inputOffset, BlockLength); SecurityAssert.AssertBuffer(output, outputOffset, BlockLength); var rounds = KeySize / 4 + 6; var state = ToState(input, inputOffset); AddRoundKey(state, rounds); for (var i = rounds - 1; i > 0; i--) { InvShiftRows(state); InvSubBytes(state); AddRoundKey(state, i); InvMixColumns(state); } InvShiftRows(state); InvSubBytes(state); AddRoundKey(state, 0); FromState(state, output, outputOffset); }
public RC4KeyParameter(byte[] key, int offset, int length) { SecurityAssert.AssertBuffer(key, offset, length); Key = new byte[length]; Array.Copy(key, offset, Key, 0, length); }
public void Decrypt(byte[] input, int inputOffset, byte[] output, int outputOffset, int length) { SecurityAssert.AssertBuffer(input, inputOffset, length); SecurityAssert.AssertBuffer(output, outputOffset, length - TagLength); Cipher.DecryptFinal(Cipher.Decrypt(input, output)); }
public void EncryptBlock(byte[] input, int inputOffset, byte[] output, int outputOffset) { SecurityAssert.Assert(_keyInitialised); SecurityAssert.AssertBuffer(input, inputOffset, BlockLength); SecurityAssert.AssertBuffer(output, outputOffset, BlockLength); var rounds = KeySize / 4 + 6; var state = ToState(input, inputOffset); AddRoundKey(state, 0); for (var round = 1; round < rounds; round++) { SubBytes(state); ShiftRows(state); MixColumns(state); AddRoundKey(state, round); } SubBytes(state); ShiftRows(state); AddRoundKey(state, rounds); FromState(state, output, outputOffset); }
public void Decrypt(byte[] input, int inputOffset, byte[] output, int outputOffset, int length) { SecurityAssert.AssertBuffer(input, inputOffset, length); SecurityAssert.NotNull(PrivateKey); var k = PrivateKey !.Modulus.GetByteLength(); SecurityAssert.Assert(k >= 11); SecurityAssert.Assert(length == k); var c = OS2IP(input, inputOffset, length); var m = DecryptPrimative(c, PrivateKey !); var em = I2OSP(m, k); SecurityAssert.Assert(em[0] == 0 && em[1] == 2); var mIdx = 2; while (mIdx < k && em[mIdx] != 0) { mIdx++; } SecurityAssert.Assert(mIdx - 2 > 8); // advance past zero mIdx++; SecurityAssert.AssertBuffer(output, outputOffset, k - mIdx); Array.Copy(em, mIdx, output, outputOffset, k - mIdx); }
public void Encrypt(byte[] input, int inputOffset, byte[] output, int outputOffset, int length) { SecurityAssert.AssertBuffer(input, inputOffset, length); SecurityAssert.NotNull(PublicKey); var k = PublicKey !.Modulus.GetByteLength(); SecurityAssert.Assert(length <= k - 11); var ps = _random.RandomNonZeroBytes(k - length - 3); SecurityAssert.Assert(ps.Length >= 8); var em = new byte[k]; em[0] = 0; em[1] = 2; Array.Copy(ps, 0, em, 2, ps.Length); em[ps.Length + 2] = 0; Array.Copy(input, inputOffset, em, ps.Length + 3, length); var m = OS2IP(em, 0, em.Length); var c = EncryptPrimative(m, PublicKey !); var result = I2OSP(c, k); SecurityAssert.AssertBuffer(output, outputOffset, result.Length); Array.Copy(result, 0, output, outputOffset, result.Length); }
public override void Digest(Span <byte> output) { SecurityAssert.AssertBuffer(output, HashSize / 8); var paddingLength = 64 - MessageSize % BlockSize / 8; if (paddingLength <= 8) { paddingLength += 64; } var padding = new byte[paddingLength]; // first bit is 1 padding[0] = 0x80; Array.Copy(EndianBitConverter.Big.GetBytes(MessageSize), 0, padding, paddingLength - 8, 8); Update(padding); SecurityAssert.Assert(WorkBufferEmpty); _complete = true; EndianBitConverter.Big.GetBytes(_h0).CopyTo(output); EndianBitConverter.Big.GetBytes(_h1).CopyTo(output.Slice(4)); EndianBitConverter.Big.GetBytes(_h2).CopyTo(output.Slice(8)); EndianBitConverter.Big.GetBytes(_h3).CopyTo(output.Slice(12)); EndianBitConverter.Big.GetBytes(_h4).CopyTo(output.Slice(16)); }
public void Decrypt(byte[] input, int inputOffset, byte[] output, int outputOffset, int length) { SecurityAssert.AssertBuffer(input, inputOffset, length); SecurityAssert.AssertBuffer(output, outputOffset, length); Array.Copy(input, inputOffset, output, outputOffset, length); }
public void AssertBuffer_WhenValid_ShouldDoNothing() { var a = new byte[] { 0, 1, 2, 3 }; SecurityAssert.AssertBuffer(a, 0, a.Length); SecurityAssert.AssertBuffer(a, 3, 1); SecurityAssert.AssertBuffer(a, 1, 3); }
public void UpdateVerification(byte[] buffer, int offset, int length) { SecurityAssert.AssertBuffer(buffer, offset, length); var output = new byte[length]; Array.Copy(buffer, offset, output, 0, length); _messages.Add(output); }
public void Decrypt(byte[] input, int inputOffset, byte[] output, int outputOffset, int length) { SecurityAssert.AssertBuffer(input, inputOffset, length); SecurityAssert.AssertBuffer(output, outputOffset, length); for (var i = 0; i < length; i += BlockCipher.BlockLength) { BlockCipher.DecryptBlock(input, inputOffset + i, output, outputOffset + i); } }
public override void DecryptBlock(byte[] input, int inputOffset, byte[] output, int outputOffset) { SecurityAssert.Assert(IVInitialised); SecurityAssert.AssertBuffer(input, inputOffset, BlockLength); SecurityAssert.AssertBuffer(output, outputOffset, BlockLength); Cipher.DecryptBlock(input, inputOffset, output, outputOffset); BufferUtils.Xor(_workingIV, 0, output, outputOffset, BlockLength); Array.Copy(input, inputOffset, _workingIV, 0, BlockLength); }
public void Encrypt(byte[] input, int inputOffset, byte[] output, int outputOffset, int length) { SecurityAssert.Assert(_keyInitialised); SecurityAssert.AssertBuffer(input, inputOffset, length); SecurityAssert.AssertBuffer(output, outputOffset, length); for (var offset = 0; offset < length; offset++) { output[outputOffset + offset] = (byte)(input[inputOffset + offset] ^ NextPGRA()); } }
public static BlockResult EncryptBlock(this IBlockCipher cipher, ReadOnlySpan <byte> input, Span <byte> output) { SecurityAssert.AssertBuffer(input, cipher.BlockLength); SecurityAssert.AssertBuffer(output, cipher.BlockLength); var inputBuffer = input.Slice(0, cipher.BlockLength).ToArray(); var outputBuffer = new byte[cipher.BlockLength]; cipher.EncryptBlock(inputBuffer, 0, outputBuffer, 0); outputBuffer.CopyTo(output); return(new BlockResult(input.Slice(cipher.BlockLength), output.Slice(cipher.BlockLength))); }
public override void Write(byte[] buffer, int offset, int count) { SecurityAssert.Assert(_active); SecurityAssert.AssertBuffer(buffer, offset, count); var data = new byte[count]; Array.Copy(buffer, offset, data, 0, count); var versionConfig = Services.GetRequiredService <VersionConfig>(); var record = new Record(RecordType.Application, versionConfig.Version, data); var connection = Services.GetRequiredService <Connection>(); connection.WriteRecord(record); }
private void ProcessBlock(byte[] input, int inputOffset, byte[] output, int outputOffset) { SecurityAssert.AssertBuffer(input, inputOffset, BlockLength); SecurityAssert.AssertBuffer(output, outputOffset, BlockLength); var counterOutput = new byte[BlockLength]; Cipher.EncryptBlock(_counter, 0, counterOutput, 0); // XOR input for (var i = 0; i < BlockLength; i++) { output[outputOffset + i] = (byte)(counterOutput[i] ^ input[inputOffset + i]); } // increment counter Inc(); }
public override void Digest(Span <byte> output) { SecurityAssert.AssertBuffer(output, HashSize / 8); // TODO same as SHA1... var paddingLength = 128 - MessageSize % BlockSize / 8; if (paddingLength <= 16) { paddingLength += 128; } var padding = new byte[paddingLength]; // first bit is 1 padding[0] = 0x80; // TODO messagesize should be 128-bits, this only 64 bits and the upper 64 are implicity zeroed in the padding Array.Copy(EndianBitConverter.Big.GetBytes(MessageSize), 0, padding, paddingLength - 8, 8); Update(padding); SecurityAssert.Assert(WorkBufferEmpty); _complete = true; EndianBitConverter.Big.GetBytes(_h0).CopyTo(output); EndianBitConverter.Big.GetBytes(_h1).CopyTo(output.Slice(8)); EndianBitConverter.Big.GetBytes(_h2).CopyTo(output.Slice(16)); EndianBitConverter.Big.GetBytes(_h3).CopyTo(output.Slice(24)); EndianBitConverter.Big.GetBytes(_h4).CopyTo(output.Slice(32)); EndianBitConverter.Big.GetBytes(_h5).CopyTo(output.Slice(40)); if (_mode == Mode.SHA512) { EndianBitConverter.Big.GetBytes(_h6).CopyTo(output.Slice(48)); EndianBitConverter.Big.GetBytes(_h7).CopyTo(output.Slice(56)); } }
public static AlertMessage Read(byte[] data) { SecurityAssert.AssertBuffer(data, 0, 2); return(new AlertMessage((AlertLevel)data[0], (AlertDescription)data[1])); }
public void AssertBuffer_WhenOffsetIsNegative_ShouldThrowSecurityException() { var a = new byte[] { 0, 1, 2, 3 }; Assert.Throws <SecurityException>(() => SecurityAssert.AssertBuffer(a, -1, 0)); }
public void AssertBuffer_WhenBufferIsNull_ShouldThrowSecurityException() { Assert.Throws <SecurityException>(() => SecurityAssert.AssertBuffer(null, 0, 0)); }
public void AssertBuffer_WhenOverflow_ShouldThrowSecurityException() { var a = new byte[] { 0, 1, 2, 3 }; Assert.Throws <SecurityException>(() => SecurityAssert.AssertBuffer(a, 3, 3)); }