Apply scalafmt

davenverse · Aug 17, 2021 · 21113f9 · 21113f9
1 parent 7d4ef49
commit 21113f9
Show file tree

Hide file tree

Showing 11 changed files with 51 additions and 41 deletions.
diff --git a/common/src/main/scala/tsec/common/ManagedRandom.scala b/common/src/main/scala/tsec/common/ManagedRandom.scala
@@ -10,7 +10,8 @@ trait ManagedRandom {
     * [[https://tersesystems.com/2015/12/17/the-right-way-to-use-securerandom/]]
     */
   private[tsec] val cachedRand: SecureRandom = {
-    val r = SecureRandom.getInstance(if ( scala.util.Properties.isWin ) ManagedRandom.WinRandom else ManagedRandom.UnixURandom)
+    val r =
+      SecureRandom.getInstance(if (scala.util.Properties.isWin) ManagedRandom.WinRandom else ManagedRandom.UnixURandom)
     r.nextBytes(new Array[Byte](20)) //Force reseed
     r
   }
@@ -20,6 +21,6 @@ trait ManagedRandom {
 }
 
 object ManagedRandom {
-  private[ManagedRandom] val WinRandom = "Windows-PRNG"
+  private[ManagedRandom] val WinRandom   = "Windows-PRNG"
   private[ManagedRandom] val UnixURandom = "NativePRNGNonBlocking"
 }
diff --git a/tsec-http4s/src/main/scala/tsec/authentication/EncryptedCookieAuthenticator.scala b/tsec-http4s/src/main/scala/tsec/authentication/EncryptedCookieAuthenticator.scala
@@ -8,7 +8,7 @@ import cats.syntax.all._
 import io.circe.Json
 import io.circe.parser.decode
 import io.circe.syntax._
-import io.circe.{Encoder, Decoder}
+import io.circe.{Decoder, Encoder}
 import org.http4s._
 import tsec.cipher.symmetric.{IvGen, _}
 import tsec.cipher.symmetric.jca._
@@ -99,8 +99,8 @@ object AuthEncryptedCookie {
 
   object Internal {
     import io.circe.generic.semiauto._
-    implicit def decoder[T : Decoder]: Decoder[Internal[T]] = deriveDecoder[Internal[T]]
-    implicit def encoder[T : Encoder]: Encoder[Internal[T]] = deriveEncoder[Internal[T]]
+    implicit def decoder[T: Decoder]: Decoder[Internal[T]] = deriveDecoder[Internal[T]]
+    implicit def encoder[T: Encoder]: Encoder[Internal[T]] = deriveEncoder[Internal[T]]
   }
 
   def build[A, Id](
@@ -418,10 +418,10 @@ object EncryptedCookieAuthenticator {
         for {
           cookieId <- F.delay(UUID.randomUUID())
           now      <- F.delay(Instant.now())
-          expiry      = now.plusSeconds(settings.expiryDuration.toSeconds)
-          lastTouched = settings.maxIdle.map(_ => now)
-          messageBodyJson = AuthEncryptedCookie.Internal(cookieId, body, expiry, lastTouched).asJson : Json
-          messageBody = messageBodyJson.printWith(JWTPrinter)
+          expiry          = now.plusSeconds(settings.expiryDuration.toSeconds)
+          lastTouched     = settings.maxIdle.map(_ => now)
+          messageBodyJson = AuthEncryptedCookie.Internal(cookieId, body, expiry, lastTouched).asJson: Json
+          messageBody     = messageBodyJson.printWith(JWTPrinter)
           encrypted <- AEADCookieEncryptor.signAndEncrypt[F, A](messageBody, generateAAD(messageBody), key)
         } yield AuthEncryptedCookie.build[A, I](cookieId, encrypted, body, expiry, lastTouched, settings)
 

diff --git a/tsec-http4s/src/main/scala/tsec/authentication/JWTAuthenticator.scala b/tsec-http4s/src/main/scala/tsec/authentication/JWTAuthenticator.scala
@@ -5,8 +5,8 @@ import cats.data.OptionT
 import cats.effect.Sync
 import cats.instances.string._
 import cats.syntax.all._
-import io.circe.{Encoder, Decoder}
-import org.http4s.{Request, Header, ResponseCookie, Response, HttpDate}
+import io.circe.{Decoder, Encoder}
+import org.http4s.{Header, HttpDate, Request, Response, ResponseCookie}
 import org.typelevel.ci.CIString
 import tsec.authentication.internal._
 import tsec.common._

diff --git a/tsec-http4s/src/main/scala/tsec/authentication/package.scala b/tsec-http4s/src/main/scala/tsec/authentication/package.scala
@@ -280,7 +280,6 @@ package object authentication {
         )
   }
 
-
   private[tsec] implicit val InstantLongEncoder: Encoder[Instant] = new Encoder[Instant] {
     def apply(a: Instant): Json = Json.fromLong(a.getEpochSecond)
   }

diff --git a/tsec-http4s/src/main/scala/tsec/authorization/package.scala b/tsec-http4s/src/main/scala/tsec/authorization/package.scala
@@ -7,7 +7,7 @@ import scala.reflect.ClassTag
 package object authorization {
 
   type AuthGroup[G] = AuthGroup.Type[G]
-  
+
   object AuthGroup {
     type Type[A] <: Array[A]
 
@@ -23,7 +23,7 @@ package object authorization {
     }
     def fromSeq[G: ClassTag](seq: Seq[G]): AuthGroup[G]       = unsafeApply[G](seq.distinct.toArray)
     def unsafeFromSeq[G: ClassTag](seq: Seq[G]): AuthGroup[G] = unsafeApply(seq.toArray)
-    def empty[G: ClassTag]: AuthGroup[G]           = unsafeApply[G](Array.empty[G])
+    def empty[G: ClassTag]: AuthGroup[G]                      = unsafeApply[G](Array.empty[G])
   }
 
   /** A simple typeclass that allows us to propagate information that is required for authorization */

diff --git a/tsec-http4s/src/main/scala/tsec/csrf/TSecCSRF.scala b/tsec-http4s/src/main/scala/tsec/csrf/TSecCSRF.scala
@@ -99,12 +99,12 @@ final class TSecCSRF[F[_], A] private[tsec] (
 
   private[tsec] def checkCSRF(r: Request[F], service: HttpRoutes[F]): F[Response[F]] =
     (for {
-      c1       <- cookieFromRequest[F](cookieName, r)
-      c2       <- OptionT.fromOption[F](r.headers.get(org.typelevel.ci.CIString(headerName)).map(_.head.value))
-      raw1     <- extractRaw(CSRFToken(c1.content))
-      raw2     <- extractRaw(CSRFToken(c2))
-      res: Response[F]      <- if (isEqual(raw1, raw2)) service(r) else OptionT.none
-      newToken <- OptionT.liftF(signToken(raw1)) //Generate a new token to guard against BREACH.
+      c1               <- cookieFromRequest[F](cookieName, r)
+      c2               <- OptionT.fromOption[F](r.headers.get(org.typelevel.ci.CIString(headerName)).map(_.head.value))
+      raw1             <- extractRaw(CSRFToken(c1.content))
+      raw2             <- extractRaw(CSRFToken(c2))
+      res: Response[F] <- if (isEqual(raw1, raw2)) service(r) else OptionT.none
+      newToken         <- OptionT.liftF(signToken(raw1)) //Generate a new token to guard against BREACH.
     } yield res.addCookie(ResponseCookie(name = cookieName, content = newToken)))
       .getOrElse(Response[F](Status.Unauthorized))
 

diff --git a/tsec-http4s/src/main/scala/tsec/csrf/package.scala b/tsec-http4s/src/main/scala/tsec/csrf/package.scala
@@ -13,7 +13,7 @@ package object csrf {
   object CSRFToken extends ManagedRandom {
     type Token <: String
 
-    def apply(s: String): CSRFToken   = s.asInstanceOf[CSRFToken]
+    def apply(s: String): CSRFToken                 = s.asInstanceOf[CSRFToken]
     def subst[F[_]](value: F[String]): F[CSRFToken] = value.asInstanceOf[F[CSRFToken]]
 
     def generateHexBase(tokenLength: Int = 32): String = {

diff --git a/tsec-http4s/src/test/scala/tsec/authentication/CSRFSpec.scala b/tsec-http4s/src/test/scala/tsec/authentication/CSRFSpec.scala
@@ -72,9 +72,11 @@ class CSRFSpec extends TestSpec {
 
       val (origToken, origRaw, response, newToken, newRaw) =
         (for {
-          t1     <- OptionT.liftF[IO, CSRFToken](tsecCSRF.generateToken)
-          raw1   <- tsecCSRF.extractRaw(t1)
-          resp   <- tsecCSRF.validate()(dummyService)(passThroughRequest.addCookie(RequestCookie(tsecCSRF.cookieName, t1)))
+          t1   <- OptionT.liftF[IO, CSRFToken](tsecCSRF.generateToken)
+          raw1 <- tsecCSRF.extractRaw(t1)
+          resp <- tsecCSRF.validate()(dummyService)(
+            passThroughRequest.addCookie(RequestCookie(tsecCSRF.cookieName, t1))
+          )
           cookie <- OptionT.fromOption[IO](resp.cookies.find(_.name == tsecCSRF.cookieName))
           raw2   <- tsecCSRF.extractRaw(CSRFToken(cookie.content))
         } yield (t1, raw1, resp, CSRFToken(cookie.content), raw2))
@@ -90,7 +92,9 @@ class CSRFSpec extends TestSpec {
       (for {
         token <- OptionT.liftF(tsecCSRF.generateToken)
         res <- tsecCSRF.validate()(dummyService)(
-          dummyRequest.withHeaders(Headers.apply(Header.Raw(CIString(tsecCSRF.headerName), token))).addCookie(tsecCSRF.cookieName, token)
+          dummyRequest
+            .withHeaders(Headers.apply(Header.Raw(CIString(tsecCSRF.headerName), token)))
+            .addCookie(tsecCSRF.cookieName, token)
         )
       } yield res).getOrElse(orElse).unsafeRunSync().status mustBe Status.Ok
     }
@@ -124,7 +128,9 @@ class CSRFSpec extends TestSpec {
         token1 <- OptionT.liftF(tsecCSRF.generateToken)
         token2 <- OptionT.liftF(tsecCSRF.generateToken)
         res <- tsecCSRF.validate()(dummyService)(
-          dummyRequest.withHeaders(Headers.apply(Header.Raw(CIString(tsecCSRF.headerName), token1))).addCookie(tsecCSRF.cookieName, token2)
+          dummyRequest
+            .withHeaders(Headers.apply(Header.Raw(CIString(tsecCSRF.headerName), token1)))
+            .addCookie(tsecCSRF.cookieName, token2)
         )
       } yield res).getOrElse(orElse).unsafeRunSync().status mustBe Status.Unauthorized
     }
@@ -134,7 +140,9 @@ class CSRFSpec extends TestSpec {
         token <- OptionT.liftF(tsecCSRF.generateToken)
         raw1  <- tsecCSRF.extractRaw(token)
         res <- tsecCSRF.validate()(dummyService)(
-          dummyRequest.withHeaders(Headers.apply(Header.Raw(CIString(tsecCSRF.headerName), token))).addCookie(tsecCSRF.cookieName, token)
+          dummyRequest
+            .withHeaders(Headers.apply(Header.Raw(CIString(tsecCSRF.headerName), token)))
+            .addCookie(tsecCSRF.cookieName, token)
         )
         r    <- OptionT.fromOption[IO](res.cookies.find(_.name == tsecCSRF.cookieName).map(_.content))
         raw2 <- tsecCSRF.extractRaw(CSRFToken(r))
@@ -146,7 +154,9 @@ class CSRFSpec extends TestSpec {
         token1 <- OptionT.liftF(tsecCSRF.generateToken)
         token2 <- OptionT.liftF(tsecCSRF.generateToken)
         res <- tsecCSRF.validate()(dummyService)(
-          dummyRequest.withHeaders(Headers.apply(Header.Raw(CIString(tsecCSRF.headerName), token1))).addCookie(tsecCSRF.cookieName, token2)
+          dummyRequest
+            .withHeaders(Headers.apply(Header.Raw(CIString(tsecCSRF.headerName), token1)))
+            .addCookie(tsecCSRF.cookieName, token2)
         )
       } yield res).getOrElse(Response.notFound).unsafeRunSync()
 

diff --git a/tsec-http4s/src/test/scala/tsec/authentication/EncryptedCookieAuthenticatorSpec.scala b/tsec-http4s/src/test/scala/tsec/authentication/EncryptedCookieAuthenticatorSpec.scala
@@ -8,9 +8,9 @@ import cats.syntax.either._
 import io.circe.generic.auto._
 import io.circe.parser.decode
 import org.http4s.headers.`Set-Cookie`
-import org.http4s.{Response, RequestCookie, Request}
+import org.http4s.{Request, RequestCookie, Response}
 import tsec.cipher.symmetric.jca._
-import tsec.cookies.{AEADCookieEncryptor, AEADCookie}
+import tsec.cookies.{AEADCookie, AEADCookieEncryptor}
 import tsec.keygen.symmetric.IdKeyGen
 
 import scala.concurrent.duration._
@@ -39,7 +39,7 @@ class EncryptedCookieAuthenticatorSpec extends RequestAuthenticatorSpec {
       store: BackingStore[IO, UUID, AuthEncryptedCookie[A, Int]]
   ): AuthSpecTester[AuthEncryptedCookie[A, Int]] = {
     implicit val instance: AADEncryptor[IO, A, SecretKey] = cipherAPI.genEncryptor[IO]
-    implicit val stategy: IvGen[IO, A] = cipherAPI.defaultIvStrategy[IO]
+    implicit val stategy: IvGen[IO, A]                    = cipherAPI.defaultIvStrategy[IO]
 
     val dummyStore = dummyBackingStore[IO, Int, DummyUser](_.id)
     val authenticator = EncryptedCookieAuthenticator.withBackingStore[IO, Int, DummyUser, A](
@@ -84,7 +84,7 @@ class EncryptedCookieAuthenticatorSpec extends RequestAuthenticatorSpec {
       idKeyGen: IdKeyGen[A, SecretKey]
   ): AuthSpecTester[AuthEncryptedCookie[A, Int]] = {
     implicit val instance: AADEncryptor[IO, A, SecretKey] = cipherAPI.genEncryptor[IO]
-    implicit val stategy: IvGen[IO, A] = cipherAPI.defaultIvStrategy[IO]
+    implicit val stategy: IvGen[IO, A]                    = cipherAPI.defaultIvStrategy[IO]
 
     val dummyStore    = dummyBackingStore[IO, Int, DummyUser](_.id)
     val secretKey     = cipherAPI.unsafeGenerateKey

diff --git a/tsec-http4s/src/test/scala/tsec/authentication/EncryptedCookieAuthenticatorTests.scala b/tsec-http4s/src/test/scala/tsec/authentication/EncryptedCookieAuthenticatorTests.scala
@@ -87,13 +87,12 @@ class EncryptedCookieAuthenticatorTests extends EncryptedCookieAuthenticatorSpec
       } yield List(cookie, update, renew, refresh, expire)
 
       program.unsafeRunSync().forall { aec =>
-
-        settings.cookieName === aec.name      &&
-        settings.secure     === aec.secure    &&
-        settings.httpOnly   === aec.httpOnly  &&
-        settings.domain     === aec.domain    &&
-        settings.path       === aec.path      &&
-        settings.extension  === aec.extension
+        settings.cookieName === aec.name &&
+        settings.secure === aec.secure &&
+        settings.httpOnly === aec.httpOnly &&
+        settings.domain === aec.domain &&
+        settings.path === aec.path &&
+        settings.extension === aec.extension
 
       } mustBe true
 

diff --git a/tsec-http4s/src/test/scala/tsec/authentication/SignedCookieAuthenticatorTests.scala b/tsec-http4s/src/test/scala/tsec/authentication/SignedCookieAuthenticatorTests.scala
@@ -14,8 +14,9 @@ import cats.effect.unsafe.implicits.global
 
 class SignedCookieAuthenticatorTests extends RequestAuthenticatorSpec {
 
-  private val cookieName             = "hi"
-  implicit def cookieBackingStore[A]: BackingStore[IO, UUID, AuthenticatedCookie[A, Int]] = dummyBackingStore[IO, UUID, AuthenticatedCookie[A, Int]](_.id)
+  private val cookieName = "hi"
+  implicit def cookieBackingStore[A]: BackingStore[IO, UUID, AuthenticatedCookie[A, Int]] =
+    dummyBackingStore[IO, UUID, AuthenticatedCookie[A, Int]](_.id)
 
   def genAuthenticator[A](
       implicit keyGenerator: IdKeyGen[A, MacSigningKey],