Problémy s autorizáciou OAuth 1.0 s X API v2 v Scale cez STTP

Riešenie autorizácie OAuth 1.0 so Scala a STTP pre Twitter API

Tento skript ukazuje, ako podpísať požiadavky OAuth 1.0 v Scala pomocou HMAC-SHA1. Zabezpečuje modularitu a spracovanie chýb, výsledkom čoho je opätovne použiteľný a udržiavateľný kód.

import java.net.URLEncoder
import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec
import org.joda.time.DateTime
import sttp.client4._
import sttp.model.Header
import scala.util.Random
object Auth {
  def urlEncode(text: String): String =
    URLEncoder.encode(text, java.nio.charset.Charset.defaultCharset())
  def generateNonce: String = Random.alphanumeric.take(15).mkString
  def sha1sign(text: String, key: String): String = {
    val mac = Mac.getInstance("HmacSHA1")
    val signingKey = new SecretKeySpec(key.getBytes, "HmacSHA1")
    mac.init(signingKey)
    val signature = mac.doFinal(text.getBytes("UTF-8"))
    java.util.Base64.getEncoder.encodeToString(signature)
  }
  def createHeader(authData: Map[String, String]): Header = {
    val signatureBaseString = "POST&" + urlEncode("https://api.twitter.com/2/tweets") + "&" +
      urlEncode(authData.toSeq.sorted.map(x => s"${x._1}=${x._2}").mkString("&"))
    val signature = sha1sign(signatureBaseString, "consumerSecret&tokenSecret")
    val authHeader = "OAuth " + authData.map { case (k, v) => s"""$k="${urlEncode(v)}"""" }.mkString(", ") +
      s""", oauth_signature="${urlEncode(signature)}""""
    Header("Authorization", authHeader)
  }
}
object TwitterApi {
  val postEndpoint = "https://api.twitter.com/2/tweets"
  def createPost(text: String): Response = {
    val authData = Map(
      "oauth_consumer_key" -> "yourConsumerKey",
      "oauth_nonce" -> Auth.generateNonce,
      "oauth_signature_method" -> "HMAC-SHA1",
      "oauth_timestamp" -> DateTime.now().getMillis.toString,
      "oauth_token" -> "yourToken",
      "oauth_version" -> "1.0"
    )
    val header = Auth.createHeader(authData)
    basicRequest
      .header(header)
      .contentType("application/json")
      .body(s"""{"text":"$text"}""")
      .post(uri"$postEndpoint")
      .send(backend)
  }
}

Alternatívny prístup: OAuth 1.0 s vlastnou nonce a časovou pečiatkou

Táto metóda zefektívňuje proces podpisovania tým, že sa zameriava na generovanie zákazkových nonces a časových pečiatok s minimálnymi závislosťami.

import java.net.URLEncoder
import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec
import sttp.client4._
import sttp.model.Header
object OAuthHelper {
  def generateTimestamp: String = (System.currentTimeMillis / 1000).toString
  def generateNonce: String = java.util.UUID.randomUUID().toString.replace("-", "")
  def urlEncode(value: String): String = URLEncoder.encode(value, "UTF-8")
  def hmacSha1(baseString: String, key: String): String = {
    val mac = Mac.getInstance("HmacSHA1")
    val signingKey = new SecretKeySpec(key.getBytes("UTF-8"), "HmacSHA1")
    mac.init(signingKey)
    val rawHmac = mac.doFinal(baseString.getBytes("UTF-8"))
    java.util.Base64.getEncoder.encodeToString(rawHmac)
  }
}
object TwitterClient {
  def createAuthorizationHeader(params: Map[String, String], signature: String): Header = {
    val headerParams = params.map { case (k, v) => s"""$k="${OAuthHelper.urlEncode(v)}"""" }.mkString(", ")
    Header("Authorization", s"""OAuth $headerParams, oauth_signature="$signature"""")
  }
  def postTweet(text: String): Response = {
    val params = Map(
      "oauth_consumer_key" -> "consumerKey",
      "oauth_nonce" -> OAuthHelper.generateNonce,
      "oauth_signature_method" -> "HMAC-SHA1",
      "oauth_timestamp" -> OAuthHelper.generateTimestamp,
      "oauth_token" -> "accessToken",
      "oauth_version" -> "1.0"
    )
    val baseString = "POST&" + OAuthHelper.urlEncode("https://api.twitter.com/2/tweets") + "&" +
      OAuthHelper.urlEncode(params.toSeq.sorted.map { case (k, v) => s"$k=$v" }.mkString("&"))
    val signature = OAuthHelper.hmacSha1(baseString, "consumerSecret&tokenSecret")
    val authHeader = createAuthorizationHeader(params, signature)
    basicRequest
      .header(authHeader)
      .contentType("application/json")
      .body(s"""{"text":"$text"}""")
      .post(uri"https://api.twitter.com/2/tweets")
      .send(backend)
  }
}

Často kladené otázky o OAuth 1.0 a autentifikácii Twitter API

1. Ako sa líši protokol OAuth 1.0 od protokolu OAuth 2.0?
2. OAuth 1.0 používa podpisy a šifrovanie HMAC-SHA1 na zabezpečenie, zatiaľ čo OAuth 2.0 používa autorizáciu založenú na tokenoch, čo zjednodušuje proces, ale vyžaduje zabezpečené pripojenia HTTPS.
3. Aký je účel nonce v OAuth 1.0?
4. Aby sa zabránilo opakovaným útokom, každá požiadavka generuje jedinečný reťazec známy ako nonce. Zabezpečuje, že každá požiadavka sa vykoná iba raz. Scala vám umožňuje zostaviť nonce pomocou Random.alphanumeric.take().
5. Prečo je v žiadostiach OAuth potrebné kódovanie adresy URL?
6. Kódovanie adresy URL je kľúčové, pretože určité znaky, ako sú ampersandy (&) alebo medzery, musia byť zakódované, aby sa predišlo nesprávnej interpretácii. Použite URLEncoder.encode() bezpečne zakódovať tieto znaky.
7. Ako vygenerujem podpis OAuth?
8. Ak chcete vytvoriť podpis OAuth, najskôr vytvorte základný reťazec z údajov požiadavky a potom ho podpíšte technikou HMAC-SHA1. Použite Mac.getInstance("HmacSHA1") na spustenie procesu hashovania.
9. Čo môže spôsobiť chybu 401 Unauthorized v protokole OAuth?
10. Chyba 401 môže byť spôsobená rôznymi chybami vrátane neplatného podpisu, nezhodných spotrebiteľských kľúčov alebo nevhodného kódovania parametrov. Vždy sa uistite, že sa podpis zhoduje s údajmi požiadavky a že kódovanie je presné.

Záverečné myšlienky na riešenie problémov s protokolom OAuth na Twitteri

Na správnu autorizáciu žiadosti OAuth 1.0 pre rozhranie API služby Twitter musia vývojári starostlivo spravovať podpisy a hlavičky. Mnoho problémov je spôsobených problémami s kódovaním alebo použitím nesprávneho formátu základného reťazca. Chybám, ako napríklad „401 neautorizované“, sa dá predísť vhodným riešením týchto problémov.

Okrem toho opätovná kontrola vytvorenia nonce, presnosti časovej pečiatky a formátovania hlavičky výrazne zvyšuje úspešnosť autorizácie. Optimalizácia metódy sha1sign, zabezpečenie presného výpočtu podpisu a dodržiavanie požiadaviek OAuth sú kritickými fázami vývoja funkčnej a automatizovanej aplikácie na publikovanie X.