Problemy z autoryzacją OAuth 1.0 w X API v2 w Scali poprzez STTP

Rozwiązywanie autoryzacji OAuth 1.0 za pomocą Scala i STTP dla API Twittera

Ten skrypt pokazuje, jak podpisywać żądania OAuth 1.0 w Scali przy użyciu HMAC-SHA1. Zapewnia modułowość i obsługę błędów, co skutkuje możliwością wielokrotnego użycia i łatwym w utrzymaniu kodem.

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)
  }
}

Podejście alternatywne: protokół OAuth 1.0 z niestandardową obsługą identyfikatora jednorazowego i znacznika czasu

Ta metoda usprawnia proces podpisywania, koncentrując się na generowaniu niestandardowych wartości jednorazowych i znaczników czasu przy minimalnych zależnościach.

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)
  }
}

Często zadawane pytania dotyczące uwierzytelniania OAuth 1.0 i Twitter API

1. Czym różni się OAuth 1.0 od OAuth 2.0?
2. OAuth 1.0 wykorzystuje podpisy i szyfrowanie HMAC-SHA1 ze względów bezpieczeństwa, podczas gdy OAuth 2.0 wykorzystuje autoryzację opartą na tokenach, co upraszcza proces, ale wymaga bezpiecznych połączeń HTTPS.
3. Jaki jest cel nonce w OAuth 1.0?
4. Aby zapobiec atakom poprzez powtórzenie, każde żądanie generuje unikalny ciąg znaków zwany wartością jednorazową. Zapewnia, że ​​każde żądanie zostanie wykonane tylko raz. Scala pozwala na skonstruowanie wartości jednorazowej przy użyciu Random.alphanumeric.take().
5. Dlaczego kodowanie adresu URL jest konieczne w żądaniach OAuth?
6. Kodowanie adresów URL ma kluczowe znaczenie, ponieważ niektóre znaki, takie jak ampersand (&) lub spacje, muszą zostać zakodowane, aby uniknąć błędnej interpretacji. Używać URLEncoder.encode() aby bezpiecznie zakodować te znaki.
7. Jak wygenerować podpis OAuth?
8. Aby ustanowić podpis OAuth, najpierw utwórz ciąg podstawowy z danych żądania, a następnie podpisz go techniką HMAC-SHA1. Używać Mac.getInstance("HmacSHA1") aby rozpocząć proces mieszania.
9. Co może powodować nieautoryzowany błąd 401 w OAuth?
10. Błąd 401 może być spowodowany różnymi błędami, w tym nieprawidłowym podpisem, niedopasowanymi kluczami konsumenckimi lub niewłaściwym kodowaniem parametrów. Zawsze upewnij się, że podpis jest zgodny z danymi żądania i że kodowanie jest prawidłowe.

Ostatnie przemyślenia na temat rozwiązywania problemów związanych z OAuth na Twitterze

Aby prawidłowo autoryzować żądanie OAuth 1.0 dla interfejsu API Twittera, programiści muszą uważnie zarządzać podpisami i nagłówkami. Wiele problemów jest spowodowanych problemami z kodowaniem lub użyciem nieprawidłowego formatu ciągu podstawowego. Błędom takim jak „401 Nieautoryzowany” można zapobiec, odpowiednio rozwiązując te problemy.

Co więcej, ponowne sprawdzenie utworzenia jednorazowego użytku, dokładności znacznika czasu i formatowania nagłówka znacznie zwiększa skuteczność autoryzacji. Optymalizacja metody sha1sign, zapewnienie dokładnego obliczenia podpisu i przestrzeganie wymagań OAuth to krytyczne etapy w kierunku opracowania funkcjonalnej i zautomatyzowanej aplikacji do publikowania X.