Ejemplo n.º 1
0
        public override byte[] Decrypt(ReadOnlyMemory <byte> cipher, KerberosKey kerberosKey, KeyUsage usage)
        {
            var key = kerberosKey.GetKey(this);

            var cipherLength = cipher.Length - ChecksumSize;

            var Ke = DK(key, usage, KeyDerivationMode.Ke);

            var decrypted = AESCTS.Decrypt(
                BlockCopy(cipher, 0, cipherLength),
                Ke,
                AllZerosInitVector
                );

            var actualChecksum = MakeChecksum(decrypted, key, usage, KeyDerivationMode.Ki, ChecksumSize);

            var expectedChecksum = BlockCopy(cipher, cipherLength, ChecksumSize);

            if (!AreEqualSlow(expectedChecksum, actualChecksum))
            {
                throw new SecurityException("Invalid checksum");
            }

            return(BlockCopy(decrypted, ConfounderSize, cipherLength - ConfounderSize));
        }
Ejemplo n.º 2
0
        public override ReadOnlySpan <byte> Decrypt(ReadOnlyMemory <byte> cipher, KerberosKey kerberosKey, KeyUsage usage)
        {
            var cipherLength = cipher.Length - ChecksumSize;

            var Ke = kerberosKey.GetOrDeriveKey(
                this,
                $"{usage}|Ke|{KeySize}|{BlockSize}",
                key => DK(key.Span, usage, KeyDerivationMode.Ke, KeySize, BlockSize).AsMemory()
                );

            var decrypted = AESCTS.Decrypt(
                cipher.Span.Slice(0, cipherLength),
                Ke,
                AllZerosInitVector.Span
                );

            var actualChecksum = MakeChecksum(decrypted, kerberosKey, usage, KeyDerivationMode.Ki, ChecksumSize);

            var expectedChecksum = cipher.Slice(cipherLength, ChecksumSize);

            if (!AreEqualSlow(expectedChecksum.Span, actualChecksum))
            {
                throw new SecurityException("Invalid checksum");
            }

            return(decrypted.Slice(ConfounderSize, cipherLength - ConfounderSize));
        }
Ejemplo n.º 3
0
        public override ReadOnlyMemory <byte> Decrypt(ReadOnlyMemory <byte> cipher, KerberosKey kerberosKey, KeyUsage usage)
        {
            var cipherLength = cipher.Length - this.ChecksumSize;

            var ke = this.GetOrDeriveKey(kerberosKey, usage);

            var decrypted = AESCTS.Decrypt(
                cipher.Slice(0, cipherLength),
                ke,
                AllZerosInitVector
                );

            var actualChecksum = this.MakeChecksum(decrypted, kerberosKey, usage, KeyDerivationMode.Ki, this.ChecksumSize);

            var expectedChecksum = cipher.Slice(cipherLength, this.ChecksumSize);

            if (!AreEqualSlow(expectedChecksum.Span, actualChecksum.Span))
            {
                throw new SecurityException("Invalid checksum");
            }

            return(decrypted.Slice(this.ConfounderSize, cipherLength - this.ConfounderSize));
        }