Heim > Artikel > Backend-Entwicklung > Wie leitet man mit Cookies und Headern zwischen Domänen in HTTP um?

Wie leitet man mit Cookies und Headern zwischen Domänen in HTTP um?

Mary-Kate OlsenOriginal: 2024-11-02 18:30:02408Durchsuche

How to Redirect with Cookies and Headers Between Domains in HTTP?

Umleitung von einer Domain zu einer anderen und Setzen von Cookies oder Headern für die andere Domain

Die Herausforderung

Umleitung von einer Domain zu einer anderen mit benutzerdefinierten Headern oder in der Antwort gesetzte Cookies ist aufgrund von Einschränkungen des HTTP-Protokolls nicht möglich. Eine Weiterleitung besteht im Wesentlichen aus einem Header (Standort), der mit der Antwort verknüpft ist, und ermöglicht nicht das Hinzufügen von Headern zum Zielort.

Das Setzen von Cookies für eine andere Domain ist ebenfalls nicht zulässig stellen ein erhebliches Sicherheitsrisiko dar. Browser speichern vom Server gesendete Cookies mit einer Antwort mithilfe des Set-Cookie-Headers und senden sie später für Anfragen an denselben Server innerhalb derselben Domäne an den Server zurück. Cookies werden nicht an eine andere Domäne gesendet.

Lösung 1: Weiterleitung mit Abfrageparameter und Cookie-Einstellung auf Zieldomäne

Ein Ansatz besteht darin, den Benutzer von der Quelldomäne zur Zieldomäne umleiten zu lassen ein Zugriffstoken, das als Abfrageparameter übergeben wird. Die Zieldomäne kann dann das Token lesen und ein eigenes Cookie setzen, das der Browser speichert und für nachfolgende Anfragen sendet.

Quelldomäne (appA.py)

<code class="python">from fastapi import FastAPI, Response
from fastapi.responses import RedirectResponse, HTMLResponse

app = FastAPI()

@app.get('/', response_class=HTMLResponse)
def home():
    return '''
    <!DOCTYPE html>
    <html>
       <body>
          <h2>Click the "submit" button to be redirected to domain B</h2>
          <form method="POST" action="/submit">
             <input type="submit" value="Submit">
          </form>
       </body>
    </html>
    '''

@app.post('/submit')
def submit():
    token = 'MTQ0NjJkZmQ5OTM2NDE1ZTZjNGZmZjI3'
    redirect_url = f'http://example.test:8001/submit?token={token}'
    response = RedirectResponse(redirect_url)
    response.set_cookie(key='access-token', value=token, httponly=True)
    return response</code>

Zieldomäne (appB.py)

<code class="python">from fastapi import FastAPI, Request, status
from fastapi.responses import RedirectResponse, HTMLResponse

app = FastAPI()

@app.get('/', response_class=HTMLResponse)
def home():
    token = request.cookies.get('access-token')
    print(token)
    return 'You have been successfully redirected to domain B!' \
           f' Your access token ends with: {token[-4:]}'

@app.post('/submit')
def submit(request: Request, token: str):
    redirect_url = request.url_for('home')
    response = RedirectResponse(redirect_url, status_code=status.HTTP_303_SEE_OTHER)
    response.set_cookie(key='access-token', value=token, httponly=True)
    return response</code>

Lösung 2: Cross-Origin-Kommunikation mit Window.postMessage()

Ein anderer Ansatz beinhaltet die Verwendung von Window. postMessage() für Cross-Origin-Kommunikation. Die Quelldomäne sendet das Token an die Zieldomäne, die es in localStorage speichert und ein Cookie setzt. Zu den Nachteilen gehören die Browserkompatibilität und die Speicherung sensibler Daten im lokalen Speicher.

Lösung 3: StackExchange Universal Login Approach

StackExchange verwendet eine robustere Lösung für die automatische Anmeldung zwischen seinen verschiedenen Websites. Dazu gehört das Senden eines Authentifizierungstokens über das src-Attribut eines Bildes, das eine Serverantwort auslöst und Cookies auf der Zielseite setzt.

Dies erfordert die Browserakzeptanz von Cookies von Drittanbietern und die CORS-Konfiguration auf dem Zielserver. Außerdem wird das Token in der Abfragezeichenfolge gesendet, was potenzielle Sicherheitsrisiken birgt.

Quelldomäne (appA.py)

<code class="python">from fastapi import FastAPI, Response
from fastapi.responses import HTMLResponse

app = FastAPI()

@app.get('/', response_class=HTMLResponse)
def home():
    return '''
    <!DOCTYPE html>
    <html>
       <body>
          <h2>Click the "submit" button to be redirected to domain B</h2>
          <input type="button" value="Submit" onclick="submit()">
          <script>
             function submit() {
                fetch('/submit', {
                     method: 'POST',
                  })
                  .then(res => {
                     authHeader = res.headers.get('Authorization');
                     if (authHeader.startsWith(&quot;Bearer &quot;))
                        token = authHeader.substring(7, authHeader.length);
                     return res.text();
                  })
                  .then(data => {
                     var url = 'http://example.test:8001/submit?token=' + encodeURIComponent(token);
                     var img = document.createElement('img');
                     img.style = 'display:none';
                     img.crossOrigin = 'use-credentials';
                     img.onerror = function(){
                        window.location.href = 'http://example.test:8001/';
                     }
                     img.src = url;
                  })
                  .catch(error => {
                     console.error(error);
                  });
             }
          </script>
       </body>
    </html>
    '''

@app.post('/submit')
def submit():
    token = 'MTQ0NjJkZmQ5OTM2NDE1ZTZjNGZmZjI3'
    headers = {'Authorization': f'Bearer {token}'}
    response = Response('success', headers=headers)
    response.set_cookie(key='access-token', value=token, httponly=True)
    return response</code>

Zieldomäne (appB .py)

<code class="python">from fastapi import FastAPI, Request, Response
from fastapi.responses import RedirectResponse
from fastapi.middleware.cors import CORSMiddleware

app = FastAPI()

origins = ['http://localhost:8000', 'http://127.0.0.1:8000',
           'https://localhost:8000', 'https://127.0.0.1:8000'] 

app.add_middleware(
    CORSMiddleware,
    allow_origins=origins,
    allow_credentials=True,
    allow_methods=[&quot;*&quot;],
    allow_headers=[&quot;*&quot;],
)

@app.get('/')
def home(request: Request):
    token = request.cookies.get('access-token')
    print(token)
    return 'You have been successfully redirected to domain B!' \
           f' Your access token ends with: {token[-4:]}'
 
@app.get('/submit')
def submit(request: Request, token: str):
    response = Response('success')
    response.set_cookie(key='access-token', value=token, samesite='none', secure=True, httponly=True) 
    return response</code>

Sicherheitsaspekte

Bei der Übertragung von Tokens oder dem Setzen von Cookies zwischen Domänen ist es wichtig, Sicherheitsaspekte zu berücksichtigen. Vermeiden Sie das Senden sensibler Daten in der Abfragezeichenfolge, da diese abgefangen oder kompromittiert werden können. Verwenden Sie HTTPS-Verbindungen für eine sichere Datenübertragung. Setzen Sie das SameSite-Flag auf „None“ mit dem Secure-Flag für standortübergreifenden Zugriffsschutz.

Das obige ist der detaillierte Inhalt vonWie leitet man mit Cookies und Headern zwischen Domänen in HTTP um?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

String for include Cookie Token auto using Attribute this location http https Access

Stellungnahme：

Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn

Vorheriger Artikel：Wie kann ich den Benutzeragenten in urllib.urlopen anpassen?Nächster Artikel：Wie kann ich den Benutzeragenten in urllib.urlopen anpassen?

In Verbindung stehende Artikel

Mehr sehen