From ec2faf617a608bd914c95b06922f98b4946d0ee2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Richard=20Wiedenh=C3=B6ft?= Date: Thu, 7 Mar 2019 19:58:24 +0100 Subject: [PATCH] Update various dependencies * Library dependencies * SBT plugins * SBT version * Scala version --- build.sbt | 5 +- project/build.properties | 2 +- project/plugins.sbt | 8 +-- .../SymmetricJavaBlockCipher.scala | 3 +- src/main/scala/blockciphers/Threefish.scala | 9 ++-- src/main/scala/hash/MD5.scala | 6 +-- src/main/scala/hash/SHA256.scala | 3 +- src/main/scala/khash/Hmac.scala | 3 +- src/main/scala/suites/AES_CBC_NoPadding.scala | 9 ++-- .../scala/suites/AES_CBC_PKCS7Padding.scala | 9 ++-- src/main/scala/suites/RSAES_OAEP.scala | 3 +- .../suites/Threefish_CBC_PKCS7Padding.scala | 9 ++-- src/main/scala/util/PBKDF2Easy.scala | 3 +- src/test/scala/BlockCipherSpec.scala | 40 +++++---------- src/test/scala/BlockPaddingSpec.scala | 38 +++++--------- src/test/scala/HashSpec.scala | 26 +++------- src/test/scala/PBKDF2Spec.scala | 13 ++--- src/test/scala/RichBigIntSpec.scala | 19 +++---- .../scala/SymmetricBlockCipherSuiteSpec.scala | 20 +++----- src/test/scala/ThreefishSpec.scala | 49 ++++++------------- 20 files changed, 90 insertions(+), 187 deletions(-) diff --git a/build.sbt b/build.sbt index 8844963..d792d35 100644 --- a/build.sbt +++ b/build.sbt @@ -13,11 +13,11 @@ lazy val scalacrypt = project.in(file(".")) version := "0.5-SNAPSHOT", licenses := Seq("Apache" -> url("http://www.apache.org/licenses/LICENSE-2.0")), homepage := Some(url("https://github.com/richard-w/scalacrypt")), - scalaVersion := "2.12.2", + scalaVersion := "2.12.8", scalacOptions ++= Seq("-feature", "-unchecked", "-deprecation", "-opt:_"), libraryDependencies ++= { Seq( - "org.scalatest" %% "scalatest" % "3.0.1" + "org.scalatest" %% "scalatest" % "3.0.5" ) }, publishMavenStyle := true, @@ -45,4 +45,3 @@ lazy val scalacrypt = project.in(file(".")) ) ) - .settings(scalariformSettings: _*) diff --git a/project/build.properties b/project/build.properties index 817bc38..c0bab04 100644 --- a/project/build.properties +++ b/project/build.properties @@ -1 +1 @@ -sbt.version=0.13.9 +sbt.version=1.2.8 diff --git a/project/plugins.sbt b/project/plugins.sbt index 227b69d..f72bc2c 100644 --- a/project/plugins.sbt +++ b/project/plugins.sbt @@ -1,7 +1,7 @@ -addSbtPlugin("com.jsuereth" % "sbt-pgp" % "1.0.0") +addSbtPlugin("com.jsuereth" % "sbt-pgp" % "1.1.2") -addSbtPlugin("org.scoverage" % "sbt-scoverage" % "1.5.0") +addSbtPlugin("org.scoverage" % "sbt-scoverage" % "1.5.1") -addSbtPlugin("org.scoverage" % "sbt-coveralls" % "1.1.0") +addSbtPlugin("org.scoverage" % "sbt-coveralls" % "1.2.7") -addSbtPlugin("com.typesafe.sbt" % "sbt-scalariform" % "1.3.0") +addSbtPlugin("org.scalariform" % "sbt-scalariform" % "1.8.2") diff --git a/src/main/scala/blockciphers/SymmetricJavaBlockCipher.scala b/src/main/scala/blockciphers/SymmetricJavaBlockCipher.scala index d9a2171..8225069 100644 --- a/src/main/scala/blockciphers/SymmetricJavaBlockCipher.scala +++ b/src/main/scala/blockciphers/SymmetricJavaBlockCipher.scala @@ -41,8 +41,7 @@ sealed trait SymmetricJavaBlockCipher[KeyType <: Key] extends BlockCipher[KeyTyp } } else { Failure( - new IllegalBlockSizeException("Expected block of length " + blockSize + ", got " + block.length + " bytes.") - ) + new IllegalBlockSizeException("Expected block of length " + blockSize + ", got " + block.length + " bytes.")) } } diff --git a/src/main/scala/blockciphers/Threefish.scala b/src/main/scala/blockciphers/Threefish.scala index e6c6b8f..2ae24b6 100644 --- a/src/main/scala/blockciphers/Threefish.scala +++ b/src/main/scala/blockciphers/Threefish.scala @@ -189,8 +189,7 @@ trait Threefish256 extends Threefish[SymmetricKey256] { Seq(25, 33), Seq(46, 12), Seq(58, 22), - Seq(32, 32) - ) + Seq(32, 32)) val permutation: Seq[Int] = Seq(0, 3, 2, 1) @@ -211,8 +210,7 @@ trait Threefish512 extends Threefish[SymmetricKey512] { Seq(39, 30, 34, 24), Seq(13, 50, 10, 17), Seq(25, 29, 39, 43), - Seq(8, 35, 56, 22) - ) + Seq(8, 35, 56, 22)) val permutation: Seq[Int] = Seq(2, 1, 4, 7, 6, 5, 0, 3) @@ -233,8 +231,7 @@ trait Threefish1024 extends Threefish[SymmetricKey1024] { Seq(41, 9, 37, 31, 12, 47, 44, 30), Seq(16, 34, 56, 51, 4, 53, 42, 41), Seq(31, 44, 47, 46, 19, 42, 44, 25), - Seq(9, 48, 35, 52, 23, 31, 37, 20) - ) + Seq(9, 48, 35, 52, 23, 31, 37, 20)) val permutation: Seq[Int] = Seq(0, 9, 2, 13, 6, 11, 4, 15, 10, 7, 12, 3, 14, 5, 8, 1) val reversePermutation: Seq[Int] = Seq(0, 15, 2, 11, 6, 13, 4, 9, 14, 1, 8, 5, 10, 3, 12, 7) diff --git a/src/main/scala/hash/MD5.scala b/src/main/scala/hash/MD5.scala index f97470a..2004953 100644 --- a/src/main/scala/hash/MD5.scala +++ b/src/main/scala/hash/MD5.scala @@ -44,8 +44,7 @@ object MD5 extends MDConstruction[(Int, Int, Int, Int)] { 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, - 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21 - ) + 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21) private val k = Seq( 0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, @@ -63,8 +62,7 @@ object MD5 extends MDConstruction[(Int, Int, Int, Int)] { 0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039, 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1, 0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1, - 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391 - ) + 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391) private def g(t: Int): Int = { if (t < 16) t diff --git a/src/main/scala/hash/SHA256.scala b/src/main/scala/hash/SHA256.scala index fd00e16..97a3890 100644 --- a/src/main/scala/hash/SHA256.scala +++ b/src/main/scala/hash/SHA256.scala @@ -41,8 +41,7 @@ object SHA256 extends MDConstruction[(Int, Int, Int, Int, Int, Int, Int, Int)] { 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, - 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 - ) + 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2) def compressionFunction(state: (Int, Int, Int, Int, Int, Int, Int, Int), block: Seq[Byte]): (Int, Int, Int, Int, Int, Int, Int, Int) = { val w = ((block.grouped(4).toSeq map { bytes2word(_) }) ++ Seq.fill[Int](64) { 0 }).toArray diff --git a/src/main/scala/khash/Hmac.scala b/src/main/scala/khash/Hmac.scala index 1ce9cc0..06fde56 100644 --- a/src/main/scala/khash/Hmac.scala +++ b/src/main/scala/khash/Hmac.scala @@ -35,8 +35,7 @@ class Hmac(hash: Hash) extends KeyedHash[Key] { Success( hash.apply.fold(Element(iKeyPad)) map { innerHash ⇒ hash(oKeyPad ++ innerHash) - } - ) + }) } def verify(key: Key, hash: Seq[Byte]): Try[Iteratee[Seq[Byte], Boolean]] = apply(key) map { _ map { _ == hash } } diff --git a/src/main/scala/suites/AES_CBC_NoPadding.scala b/src/main/scala/suites/AES_CBC_NoPadding.scala index 9875dd2..d0c6e40 100644 --- a/src/main/scala/suites/AES_CBC_NoPadding.scala +++ b/src/main/scala/suites/AES_CBC_NoPadding.scala @@ -28,8 +28,7 @@ object AES128_CBC_NoPadding { 'iv -> (iv match { case Some(s) ⇒ s case _ ⇒ Random.nextBytes(16) - }) - ) + })) BlockCipher[AES128](params) flatMap { cipher ⇒ BlockCipherMode[CBC](params) flatMap { mode ⇒ @@ -49,8 +48,7 @@ object AES192_CBC_NoPadding { 'iv -> (iv match { case Some(s) ⇒ s case _ ⇒ Random.nextBytes(16) - }) - ) + })) BlockCipher[AES192](params) flatMap { cipher ⇒ BlockCipherMode[CBC](params) flatMap { mode ⇒ @@ -70,8 +68,7 @@ object AES256_CBC_NoPadding { 'iv -> (iv match { case Some(s) ⇒ s case _ ⇒ Random.nextBytes(16) - }) - ) + })) BlockCipher[AES256](params) flatMap { cipher ⇒ BlockCipherMode[CBC](params) flatMap { mode ⇒ diff --git a/src/main/scala/suites/AES_CBC_PKCS7Padding.scala b/src/main/scala/suites/AES_CBC_PKCS7Padding.scala index 4bc5fd9..beb4368 100644 --- a/src/main/scala/suites/AES_CBC_PKCS7Padding.scala +++ b/src/main/scala/suites/AES_CBC_PKCS7Padding.scala @@ -28,8 +28,7 @@ object AES128_CBC_PKCS7Padding { 'iv -> (iv match { case Some(s) ⇒ s case _ ⇒ Random.nextBytes(16) - }) - ) + })) BlockCipher[AES128](params) flatMap { cipher ⇒ BlockCipherMode[CBC](params) flatMap { mode ⇒ @@ -49,8 +48,7 @@ object AES192_CBC_PKCS7Padding { 'iv -> (iv match { case Some(s) ⇒ s case _ ⇒ Random.nextBytes(16) - }) - ) + })) BlockCipher[AES192](params) flatMap { cipher ⇒ BlockCipherMode[CBC](params) flatMap { mode ⇒ @@ -70,8 +68,7 @@ object AES256_CBC_PKCS7Padding { 'iv -> (iv match { case Some(s) ⇒ s case _ ⇒ Random.nextBytes(16) - }) - ) + })) BlockCipher[AES256](params) flatMap { cipher ⇒ BlockCipherMode[CBC](params) flatMap { mode ⇒ diff --git a/src/main/scala/suites/RSAES_OAEP.scala b/src/main/scala/suites/RSAES_OAEP.scala index 4af5c15..5316818 100644 --- a/src/main/scala/suites/RSAES_OAEP.scala +++ b/src/main/scala/suites/RSAES_OAEP.scala @@ -28,8 +28,7 @@ object RSAES_OAEP { 'rsaKey -> k, 'label -> label, 'hash -> hash, - 'generator -> genSeed - ) + 'generator -> genSeed) BlockCipher[RSA](params) flatMap { cipher ⇒ BlockCipherMode[ECB](params) flatMap { mode ⇒ diff --git a/src/main/scala/suites/Threefish_CBC_PKCS7Padding.scala b/src/main/scala/suites/Threefish_CBC_PKCS7Padding.scala index a1ac5e9..9e7c39a 100644 --- a/src/main/scala/suites/Threefish_CBC_PKCS7Padding.scala +++ b/src/main/scala/suites/Threefish_CBC_PKCS7Padding.scala @@ -32,8 +32,7 @@ object Threefish256_CBC_PKCS7Padding { 'tweak -> (tweak match { case Some(s) ⇒ s case _ ⇒ Random.nextBytes(16) - }) - ) + })) BlockCipher[Threefish256](params) flatMap { cipher ⇒ BlockCipherMode[CBC](params) flatMap { mode ⇒ @@ -57,8 +56,7 @@ object Threefish512_CBC_PKCS7Padding { 'tweak -> (tweak match { case Some(s) ⇒ s case _ ⇒ Random.nextBytes(16) - }) - ) + })) BlockCipher[Threefish512](params) flatMap { cipher ⇒ BlockCipherMode[CBC](params) flatMap { mode ⇒ @@ -82,8 +80,7 @@ object Threefish1024_CBC_PKCS7Padding { 'tweak -> (tweak match { case Some(s) ⇒ s case _ ⇒ Random.nextBytes(16) - }) - ) + })) BlockCipher[Threefish1024](params) flatMap { cipher ⇒ BlockCipherMode[CBC](params) flatMap { mode ⇒ diff --git a/src/main/scala/util/PBKDF2Easy.scala b/src/main/scala/util/PBKDF2Easy.scala index 7d661f0..8db3f5d 100644 --- a/src/main/scala/util/PBKDF2Easy.scala +++ b/src/main/scala/util/PBKDF2Easy.scala @@ -24,8 +24,7 @@ import scala.util.{ Try, Success, Failure } */ object PBKDF2Easy { lazy val algoMap = Map[Byte, KeyedHash[Key]]( - 1.toByte -> khash.HmacSHA256 - ) + 1.toByte -> khash.HmacSHA256) lazy val defaultAlgorithm = 1.toByte val defaultSaltLength = 32 diff --git a/src/test/scala/BlockCipherSpec.scala b/src/test/scala/BlockCipherSpec.scala index 9f48696..b35ce13 100644 --- a/src/test/scala/BlockCipherSpec.scala +++ b/src/test/scala/BlockCipherSpec.scala @@ -106,37 +106,30 @@ class AES128Spec extends BlockCipherSpec[SymmetricKey128, AES128] { val parameterTestVectors = Seq( (Parameters('symmetricKey256 -> Key.generate[SymmetricKey256]), false), - (Parameters('symmetricKey128 -> Key.generate[SymmetricKey192]), false) - ) + (Parameters('symmetricKey128 -> Key.generate[SymmetricKey192]), false)) val defaultKey = (Seq( 0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, - 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c - ) map { _.toByte }).toKey[SymmetricKey128].get + 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c) map { _.toByte }).toKey[SymmetricKey128].get val testVectors = Seq( ( Seq(0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96, 0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a) map { _.toByte }, defaultKey, Seq(0x3a, 0xd7, 0x7b, 0xb4, 0x0d, 0x7a, 0x36, 0x60, 0xa8, 0x9e, 0xca, 0xf3, 0x24, 0x66, 0xef, 0x97) map { _.toByte }, - None - ), ( + None), ( Seq(0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c, 0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51) map { _.toByte }, defaultKey, Seq(0xf5, 0xd3, 0xd5, 0x85, 0x03, 0xb9, 0x69, 0x9d, 0xe7, 0x85, 0x89, 0x5a, 0x96, 0xfd, 0xba, 0xaf) map { _.toByte }, - None - ), ( + None), ( Seq(0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11, 0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef) map { _.toByte }, defaultKey, Seq(0x43, 0xb1, 0xcd, 0x7f, 0x59, 0x8e, 0xce, 0x23, 0x88, 0x1b, 0x00, 0xe3, 0xed, 0x03, 0x06, 0x88) map { _.toByte }, - None - ), ( + None), ( Seq(0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17, 0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10) map { _.toByte }, defaultKey, Seq(0x7b, 0x0c, 0x78, 0x5e, 0x27, 0xe8, 0xad, 0x3f, 0x82, 0x23, 0x20, 0x71, 0x04, 0x72, 0x5d, 0xd4) map { _.toByte }, - None - ) - ) + None)) } class AES192Spec extends BlockCipherSpec[SymmetricKey192, AES192] { @@ -146,8 +139,7 @@ class AES192Spec extends BlockCipherSpec[SymmetricKey192, AES192] { val parameterTestVectors = Seq( (Parameters('symmetricKey256 -> Key.generate[SymmetricKey256]), false), - (Parameters('symmetricKey192 -> Key.generate[SymmetricKey1024]), false) - ) + (Parameters('symmetricKey192 -> Key.generate[SymmetricKey1024]), false)) val testVectors = Seq() } @@ -159,8 +151,7 @@ class AES256Spec extends BlockCipherSpec[SymmetricKey256, AES256] { val parameterTestVectors = Seq( (Parameters('symmetricKey128 -> Key.generate[SymmetricKey128]), false), - (Parameters('symmetricKey256 -> Key.generate[SymmetricKey128]), false) - ) + (Parameters('symmetricKey256 -> Key.generate[SymmetricKey128]), false)) val testVectors = Seq() } @@ -174,8 +165,7 @@ class Threefish256Spec extends BlockCipherSpec[SymmetricKey256, Threefish256] { val parameterTestVectors = Seq( (Parameters('symmetricKey128 -> Key.generate[SymmetricKey128], 'tweak -> tweak), false), (Parameters('symmetricKey256 -> Key.generate[SymmetricKey1024], 'tweak -> tweak), false), - (Parameters('symmetricKey256 -> Key.generate[SymmetricKey256], 'tweak -> (0 until 15 map { _.toByte })), false) - ) + (Parameters('symmetricKey256 -> Key.generate[SymmetricKey256], 'tweak -> (0 until 15 map { _.toByte })), false)) val testVectors = Seq() } @@ -189,8 +179,7 @@ class Threefish512Spec extends BlockCipherSpec[SymmetricKey512, Threefish512] { val parameterTestVectors = Seq( (Parameters('symmetricKey256 -> Key.generate[SymmetricKey256], 'tweak -> tweak), false), (Parameters('symmetricKey512 -> Key.generate[SymmetricKey1024], 'tweak -> tweak), false), - (Parameters('symmetricKey512 -> Key.generate[SymmetricKey512], 'tweak -> (0 until 15 map { _.toByte })), false) - ) + (Parameters('symmetricKey512 -> Key.generate[SymmetricKey512], 'tweak -> (0 until 15 map { _.toByte })), false)) val testVectors = Seq() } @@ -204,8 +193,7 @@ class Threefish1024Spec extends BlockCipherSpec[SymmetricKey1024, Threefish1024] val parameterTestVectors = Seq( (Parameters('symmetricKey256 -> Key.generate[SymmetricKey256], 'tweak -> tweak), false), (Parameters('symmetricKey1024 -> Key.generate[SymmetricKey256], 'tweak -> tweak), false), - (Parameters('symmetricKey512 -> Key.generate[SymmetricKey512], 'tweak -> (0 until 15 map { _.toByte })), false) - ) + (Parameters('symmetricKey512 -> Key.generate[SymmetricKey512], 'tweak -> (0 until 15 map { _.toByte })), false)) val testVectors = Seq() } @@ -263,8 +251,7 @@ class RSACrtSpec extends BlockCipherSpec[RSAKey, RSA] { val parameterTestVectors = Seq( (Parameters('symmetricKey256 -> Key.generate[SymmetricKey256]), false), - (Parameters('rsaKey -> Key.generate[SymmetricKey1024]), false) - ) + (Parameters('rsaKey -> Key.generate[SymmetricKey1024]), false)) val testVectors = Seq() } @@ -324,8 +311,7 @@ class RSAExpSpec extends BlockCipherSpec[RSAKey, RSA] { val parameterTestVectors = Seq( (Parameters('symmetricKey256 -> Key.generate[SymmetricKey256]), false), - (Parameters('rsaKey -> Key.generate[SymmetricKey1024]), false) - ) + (Parameters('rsaKey -> Key.generate[SymmetricKey1024]), false)) val testVectors = Seq() } diff --git a/src/test/scala/BlockPaddingSpec.scala b/src/test/scala/BlockPaddingSpec.scala index a2594f7..fd76706 100644 --- a/src/test/scala/BlockPaddingSpec.scala +++ b/src/test/scala/BlockPaddingSpec.scala @@ -25,33 +25,25 @@ class BlockPaddingSpec extends FlatSpec with Matchers { ( 16, Seq(Seq(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)), - Seq(Seq(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 6, 6, 6, 6, 6, 6)) - ), ( + Seq(Seq(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 6, 6, 6, 6, 6, 6))), ( 16, Seq(Seq(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16)), - Seq(Seq(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16), Seq(16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16)) - ), ( + Seq(Seq(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16), Seq(16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16))), ( 16, Seq(Seq()), - Seq(Seq(16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16)) - ), ( + Seq(Seq(16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16))), ( 8, Seq(Seq(1, 2, 3, 4, 5, 6)), - Seq(Seq(1, 2, 3, 4, 5, 6, 2, 2)) - ), ( + Seq(Seq(1, 2, 3, 4, 5, 6, 2, 2))), ( 8, Seq(Seq(1, 2, 3, 4, 5, 6, 7, 8)), - Seq(Seq(1, 2, 3, 4, 5, 6, 7, 8), Seq(8, 8, 8, 8, 8, 8, 8, 8)) - ), ( + Seq(Seq(1, 2, 3, 4, 5, 6, 7, 8), Seq(8, 8, 8, 8, 8, 8, 8, 8))), ( 8, Seq(Seq()), - Seq(Seq(8, 8, 8, 8, 8, 8, 8, 8)) - ), ( + Seq(Seq(8, 8, 8, 8, 8, 8, 8, 8))), ( 16, Seq(Seq(1, 2, 3), Seq(4, 5, 6), Seq(7, 8, 9), Seq(10)), - Seq(Seq(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 6, 6, 6, 6, 6, 6)) - ) - ) + Seq(Seq(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 6, 6, 6, 6, 6, 6)))) for (testvector <- testvectors) { val padding = BlockPadding[PKCS7Padding](Parameters()).get @@ -65,25 +57,19 @@ class BlockPaddingSpec extends FlatSpec with Matchers { ( // Does not contain padding block 8, - Seq(Seq(1, 2, 3, 4, 5, 6, 7, 8), Seq(1, 2, 3, 4, 5, 6, 7, 8)) - ), ( + Seq(Seq(1, 2, 3, 4, 5, 6, 7, 8), Seq(1, 2, 3, 4, 5, 6, 7, 8))), ( // Wrong padding byte 8, - Seq(Seq(1, 2, 3, 4, 5, 6, 3, 3)) - ), ( + Seq(Seq(1, 2, 3, 4, 5, 6, 3, 3))), ( // Illegal block size 8, - Seq(Seq(1, 2, 3, 4, 5, 6, 7), Seq(1)) - ), ( + Seq(Seq(1, 2, 3, 4, 5, 6, 7), Seq(1))), ( // Illegal block size 8, - Seq(Seq(1, 2, 3), Seq(8, 8, 8, 8, 8, 8, 8, 8)) - ), ( + Seq(Seq(1, 2, 3), Seq(8, 8, 8, 8, 8, 8, 8, 8))), ( // Wrong byte inside padding 8, - Seq(Seq(1, 2, 6, 6, 6, 7, 6, 6)) - ) - ) + Seq(Seq(1, 2, 6, 6, 6, 7, 6, 6)))) for (test <- tests) { val padding = BlockPadding[PKCS7Padding](Parameters()).get diff --git a/src/test/scala/HashSpec.scala b/src/test/scala/HashSpec.scala index ec01863..e202a63 100644 --- a/src/test/scala/HashSpec.scala +++ b/src/test/scala/HashSpec.scala @@ -23,18 +23,13 @@ class HashSpec extends FlatSpec with Matchers { val vectors = Seq( ( "".getBytes.toSeq, - Seq(0xda, 0x39, 0xa3, 0xee, 0x5e, 0x6b, 0x4b, 0x0d, 0x32, 0x55, 0xbf, 0xef, 0x95, 0x60, 0x18, 0x90, 0xaf, 0xd8, 0x07, 0x09) - ), ( + Seq(0xda, 0x39, 0xa3, 0xee, 0x5e, 0x6b, 0x4b, 0x0d, 0x32, 0x55, 0xbf, 0xef, 0x95, 0x60, 0x18, 0x90, 0xaf, 0xd8, 0x07, 0x09)), ( "abc".getBytes.toSeq, - Seq(0xa9, 0x99, 0x3e, 0x36, 0x47, 0x06, 0x81, 0x6a, 0xba, 0x3e, 0x25, 0x71, 0x78, 0x50, 0xc2, 0x6c, 0x9c, 0xd0, 0xd8, 0x9d) - ), ( + Seq(0xa9, 0x99, 0x3e, 0x36, 0x47, 0x06, 0x81, 0x6a, 0xba, 0x3e, 0x25, 0x71, 0x78, 0x50, 0xc2, 0x6c, 0x9c, 0xd0, 0xd8, 0x9d)), ( "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu".getBytes.toSeq, - Seq(0xa4, 0x9b, 0x24, 0x46, 0xa0, 0x2c, 0x64, 0x5b, 0xf4, 0x19, 0xf9, 0x95, 0xb6, 0x70, 0x91, 0x25, 0x3a, 0x04, 0xa2, 0x59) - ), ( + Seq(0xa4, 0x9b, 0x24, 0x46, 0xa0, 0x2c, 0x64, 0x5b, 0xf4, 0x19, 0xf9, 0x95, 0xb6, 0x70, 0x91, 0x25, 0x3a, 0x04, 0xa2, 0x59)), ( Seq.fill[Byte](1000000) { 'a'.toByte }, - Seq(0x34, 0xaa, 0x97, 0x3c, 0xd4, 0xc4, 0xda, 0xa4, 0xf6, 0x1e, 0xeb, 0x2b, 0xdb, 0xad, 0x27, 0x31, 0x65, 0x34, 0x01, 0x6f) - ) - ) + Seq(0x34, 0xaa, 0x97, 0x3c, 0xd4, 0xc4, 0xda, 0xa4, 0xf6, 0x1e, 0xeb, 0x2b, 0xdb, 0xad, 0x27, 0x31, 0x65, 0x34, 0x01, 0x6f))) for (vector <- vectors) { val hash = SHA1(vector._1) @@ -47,18 +42,13 @@ class HashSpec extends FlatSpec with Matchers { val vectors = Seq( ( "".getBytes.toSeq, - Seq(0xe3, 0xb0, 0xc4, 0x42, 0x98, 0xfc, 0x1c, 0x14, 0x9a, 0xfb, 0xf4, 0xc8, 0x99, 0x6f, 0xb9, 0x24, 0x27, 0xae, 0x41, 0xe4, 0x64, 0x9b, 0x93, 0x4c, 0xa4, 0x95, 0x99, 0x1b, 0x78, 0x52, 0xb8, 0x55) - ), ( + Seq(0xe3, 0xb0, 0xc4, 0x42, 0x98, 0xfc, 0x1c, 0x14, 0x9a, 0xfb, 0xf4, 0xc8, 0x99, 0x6f, 0xb9, 0x24, 0x27, 0xae, 0x41, 0xe4, 0x64, 0x9b, 0x93, 0x4c, 0xa4, 0x95, 0x99, 0x1b, 0x78, 0x52, 0xb8, 0x55)), ( "abc".getBytes.toSeq, - Seq(0xba, 0x78, 0x16, 0xbf, 0x8f, 0x01, 0xcf, 0xea, 0x41, 0x41, 0x40, 0xde, 0x5d, 0xae, 0x22, 0x23, 0xb0, 0x03, 0x61, 0xa3, 0x96, 0x17, 0x7a, 0x9c, 0xb4, 0x10, 0xff, 0x61, 0xf2, 0x00, 0x15, 0xad) - ), ( + Seq(0xba, 0x78, 0x16, 0xbf, 0x8f, 0x01, 0xcf, 0xea, 0x41, 0x41, 0x40, 0xde, 0x5d, 0xae, 0x22, 0x23, 0xb0, 0x03, 0x61, 0xa3, 0x96, 0x17, 0x7a, 0x9c, 0xb4, 0x10, 0xff, 0x61, 0xf2, 0x00, 0x15, 0xad)), ( "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu".getBytes.toSeq, - Seq(0xcf, 0x5b, 0x16, 0xa7, 0x78, 0xaf, 0x83, 0x80, 0x03, 0x6c, 0xe5, 0x9e, 0x7b, 0x04, 0x92, 0x37, 0x0b, 0x24, 0x9b, 0x11, 0xe8, 0xf0, 0x7a, 0x51, 0xaf, 0xac, 0x45, 0x03, 0x7a, 0xfe, 0xe9, 0xd1) - ), ( + Seq(0xcf, 0x5b, 0x16, 0xa7, 0x78, 0xaf, 0x83, 0x80, 0x03, 0x6c, 0xe5, 0x9e, 0x7b, 0x04, 0x92, 0x37, 0x0b, 0x24, 0x9b, 0x11, 0xe8, 0xf0, 0x7a, 0x51, 0xaf, 0xac, 0x45, 0x03, 0x7a, 0xfe, 0xe9, 0xd1)), ( Seq.fill[Byte](1000000) { 'a'.toByte }, - Seq(0xcd, 0xc7, 0x6e, 0x5c, 0x99, 0x14, 0xfb, 0x92, 0x81, 0xa1, 0xc7, 0xe2, 0x84, 0xd7, 0x3e, 0x67, 0xf1, 0x80, 0x9a, 0x48, 0xa4, 0x97, 0x20, 0x0e, 0x04, 0x6d, 0x39, 0xcc, 0xc7, 0x11, 0x2c, 0xd0) - ) - ) + Seq(0xcd, 0xc7, 0x6e, 0x5c, 0x99, 0x14, 0xfb, 0x92, 0x81, 0xa1, 0xc7, 0xe2, 0x84, 0xd7, 0x3e, 0x67, 0xf1, 0x80, 0x9a, 0x48, 0xa4, 0x97, 0x20, 0x0e, 0x04, 0x6d, 0x39, 0xcc, 0xc7, 0x11, 0x2c, 0xd0))) for (vector <- vectors) { val hash = SHA256(vector._1) diff --git a/src/test/scala/PBKDF2Spec.scala b/src/test/scala/PBKDF2Spec.scala index 8920f01..b2a9b09 100644 --- a/src/test/scala/PBKDF2Spec.scala +++ b/src/test/scala/PBKDF2Spec.scala @@ -27,24 +27,19 @@ class PBKDF2Spec extends FlatSpec with Matchers { "password", "salt", 1, - Seq(0x0c, 0x60, 0xc8, 0x0f, 0x96, 0x1f, 0x0e, 0x71, 0xf3, 0xa9, 0xb5, 0x24, 0xaf, 0x60, 0x12, 0x06, 0x2f, 0xe0, 0x37, 0xa6) map { _.toByte } - ), ( + Seq(0x0c, 0x60, 0xc8, 0x0f, 0x96, 0x1f, 0x0e, 0x71, 0xf3, 0xa9, 0xb5, 0x24, 0xaf, 0x60, 0x12, 0x06, 0x2f, 0xe0, 0x37, 0xa6) map { _.toByte }), ( "password", "salt", 2, - Seq(0xea, 0x6c, 0x01, 0x4d, 0xc7, 0x2d, 0x6f, 0x8c, 0xcd, 0x1e, 0xd9, 0x2a, 0xce, 0x1d, 0x41, 0xf0, 0xd8, 0xde, 0x89, 0x57) map { _.toByte } - ), ( + Seq(0xea, 0x6c, 0x01, 0x4d, 0xc7, 0x2d, 0x6f, 0x8c, 0xcd, 0x1e, 0xd9, 0x2a, 0xce, 0x1d, 0x41, 0xf0, 0xd8, 0xde, 0x89, 0x57) map { _.toByte }), ( "password", "salt", 4096, - Seq(0x4b, 0x00, 0x79, 0x01, 0xb7, 0x65, 0x48, 0x9a, 0xbe, 0xad, 0x49, 0xd9, 0x26, 0xf7, 0x21, 0xd0, 0x65, 0xa4, 0x29, 0xc1) map { _.toByte } - ), ( + Seq(0x4b, 0x00, 0x79, 0x01, 0xb7, 0x65, 0x48, 0x9a, 0xbe, 0xad, 0x49, 0xd9, 0x26, 0xf7, 0x21, 0xd0, 0x65, 0xa4, 0x29, 0xc1) map { _.toByte }), ( "passwordPASSWORDpassword", "saltSALTsaltSALTsaltSALTsaltSALTsalt", 4096, - Seq(0x3d, 0x2e, 0xec, 0x4f, 0xe4, 0x1c, 0x84, 0x9b, 0x80, 0xc8, 0xd8, 0x36, 0x62, 0xc0, 0xe4, 0x4a, 0x8b, 0x29, 0x1a, 0x96, 0x4c, 0xf2, 0xf0, 0x70, 0x38) map { _.toByte } - ) - ) + Seq(0x3d, 0x2e, 0xec, 0x4f, 0xe4, 0x1c, 0x84, 0x9b, 0x80, 0xc8, 0xd8, 0x36, 0x62, 0xc0, 0xe4, 0x4a, 0x8b, 0x29, 0x1a, 0x96, 0x4c, 0xf2, 0xf0, 0x70, 0x38) map { _.toByte })) for (test <- tests) { val instance = PBKDF2(HmacSHA1, test._3, test._4.length) diff --git a/src/test/scala/RichBigIntSpec.scala b/src/test/scala/RichBigIntSpec.scala index e171993..3d9b490 100644 --- a/src/test/scala/RichBigIntSpec.scala +++ b/src/test/scala/RichBigIntSpec.scala @@ -23,24 +23,17 @@ class RichBigIntSpec extends FlatSpec with Matchers { val tests = Seq[(Int, Seq[Int])]( ( 0, - Seq(0, 0, 0) - ), ( + Seq(0, 0, 0)), ( 1, - Seq(0, 0, 1) - ), ( + Seq(0, 0, 1)), ( 255, - Seq(0, 0, 255) - ), ( + Seq(0, 0, 255)), ( 256, - Seq(0, 1, 0) - ), ( + Seq(0, 1, 0)), ( 257, - Seq(0, 1, 1) - ), ( + Seq(0, 1, 1)), ( 511, - Seq(0, 1, 255) - ) - ) + Seq(0, 1, 255))) for (test <- tests) { val int = BigInt(test._1) diff --git a/src/test/scala/SymmetricBlockCipherSuiteSpec.scala b/src/test/scala/SymmetricBlockCipherSuiteSpec.scala index 1c69d41..8d2d3a7 100644 --- a/src/test/scala/SymmetricBlockCipherSuiteSpec.scala +++ b/src/test/scala/SymmetricBlockCipherSuiteSpec.scala @@ -23,21 +23,16 @@ class SymmetricBlockCipherSuiteSpec extends FlatSpec with Matchers { ( Seq(0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F) map { _.toByte }, Seq(0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96, 0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a) map { _.toByte }, - Seq(0x76, 0x49, 0xab, 0xac, 0x81, 0x19, 0xb2, 0x46, 0xce, 0xe9, 0x8e, 0x9b, 0x12, 0xe9, 0x19, 0x7d) map { _.toByte } - ), ( + Seq(0x76, 0x49, 0xab, 0xac, 0x81, 0x19, 0xb2, 0x46, 0xce, 0xe9, 0x8e, 0x9b, 0x12, 0xe9, 0x19, 0x7d) map { _.toByte }), ( Seq(0x76, 0x49, 0xAB, 0xAC, 0x81, 0x19, 0xB2, 0x46, 0xCE, 0xE9, 0x8E, 0x9B, 0x12, 0xE9, 0x19, 0x7D) map { _.toByte }, Seq(0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c, 0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51) map { _.toByte }, - Seq(0x50, 0x86, 0xcb, 0x9b, 0x50, 0x72, 0x19, 0xee, 0x95, 0xdb, 0x11, 0x3a, 0x91, 0x76, 0x78, 0xb2) map { _.toByte } - ), ( + Seq(0x50, 0x86, 0xcb, 0x9b, 0x50, 0x72, 0x19, 0xee, 0x95, 0xdb, 0x11, 0x3a, 0x91, 0x76, 0x78, 0xb2) map { _.toByte }), ( Seq(0x50, 0x86, 0xCB, 0x9B, 0x50, 0x72, 0x19, 0xEE, 0x95, 0xDB, 0x11, 0x3A, 0x91, 0x76, 0x78, 0xB2) map { _.toByte }, Seq(0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11, 0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef) map { _.toByte }, - Seq(0x73, 0xbe, 0xd6, 0xb8, 0xe3, 0xc1, 0x74, 0x3b, 0x71, 0x16, 0xe6, 0x9e, 0x22, 0x22, 0x95, 0x16) map { _.toByte } - ), ( + Seq(0x73, 0xbe, 0xd6, 0xb8, 0xe3, 0xc1, 0x74, 0x3b, 0x71, 0x16, 0xe6, 0x9e, 0x22, 0x22, 0x95, 0x16) map { _.toByte }), ( Seq(0x73, 0xBE, 0xD6, 0xB8, 0xE3, 0xC1, 0x74, 0x3B, 0x71, 0x16, 0xE6, 0x9E, 0x22, 0x22, 0x95, 0x16) map { _.toByte }, Seq(0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17, 0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10) map { _.toByte }, - Seq(0x3f, 0xf1, 0xca, 0xa1, 0x68, 0x1f, 0xac, 0x09, 0x12, 0x0e, 0xca, 0x30, 0x75, 0x86, 0xe1, 0xa7) map { _.toByte } - ) - ) + Seq(0x3f, 0xf1, 0xca, 0xa1, 0x68, 0x1f, 0xac, 0x09, 0x12, 0x0e, 0xca, 0x30, 0x75, 0x86, 0xe1, 0xa7) map { _.toByte })) for (test <- testvectors) { val enc = suites.AES128_CBC_NoPadding(Seq(0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c).map({ _.toByte }).toKey[SymmetricKey128].get, Some(test._1)).get @@ -54,13 +49,10 @@ class SymmetricBlockCipherSuiteSpec extends FlatSpec with Matchers { val tests = Seq[Seq[Seq[Byte]]]( Seq( - Seq(1, 2, 3), Seq(2, 3, 4) - ), Seq( + Seq(1, 2, 3), Seq(2, 3, 4)), Seq( Seq(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17), Seq(18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30), - Seq(31, 32, 33, 34, 35) - ) - ) + Seq(31, 32, 33, 34, 35))) for (test <- tests) { val key = Key.generate[SymmetricKey128] diff --git a/src/test/scala/ThreefishSpec.scala b/src/test/scala/ThreefishSpec.scala index 78e9ea8..e8f7248 100644 --- a/src/test/scala/ThreefishSpec.scala +++ b/src/test/scala/ThreefishSpec.scala @@ -23,8 +23,7 @@ class ThreefishSpec extends FlatSpec with Matchers { 'symmetricKey256 -> Key.generate[SymmetricKey256], 'symmetricKey512 -> Key.generate[SymmetricKey512], 'symmetricKey1024 -> Key.generate[SymmetricKey1024], - 'tweak -> ((1 to 16) map { _.toByte }) - ) + 'tweak -> ((1 to 16) map { _.toByte })) val tf256 = BlockCipher[Threefish256](params).get val tf512 = BlockCipher[Threefish512](params).get @@ -36,14 +35,11 @@ class ThreefishSpec extends FlatSpec with Matchers { Seq(0, 0, 0, 0), Seq(0, 0), Seq(0, 0, 0, 0), - Seq(0x94EEEA8B1F2ADA84L, 0xADF103313EAE6670L, 0x952419A1F4B16D53L, 0xD83F13E63C9F6B11L) - ), ( + Seq(0x94EEEA8B1F2ADA84L, 0xADF103313EAE6670L, 0x952419A1F4B16D53L, 0xD83F13E63C9F6B11L)), ( Seq(0x1716151413121110L, 0x1F1E1D1C1B1A1918L, 0x2726252423222120L, 0x2F2E2D2C2B2A2928L), Seq(0x0706050403020100L, 0x0F0E0D0C0B0A0908L), Seq(0xF8F9FAFBFCFDFEFFL, 0xF0F1F2F3F4F5F6F7L, 0xE8E9EAEBECEDEEEFL, 0xE0E1E2E3E4E5E6E7L), - Seq(0x277610F5036C2E1FL, 0x25FB2ADD1267773EL, 0x9E1D67B3E4B06872L, 0x3F76BC7651B39682L) - ) - ) + Seq(0x277610F5036C2E1FL, 0x25FB2ADD1267773EL, 0x9E1D67B3E4B06872L, 0x3F76BC7651B39682L))) val tests512 = Seq[(Seq[Long], Seq[Long], Seq[Long], Seq[Long])]( ( @@ -51,17 +47,14 @@ class ThreefishSpec extends FlatSpec with Matchers { Seq(0, 0), Seq(0, 0, 0, 0, 0, 0, 0, 0), Seq(0xBC2560EFC6BBA2B1L, 0xE3361F162238EB40L, 0xFB8631EE0ABBD175L, 0x7B9479D4C5479ED1L, - 0xCFF0356E58F8C27BL, 0xB1B7B08430F0E7F7L, 0xE9A380A56139ABF1L, 0xBE7B6D4AA11EB47EL) - ), ( + 0xCFF0356E58F8C27BL, 0xB1B7B08430F0E7F7L, 0xE9A380A56139ABF1L, 0xBE7B6D4AA11EB47EL)), ( Seq(0x1716151413121110L, 0x1F1E1D1C1B1A1918L, 0x2726252423222120L, 0x2F2E2D2C2B2A2928L, 0x3736353433323130L, 0x3F3E3D3C3B3A3938L, 0x4746454443424140L, 0x4F4E4D4C4B4A4948L), Seq(0x0706050403020100L, 0x0F0E0D0C0B0A0908L), Seq(0xF8F9FAFBFCFDFEFFL, 0xF0F1F2F3F4F5F6F7L, 0xE8E9EAEBECEDEEEFL, 0xE0E1E2E3E4E5E6E7L, 0xD8D9DADBDCDDDEDFL, 0xD0D1D2D3D4D5D6D7L, 0xC8C9CACBCCCDCECFL, 0xC0C1C2C3C4C5C6C7L), Seq(0xD4A32EDD6ABEFA1CL, 0x6AD5C4252C3FF743L, 0x35AC875BE2DED68CL, 0x99A6C774EA5CD06CL, - 0xDCEC9C4251D7F4F8L, 0xF5761BCB3EF592AFL, 0xFCABCB6A3212DF60L, 0xFD6EDE9FF9A2E14EL) - ) - ) + 0xDCEC9C4251D7F4F8L, 0xF5761BCB3EF592AFL, 0xFCABCB6A3212DF60L, 0xFD6EDE9FF9A2E14EL))) val tests1024 = Seq[(Seq[Long], Seq[Long], Seq[Long], Seq[Long])]( ( @@ -71,8 +64,7 @@ class ThreefishSpec extends FlatSpec with Matchers { Seq(0x04B3053D0A3D5CF0L, 0x0136E0D1C7DD85F7L, 0x067B212F6EA78A5CL, 0x0DA9C10B4C54E1C6L, 0x0F4EC27394CBACF0L, 0x32437F0568EA4FD5L, 0xCFF56D1D7654B49CL, 0xA2D5FB14369B2E7BL, 0x540306B460472E0BL, 0x71C18254BCEA820DL, 0xC36B4068BEAF32C8L, 0xFA4329597A360095L, - 0xC4A36C28434A5B9AL, 0xD54331444B1046CFL, 0xDF11834830B2A460L, 0x1E39E8DFE1F7EE4FL) - ), ( + 0xC4A36C28434A5B9AL, 0xD54331444B1046CFL, 0xDF11834830B2A460L, 0x1E39E8DFE1F7EE4FL)), ( Seq(0x1716151413121110L, 0x1F1E1D1C1B1A1918L, 0x2726252423222120L, 0x2F2E2D2C2B2A2928L, 0x3736353433323130L, 0x3F3E3D3C3B3A3938L, 0x4746454443424140L, 0x4F4E4D4C4B4A4948L, 0x5756555453525150L, 0x5F5E5D5C5B5A5958L, 0x6766656463626160L, 0x6F6E6D6C6B6A6968L, @@ -85,31 +77,26 @@ class ThreefishSpec extends FlatSpec with Matchers { Seq(0x483AC62C27B09B59L, 0x4CB85AA9E48221AAL, 0x80BC1644069F7D0BL, 0xFCB26748FF92B235L, 0xE83D70243B5D294BL, 0x316A3CA3587A0E02L, 0x5461FD7C8EF6C1B9L, 0x7DD5C1A4C98CA574L, 0xFDA694875AA31A35L, 0x03D1319C26C2624CL, 0xA2066D0DF2BF7827L, 0x6831CCDAA5C8A370L, - 0x2B8FCD9189698DACL, 0xE47818BBFD604399L, 0xDF47E519CBCEA541L, 0x5EFD5FF4A5D4C259L) - ) - ) + 0x2B8FCD9189698DACL, 0xE47818BBFD604399L, 0xDF47E519CBCEA541L, 0x5EFD5FF4A5D4C259L))) val test0Params = Parameters( 'symmetricKey256 -> Threefish.words2block(tests256(0)._1).toKey[SymmetricKey256].get, 'symmetricKey512 -> Threefish.words2block(tests512(0)._1).toKey[SymmetricKey512].get, 'symmetricKey1024 -> Threefish.words2block(tests1024(0)._1).toKey[SymmetricKey1024].get, - 'tweak -> Threefish.words2block(tests256(0)._2) - ) + 'tweak -> Threefish.words2block(tests256(0)._2)) val test1Params = Parameters( 'symmetricKey256 -> Threefish.words2block(tests256(1)._1).toKey[SymmetricKey256].get, 'symmetricKey512 -> Threefish.words2block(tests512(1)._1).toKey[SymmetricKey512].get, 'symmetricKey1024 -> Threefish.words2block(tests1024(1)._1).toKey[SymmetricKey1024].get, - 'tweak -> Threefish.words2block(tests256(1)._2) - ) + 'tweak -> Threefish.words2block(tests256(1)._2)) "The Threefish mix function" should "be reversible." in { val tests = Seq[(Long, Long, Int)]( (5122421, 2141242, 53), (12, Long.MaxValue, 5), (Long.MaxValue, 5152124, 5), - (Long.MaxValue, Long.MaxValue, 34) - ) + (Long.MaxValue, Long.MaxValue, 34)) for (test <- tests) { val mix = Threefish.mix(test._1, test._2, test._3) val unmix = Threefish.unmix(mix(0), mix(1), test._3) @@ -125,33 +112,27 @@ class ThreefishSpec extends FlatSpec with Matchers { Seq(0, 0, 0, 0, 0, 0, 0, 0) map { _.toByte }, 0, Seq(0, 0, 0, 0, 0, 0, 0, 0) map { _.toByte }, - Seq(0, 0, 0, 0, 0, 0, 0, 0) map { _.toByte } - ), ( + Seq(0, 0, 0, 0, 0, 0, 0, 0) map { _.toByte }), ( Seq(1, 0, 0, 0, 0, 0, 0, 0) map { _.toByte }, Seq(1, 0, 0, 0, 0, 0, 0, 0) map { _.toByte }, 0, Seq(2, 0, 0, 0, 0, 0, 0, 0) map { _.toByte }, - Seq(3, 0, 0, 0, 0, 0, 0, 0) map { _.toByte } - ), ( + Seq(3, 0, 0, 0, 0, 0, 0, 0) map { _.toByte }), ( Seq(1, 0, 0, 0, 0, 0, 0, 0) map { _.toByte }, Seq(1, 0, 0, 0, 0, 0, 0, 0) map { _.toByte }, 1, Seq(2, 0, 0, 0, 0, 0, 0, 0) map { _.toByte }, - Seq(0, 0, 0, 0, 0, 0, 0, 0) map { _.toByte } - ), ( + Seq(0, 0, 0, 0, 0, 0, 0, 0) map { _.toByte }), ( Seq(232, 3, 0, 0, 0, 0, 0, 0) map { _.toByte }, Seq(208, 7, 0, 0, 0, 0, 0, 0) map { _.toByte }, 5, Seq(184, 11, 0, 0, 0, 0, 0, 0) map { _.toByte }, - Seq(184, 241, 0, 0, 0, 0, 0, 0) map { _.toByte } - ), ( + Seq(184, 241, 0, 0, 0, 0, 0, 0) map { _.toByte }), ( Seq(232, 3, 0, 0, 0, 0, 0, 0) map { _.toByte }, Seq(208, 7, 0, 0, 0, 0, 0, 0) map { _.toByte }, 62, Seq(184, 11, 0, 0, 0, 0, 0, 0) map { _.toByte }, - Seq(76, 10, 0, 0, 0, 0, 0, 0) map { _.toByte } - ) - ) + Seq(76, 10, 0, 0, 0, 0, 0, 0) map { _.toByte })) for (test <- tests) { val a = Threefish.bytes2word(test._1)