OAuth 1.0 auktoriseringsproblem med X API v2 i Scala via STTP

Löser OAuth 1.0-auktorisering med Scala och STTP för Twitter API

Det här skriptet visar hur man signerar OAuth 1.0-förfrågningar i Scala med HMAC-SHA1. Det säkerställer modularitet och felhantering, vilket resulterar i återanvändbar kod som kan underhållas.

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 tillvägagångssätt: OAuth 1.0 med anpassad nonce- och tidsstämpelhantering

Denna metod effektiviserar signaturprocessen genom att fokusera på att generera skräddarsydda nonces och tidsstämplar med minimala beroenden.

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

Vanliga frågor om OAuth 1.0 och Twitter API-autentisering

1. Hur skiljer sig OAuth 1.0 från OAuth 2.0?
2. OAuth 1.0 använder signaturer och HMAC-SHA1-kryptering för säkerhet, medan OAuth 2.0 använder tokenbaserad auktorisering, vilket förenklar processen men kräver säkra HTTPS-anslutningar.
3. Vad är syftet med en nonce i OAuth 1.0?
4. För att förhindra reprisattacker genererar varje begäran en unik sträng som kallas nonce. Det säkerställer att varje begäran endast exekveras en gång. Scala låter dig konstruera en nonce med hjälp av Random.alphanumeric.take().
5. Varför krävs URL-kodning i OAuth-förfrågningar?
6. URL-kodning är avgörande eftersom vissa tecken, som et-tecken (&) eller mellanslag, måste kodas för att undvika feltolkning. Använda URLEncoder.encode() för att säkert koda dessa tecken.
7. Hur genererar jag en OAuth-signatur?
8. För att upprätta en OAuth-signatur, skapa först en bassträng från begärandata och sedan signera den med HMAC-SHA1-tekniken. Använda Mac.getInstance("HmacSHA1") för att starta hashprocessen.
9. Vad kan orsaka ett 401 obehörigt fel i OAuth?
10. Ett 401-fel kan orsakas av en mängd olika fel, inklusive en ogiltig signatur, felaktiga konsumentnycklar eller olämplig parameterkodning. Se alltid till att signaturen matchar förfrågningsdata och att kodningen är korrekt.

Sista tankar om att lösa Twitter OAuth-problem

För att korrekt auktorisera en OAuth 1.0-begäran för Twitters API måste utvecklare noggrant hantera signaturer och rubriker. Många problem orsakas av kodningsproblem eller användning av felaktigt bassträngformat. Fel som "401 obehörig" kan förhindras genom att åtgärda dessa problem på lämpligt sätt.

Dessutom ökar auktoriseringsframgången avsevärt om du inte har skapat en gång, tidsstämpelns noggrannhet och formatering av rubriker. Att optimera sha1sign-metoden, säkerställa korrekt signaturberäkning och att följa OAuth-kraven är kritiska steg för att utveckla en funktionell och automatiserad X-publiceringsapplikation.