OAuth 1.0-autorisasjonsproblemer med X API v2 i Scala via STTP

Løser OAuth 1.0-autorisasjon med Scala og STTP for Twitter API

Dette skriptet viser hvordan du signerer OAuth 1.0-forespørsler i Scala ved hjelp av HMAC-SHA1. Det sikrer modularitet og feilhåndtering, noe som resulterer i gjenbrukbar, vedlikeholdbar kode.

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

Alternativ tilnærming: OAuth 1.0 med tilpasset ikke- og tidsstempelhåndtering

Denne metoden effektiviserer signaturprosessen ved å fokusere på å generere skreddersydde nonces og tidsstempler med minimale avhengigheter.

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

Ofte stilte spørsmål om OAuth 1.0 og Twitter API-autentisering

1. Hvordan skiller OAuth 1.0 seg fra OAuth 2.0?
2. OAuth 1.0 bruker signaturer og HMAC-SHA1-kryptering for sikkerhet, mens OAuth 2.0 bruker token-basert autorisasjon, som forenkler prosessen, men nødvendiggjør sikre HTTPS-tilkoblinger.
3. Hva er hensikten med en nonce i OAuth 1.0?
4. For å forhindre replay-angrep genererer hver forespørsel en unik streng kjent som en nonce. Det sikrer at hver forespørsel kun utføres én gang. Scala lar deg konstruere en nonce ved hjelp av Random.alphanumeric.take().
5. Hvorfor er URL-koding nødvendig i OAuth-forespørsler?
6. URL-koding er avgjørende fordi visse tegn, som og-tegn (&) eller mellomrom, må kodes for å unngå feiltolkning. Bruk URLEncoder.encode() for å sikkert kode disse tegnene.
7. Hvordan genererer jeg en OAuth-signatur?
8. For å etablere en OAuth-signatur må du først opprette en basisstreng fra forespørselsdataene og deretter signere den med HMAC-SHA1-teknikken. Bruk Mac.getInstance("HmacSHA1") for å starte hashing-prosessen.
9. Hva kan forårsake en 401 uautorisert feil i OAuth?
10. En 401-feil kan være forårsaket av en rekke feil, inkludert en ugyldig signatur, feilaktige forbrukernøkler eller upassende parameterkoding. Sørg alltid for at signaturen samsvarer med forespørselsdataene og at kodingen er nøyaktig.

Siste tanker om å løse Twitter OAuth-problemer

For å autorisere en OAuth 1.0-forespørsel for Twitters API på riktig måte, må utviklere administrere signaturer og overskrifter nøye. Mange problemer er forårsaket av kodingsproblemer eller bruk av feil grunnstrengformat. Feil som "401 Uautorisert" kan forhindres ved å løse disse problemene på riktig måte.

I tillegg øker godkjenningssuksessen betraktelig ved å kontrollere ikke-oppretting, tidsstempelnøyaktighet og topptekstformatering. Optimalisering av sha1sign-metoden, sikring av nøyaktig signaturberegning og overholdelse av OAuth-krav er kritiske stadier for å utvikle en funksjonell og automatisert X-publiseringsapplikasjon.