ප්‍රවේශ-පාලනය-ඉඩ දෙන්න-සම්භවය බහු ප්‍රභව වසම්?

Access-Control-Allow-Originශීර්ෂකය භාවිතා කරමින් බහු හරස් වසම් වලට ඉඩ දීමට ක්‍රමයක් තිබේද?

මම දන්නවා *, නමුත් එය විවෘතයි. මට ඇත්තටම අවශ්‍ය වන්නේ වසම් දෙකකට පමණි.

උදාහරණයක් ලෙස, මේ වගේ දෙයක්:

Access-Control-Allow-Origin: http://domain1.example, http://domain2.example

මම ඉහත කේතය උත්සාහ කර ඇති නමුත් එය ෆයර්ෆොක්ස් හි වැඩ කරන බවක් නොපෙනේ.

බහුවිධ වසම් නියම කළ හැකිද? නැතහොත් මම එකකින් පමණක් හිර වී සිටිනවාද?

එය කිරීමට නිර්දේශිත ක්‍රමය මෙන් පෙනේ, ඔබේ සේවාදායකයා සේවාදායකයා වෙතින් ප්‍රභව ශීර්ෂය කියවීම, එය ඔබ ඉඩ දීමට කැමති වසම් ලැයිස්තුව සමඟ සසඳන්න, එය ගැලපෙන්නේ නම්, Originශීර්ෂයේ වටිනාකම සේවාදායකයා වෙත නැවත ප්‍රතිරාවය කරන්න. මෙම Access-Control-Allow-Originප්රතිචාරය දී ශීර්ෂ.

සමග .htaccessඔබ මේ වගේ ඒක කරන්න පුළුවන්:

# ----------------------------------------------------------------------
# Allow loading of external fonts
# ----------------------------------------------------------------------
<FilesMatch "\.(ttf|otf|eot|woff|woff2)$">
    <IfModule mod_headers.c>
        SetEnvIf Origin "http(s)?://(www\.)?(google.com|staging.google.com|development.google.com|otherdomain.example|dev02.otherdomain.example)$" AccessControlAllowOrigin=$0
        Header add Access-Control-Allow-Origin %{AccessControlAllowOrigin}e env=AccessControlAllowOrigin
        Header merge Vary Origin
    </IfModule>
</FilesMatch>

මම PHP හි භාවිතා කරන තවත් විසඳුමක්:

$http_origin = $_SERVER['HTTP_ORIGIN'];

if ($http_origin == "http://www.domain1.com" || $http_origin == "http://www.domain2.com" || $http_origin == "http://www.domain3.com")
{  
    header("Access-Control-Allow-Origin: $http_origin");
}

මෙය මට ප්‍රයෝජනවත් විය:

SetEnvIf Origin "^http(s)?://(.+\.)?(domain\.example|domain2\.example)$" origin_is=$0 
Header always set Access-Control-Allow-Origin %{origin_is}e env=origin_is

දැමූ විට .htaccess, එය නිසැකවම ක්රියා කරනු ඇත.

මට වොෆ්-ෆොන්ට් සම්බන්ධයෙන් එකම ගැටළුවක් ඇති විය, බහු උප ඩොමේන වලට ප්‍රවේශය තිබිය යුතුය. උප ඩොමේන් වලට ඉඩ දීම සඳහා මම මගේ httpd.conf වෙත මෙවැනි දෙයක් එකතු කළෙමි:

SetEnvIf Origin "^(.*\.example\.com)$" ORIGIN_SUB_DOMAIN=$1
<FilesMatch "\.woff$">
    Header set Access-Control-Allow-Origin "%{ORIGIN_SUB_DOMAIN}e" env=ORIGIN_SUB_DOMAIN
</FilesMatch>

බහු වසම් සඳහා ඔබට රීජෙක්ස් වෙනස් කළ හැකිය SetEnvIf.

ඔරිජින් ශීර්ෂය ඔබේ වසමට Nginx සමඟ ගැලපෙන්නේ නම් එය ප්‍රතිරාවය කරන්නේ කෙසේද යන්න මෙන්න, ඔබට අකුරු බහු උප වසම් සේවය කිරීමට අවශ්‍ය නම් මෙය ප්‍රයෝජනවත් වේ:

location /fonts {
    # this will echo back the origin header
    if ($http_origin ~ "example.org$") {
        add_header "Access-Control-Allow-Origin" $http_origin;
    }
}

අජැක්ස් විසින් ඉල්ලා සිටින PHP යෙදුමක් සඳහා මා කළ දේ මෙන්න

$request_headers        = apache_request_headers();
$http_origin            = $request_headers['Origin'];
$allowed_http_origins   = array(
                            "http://myDumbDomain.example"   ,
                            "http://anotherDumbDomain.example"  ,
                            "http://localhost"  ,
                          );
if (in_array($http_origin, $allowed_http_origins)){  
    @header("Access-Control-Allow-Origin: " . $http_origin);
}

ඉල්ලුම් කිරීමේ සම්භවය මගේ සේවාදායකයා විසින් අවසර දී ඇත්නම්, ආදේශක කාඩ්පතක් ආපසු ලබා දීම වෙනුවට ශීර්ෂයේ $http_originවටිනාකම ලෙස එය Access-Control-Allow-Originආපසු *එවන්න.

ඔබ දැනුවත් විය යුතු එක් අවාසියක් තිබේ: ඔබ සීඩීඑන් වෙත ලිපිගොනු ලබාගත් විගසම (හෝ ස්ක්‍රිප්ටින් කිරීමට ඉඩ නොදෙන වෙනත් සේවාදායකයක්) හෝ ඔබේ ලිපිගොනු ප්‍රොක්සියක හැඹිලිගත කර ඇත්නම්, 'සම්භවය' මත පදනම්ව ප්‍රතිචාර වෙනස් කිරීම. ඉල්ලීම් ශීර්ෂය ක්‍රියා නොකරනු ඇත.

බහු වසම් සඳහා, ඔබගේ .htaccess:

<IfModule mod_headers.c>
    SetEnvIf Origin "http(s)?://(www\.)?(domain1.example|domain2.example)$" AccessControlAllowOrigin=$0$1
    Header add Access-Control-Allow-Origin %{AccessControlAllowOrigin}e env=AccessControlAllowOrigin
    Header set Access-Control-Allow-Credentials true
</IfModule>

Nginx භාවිතා කරන්නන් සඳහා බහු වසම් සඳහා CORS ඉඩ ලබා දේ. මාෂල්ගේ ආදර්ශයට මම කැමතියි. වසම් ලැයිස්තුවක් හා උප ඩොමේනයක් ගැලපීම සඳහා මෙම රීජෙක්ස් අකුරු සමඟ වැඩ කිරීම පහසු කරයි:

location ~* \.(?:ttf|ttc|otf|eot|woff|woff2)$ {
   if ( $http_origin ~* (https?://(.+\.)?(domain1|domain2|domain3)\.(?:me|co|com)$) ) {
      add_header "Access-Control-Allow-Origin" "$http_origin";
   }
}

මෙය ප්‍රතිරාවය කරනුයේ ලබා දී ඇති වසම් ලැයිස්තුවට ගැලපෙන "ප්‍රවේශ-පාලනය-ඉඩ දෙන්න-සම්භවය" ශීර්ෂයන් පමණි.

URL Rewrite 2.0 මොඩියුලය ස්ථාපනය කර ඇති IIS 7.5+ සඳහා කරුණාකර මෙම SO පිළිතුර බලන්න

යෙස්ටැට්ගුයි වෙතින් ලැබෙන පිළිතුර පදනම් කර ගනිමින් ජාවා වෙබ් යෙදුම සඳහා විසඳුමක් මෙන්න.

මම ජර්සි REST 1.x භාවිතා කරමි

ජර්සි REST සහ CORSResponseFilter ගැන දැනුවත් වීමට web.xml වින්‍යාස කරන්න

 <!-- Jersey REST config -->
  <servlet>    
    <servlet-name>JAX-RS Servlet</servlet-name>
    <servlet-class>com.sun.jersey.spi.container.servlet.ServletContainer</servlet-class>
    <init-param> 
        <param-name>com.sun.jersey.api.json.POJOMappingFeature</param-name>
        <param-value>true</param-value>
    </init-param>
    <init-param>
      <param-name>com.sun.jersey.spi.container.ContainerResponseFilters</param-name>
      <param-value>com.your.package.CORSResponseFilter</param-value>
    </init-param>   
    <init-param>
        <param-name>com.sun.jersey.config.property.packages</param-name>
        <param-value>com.your.package</param-value>
    </init-param>        
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>JAX-RS Servlet</servlet-name>
    <url-pattern>/ws/*</url-pattern>
  </servlet-mapping>

CORSResponseFilter සඳහා කේතය මෙන්න

import com.sun.jersey.spi.container.ContainerRequest;
import com.sun.jersey.spi.container.ContainerResponse;
import com.sun.jersey.spi.container.ContainerResponseFilter;


public class CORSResponseFilter implements ContainerResponseFilter{

@Override
public ContainerResponse filter(ContainerRequest request,
        ContainerResponse response) {

    String[] allowDomain = {"http://localhost:9000","https://my.domain.example"};
    Set<String> allowedOrigins = new HashSet<String>(Arrays.asList (allowDomain));                  

    String originHeader = request.getHeaderValue("Origin");

    if(allowedOrigins.contains(originHeader)) {
        response.getHttpHeaders().add("Access-Control-Allow-Origin", originHeader);

        response.getHttpHeaders().add("Access-Control-Allow-Headers",
                "origin, content-type, accept, authorization");
        response.getHttpHeaders().add("Access-Control-Allow-Credentials", "true");
        response.getHttpHeaders().add("Access-Control-Allow-Methods",
                "GET, POST, PUT, DELETE, OPTIONS, HEAD");
    }

    return response;
}

}

ඉහත සඳහන් කළ පරිදි, Access-Control-Allow-Originඅද්විතීය Varyවිය යුතු අතර Originඔබ සීඩීඑන් (අන්තර්ගත බෙදාහැරීමේ ජාලය) පිටුපස සිටී නම් එය සැකසිය යුතුය .

මගේ Nginx වින්‍යාසයේ අදාළ කොටස:

if ($http_origin ~* (https?://.*\.mydomain.example(:[0-9]+)?)) {
  set $cors "true";
}
if ($cors = "true") {
  add_header 'Access-Control-Allow-Origin' "$http_origin";
  add_header 'X-Frame-Options' "ALLOW FROM $http_origin";
  add_header 'Access-Control-Allow-Credentials' 'true';
  add_header 'Vary' 'Origin';
}

සමහර විට මම වැරදියි, නමුත් මට පෙනෙන Access-Control-Allow-Originපරිදි අ"origin-list" පරාමිතිය ලෙස.

විසින් නිර්වචනය යනු origin-listඇත:

origin            = "origin" ":" 1*WSP [ "null" / origin-list ]
origin-list       = serialized-origin *( 1*WSP serialized-origin )
serialized-origin = scheme "://" host [ ":" port ]
                  ; <scheme>, <host>, <port> productions from RFC3986

මෙයින්, මම තර්ක කරන්නේ විවිධ සම්භවයන් පිළිගෙන ඇති අතර අවකාශය වෙන් කළ යුතු බවයි .

HTTPS ධාවනය වන වසමක් සඳහා මෙය සැකසීමට මම වෙහෙසුණා, එබැවින් මම විසඳුම බෙදාගනු ඇතැයි සිතුවෙමි. මගේ httpd.conf ගොනුවේ පහත දැක්වෙන විධානය භාවිතා කළෙමි :

    <FilesMatch "\.(ttf|otf|eot|woff)$">
            SetEnvIf Origin "^http(s)?://(.+\.)?example\.com$" AccessControlAllowOrigin=$0
            Header set Access-Control-Allow-Origin %{AccessControlAllowOrigin}e env=AccessControlAllowOrigin
    </FilesMatch>

example.comඔබගේ ඩොමේන් නාමයට වෙනස් කරන්න. මෙම තුළ එකතු <VirtualHost x.x.x.x:xx>ඔබේ httpd.conf ගොනුවට. ඔබට VirtualHostවරාය උපසර්ගයක් තිබේ නම් (උදා :80) මෙම නියෝගය HTTPS සඳහා අදාළ නොවන බව සලකන්න, එබැවින් ඔබට / etc / apache2 / sites-available / default-ssl වෙත ගොස් එම ගොනුවේ එකම විධානය ඇතුලත් කිරීමට අවශ්‍ය වනු ඇත. පිළිබඳ <VirtualHost _default_:443>කොටස.

වින්‍යාස ගොනු යාවත්කාලීන වූ පසු, ඔබට පහත විධානයන් පර්යන්තය තුළ ක්‍රියාත්මක කිරීමට අවශ්‍ය වනු ඇත:

a2enmod headers
sudo service apache2 reload

ExpressJS යෙදුම් සඳහා ඔබට භාවිතා කළ හැකිය:

app.use((req, res, next) => {
    const corsWhitelist = [
        'https://domain1.example',
        'https://domain2.example',
        'https://domain3.example'
    ];
    if (corsWhitelist.indexOf(req.headers.origin) !== -1) {
        res.header('Access-Control-Allow-Origin', req.headers.origin);
        res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept');
    }

    next();
});

ඔබට අකුරු සම්බන්ධ ගැටලුවක් තිබේ නම්, භාවිතා කරන්න:

<FilesMatch "\.(ttf|ttc|otf|eot|woff)$">
    <IfModule mod_headers>
        Header set Access-Control-Allow-Origin "*"
    </IfModule>
</FilesMatch>

වඩාත් නම්‍යශීලී ප්‍රවේශයක් වන්නේ Apache 2.4 හි ප්‍රකාශන භාවිතා කිරීමයි. ඔබට වසම්, මාර්ග සහ අනෙකුත් සෑම ඉල්ලීම් විචල්‍යයක් සමඟම ගැලපේ. යවන ලද ප්‍රතිචාරය සැමවිටම වුවද, *එය ලැබෙන එකම ඉල්ලුම්කරුවන් කෙසේ හෝ අවශ්‍යතා සපුරාලයි. Originප්‍රකාශනයේ (හෝ වෙනත්) ඉල්ලීම් ශීර්ෂයක් භාවිතා කිරීමෙන් Apache එය ස්වයංක්‍රීයව Varyප්‍රතිචාර ශීර්ෂයට ඒකාබද්ධ කරයි , එවිට ප්‍රතිචාරය වෙනත් සම්භවයක් සඳහා නැවත භාවිතා නොවේ.

<IfModule mod_headers.c>
    <If "%{HTTP:Host} =~ /\\bcdndomain\\.example$/i && %{HTTP:Origin} =~ /\\bmaindomain\\.example$/i">
        Header set Access-Control-Allow-Origin "*"
    </If>
</IfModule>

PHP කේතය:

$httpOrigin = isset($_SERVER['HTTP_ORIGIN']) ? $_SERVER['HTTP_ORIGIN'] : null;
if (in_array($httpOrigin, [
    'http://localhost:9000', // Co-worker dev-server
    'http://127.0.0.1:9001', // My dev-server
])) header("Access-Control-Allow-Origin: ${httpOrigin}");
header('Access-Control-Allow-Credentials: true');

HTTP_ORIGIN සියලුම බ්‍රව්සර් භාවිතා නොකරයි. HTTP_ORIGIN කෙතරම් ආරක්‍ෂිතද? මට නම් එය එෆ්එෆ් හි හිස්ව එයි.
මගේ වෙබ් අඩවියට ප්‍රවේශ වීමට ඉඩ දෙන වෙබ් අඩවි අඩවි හැඳුනුම්පතක් හරහා මා සතුව ඇති අතර, එම හැඳුනුම්පත සමඟ ඇති වාර්තාව සඳහා මගේ ඩීබී පරික්ෂා කර SITE_URL තීරු අගය (www.yoursite.com) ලබා ගනිමි.

header('Access-Control-Allow-Origin: http://'.$row['SITE_URL']);

වලංගු අඩවි හැඳුනුම්පතක් යැවීම වුවද ඉල්ලීම එම අඩවි හැඳුනුම්පත හා සම්බන්ධ මගේ ඩීබී හි ලැයිස්තුගත කර ඇති වසමෙන් විය යුතුය.

නවතම හා සැලසුම් කළ අකුරු අර්ථ දැක්වීම් කිහිපයක් ඇතුළත් වන අපාචේ සඳහා පුළුල් විකල්පයක් මෙන්න:

<FilesMatch "\.(ttf|otf|eot|woff|woff2|sfnt|svg)$">
    <IfModule mod_headers.c>
        SetEnvIf Origin "^http(s)?://(.+\.)?(domainname1|domainname2|domainname3)\.(?:com|net|org)$" AccessControlAllowOrigin=$0$1$2
        Header add Access-Control-Allow-Origin %{AccessControlAllowOrigin}e env=AccessControlAllowOrigin
        Header set Access-Control-Allow-Credentials true
    </IfModule>
</FilesMatch>

ASMX සේවාවක් සඳහා බහු වසම් ප්‍රවේශයට පහසුකම් සැපයීම සඳහා, මම මෙම කාර්යය global.asax ගොනුවේ නිර්මාණය කළෙමි:

protected void Application_BeginRequest(object sender, EventArgs e)
{
    string CORSServices = "/account.asmx|/account2.asmx";
    if (CORSServices.IndexOf(HttpContext.Current.Request.Url.AbsolutePath) > -1)
    {
        string allowedDomains = "http://xxx.yyy.example|http://aaa.bbb.example";

        if(allowedDomains.IndexOf(HttpContext.Current.Request.Headers["Origin"]) > -1)
            HttpContext.Current.Response.AddHeader("Access-Control-Allow-Origin", HttpContext.Current.Request.Headers["Origin"]);

        if(HttpContext.Current.Request.HttpMethod == "OPTIONS")
            HttpContext.Current.Response.End();
    }
}

CORS ක්‍රියාපද හැසිරවීමට ද මෙය ඉඩ දෙයි OPTIONS.

උප ඩොමේන් ගැලපීම සඳහා PHP කේත උදාහරණය.

if( preg_match("/http:\/\/(.*?)\.yourdomain.example/", $_SERVER['HTTP_ORIGIN'], $matches )) {
        $theMatch = $matches[0];
        header('Access-Control-Allow-Origin: ' . $theMatch);
}

.NET යෙදුම් සඳහා තරමක් පහසු පිටපතක් / පේස්ට් සඳහා, මම මෙය ලිව්වේ global.asaxගොනුවක් තුළ සිට CORS සක්‍රීය කිරීම සඳහා ය . මෙම කේතය දැනට පිළිගත් පිළිතුරේ දී ඇති උපදෙස් අනුගමනය කරයි. මෙය භාවිතා නොකර '*' effectively ලදායී ලෙස සාක්ෂාත් කරගනී.

එයට හේතුව නම්, එය 'සත්‍ය' ලෙස සකසා ඇති 'withCredentials' ගුණාංගය සමඟ AJAX XMLHttpRequest යැවීමේ හැකියාව ඇතුළුව තවත් CORS විශේෂාංග කිහිපයක් සක්‍රීය කිරීමයි .

void Application_BeginRequest(object sender, EventArgs e)
{
    if (Request.HttpMethod == "OPTIONS")
    {
        Response.AddHeader("Access-Control-Allow-Methods", "GET, POST");
        Response.AddHeader("Access-Control-Allow-Headers", "Content-Type, Accept");
        Response.AddHeader("Access-Control-Max-Age", "1728000");
        Response.End();
    }
    else
    {
        Response.AddHeader("Access-Control-Allow-Credentials", "true");

        if (Request.Headers["Origin"] != null)
            Response.AddHeader("Access-Control-Allow-Origin" , Request.Headers["Origin"]);
        else
            Response.AddHeader("Access-Control-Allow-Origin" , "*");
    }
}

AWS Lambda / API ද්වාරය

සර්වර්ලස් ඒඩබ්ලිව්එස් ලැම්බඩා සහ ඒපීඅයි ගේට්වේ හි බහු මූලාරම්භයන් වින්‍යාසගත කරන්නේ කෙසේද යන්න පිළිබඳ තොරතුරු සඳහා - යමෙකුට දැනෙන දෙයක් සඳහා තරමක් විශාල විසඳුමක් වුවද එය සරල යැයි සිතිය හැකිය - මෙහි බලන්න:

https://stackoverflow.com/a/41708323/1624933

ඒපීඅයි ගේට්වේ හි බහු සම්භවයක් වින්‍යාස කිරීමට දැනට නොහැකි ය, මෙහි බලන්න: https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-cors-console.html ), නමුත් නිර්දේශය (තුළ) ඉහත පිළිතුර):

• බ්‍රව්සරය විසින් එවන ලද මූල ශීර්ෂය පරීක්ෂා කරන්න
• මූලාරම්භයේ සුදු ලැයිස්තුවකට එරෙහිව එය පරීක්ෂා කරන්න
• එය ගැලපෙන්නේ නම්, එන ප්‍රභවය ප්‍රවේශ-පාලක-ඉඩ දෙන්න-සම්භවය ශීර්ෂය ලෙස ආපසු එවන්න, නැතිනම් ස්ථාන දරන්නෙකු (පෙරනිමි සම්භවය) ආපසු එවන්න.

සරල විසඳුම පැහැදිලිවම සියලු (*) සක්‍රීය කරයි:

exports.handler = async (event) => {
    const response = {
        statusCode: 200,
        headers: {
            "Access-Control-Allow-Origin": "*",
            "Access-Control-Allow-Credentials" : true // Required for cookies, authorization headers with HTTPS
        },
        body: JSON.stringify([{

නමුත් API ගේට්වේ පැත්තේ මෙය කිරීම වඩා හොඳ විය හැකිය (ඉහත 2 වන සබැඳිය බලන්න).

ජැන්ගෝ හි තවත් එක් පිළිතුරක්. තනි දර්ශනයක් ලබා ගැනීම සඳහා බහු වසම් වලින් CORS ට ඉඩ දෙන්න, මෙන්න මගේ කේතය:

def my_view(request):
    if 'HTTP_ORIGIN' in request.META.keys() and request.META['HTTP_ORIGIN'] in ['http://allowed-unsecure-domain.com', 'https://allowed-secure-domain.com', ...]:
        response = my_view_response() # Create your desired response data: JsonResponse, HttpResponse...
        # Then add CORS headers for access from delivery
        response["Access-Control-Allow-Origin"] = request.META['HTTP_ORIGIN']
        response["Access-Control-Allow-Methods"] = "GET" # "GET, POST, PUT, DELETE, OPTIONS, HEAD"
        response["Access-Control-Max-Age"] = "1000"  
        response["Access-Control-Allow-Headers"] = "*"  
        return response

එස්එස්එල් සහ ආර්එෆ්සී හි ව්‍යාකරණ හරහා දැන්වීම් සැපයීම පිළිබඳ ගූගල්ගේ සහාය පිළිතුරෙන් ඔබට URL වල අවකාශය සීමා කළ හැකි බව පෙනේ. විවිධ බ්‍රව්සර් වල මෙය කෙතරම් හොඳින් සහාය වේදැයි විශ්වාස නැත.

CORS භාවිතයෙන් එය ක්‍රියාත්මක කිරීම සඳහා ඔබ මා වැනි කේත උදාහරණ බොහොමයක් උත්සාහ කළහොත්, ඔබේ හැඹිලිය සත්‍ය වශයෙන්ම ක්‍රියාත්මක වන්නේ දැයි බැලීමට පළමුව එය ඉවත් කළ යුතු බව සඳහන් කිරීම වටී, පැරණි පින්තූර තවමත් පවතින විට වැනි ගැටළු වලට සමාන වේ. සේවාදායකයේ මකාදමා ඇත (මන්ද එය තවමත් ඔබගේ හැඹිලියේ සුරකින බැවිනි).

උදාහරණයක් වශයෙන් CTRL + SHIFT + DELඔබගේ හැඹිලිය මකා දැමීමට Google Chrome හි .

පිරිසිදු .htaccessවිසඳුම් බොහොමයක් උත්සාහ කිරීමෙන් පසු මෙම කේතය භාවිතා කිරීමට මෙය මට උපකාරී වූ අතර මෙය වැඩ කරන එකම එක බව පෙනේ (අවම වශයෙන් මට):

    Header add Access-Control-Allow-Origin "http://google.com"
    Header add Access-Control-Allow-Headers "authorization, origin, user-token, x-requested-with, content-type"
    Header add Access-Control-Allow-Methods "PUT, GET, POST, DELETE, OPTIONS"

    <FilesMatch "\.(ttf|otf|eot|woff)$">
        <IfModule mod_headers.c>
            SetEnvIf Origin "http(s)?://(www\.)?(google.com|staging.google.com|development.google.com|otherdomain.com|dev02.otherdomain.net)$" AccessControlAllowOrigin=$0
            Header add Access-Control-Allow-Origin %{AccessControlAllowOrigin}e env=AccessControlAllowOrigin
        </IfModule>
    </FilesMatch>

එසේම එය බොහෝ විසඳුම් ඔබ ටයිප් කිරීමට ඇති කියන්න පැතිරෙන පුළුල් ලෙස බව කරුණාවෙන් Header set ...නමුත් එය Header add .... මා වැනි දැන් පැය කිහිපයක් එකම කරදර ඇති කෙනෙකුට මෙය උපකාරී වේ යැයි සිතමි.

පහත පිළිතුර C # සඳහා විශේෂිත වේ, නමුත් සංකල්පය විවිධ වේදිකාවලට අදාළ විය යුතුය.

වෙබ් api එකකින් හරස් ප්‍රභව ඉල්ලීම් වලට ඉඩ දීම සඳහා, ඔබ ඔබේ යෙදුමට විකල්ප ඉල්ලීම් වලට ඉඩ දිය යුතු අතර පාලක මට්ටමින් පහත දැක්වෙන විවරණ එකතු කරන්න.

[EnableCors (UrlString, Header, Method)] දැන් මූලාරම්භය සම්මත කළ හැක්කේ නූල් ලෙස පමණි. SO ඔබට ඉල්ලීමෙහි එක් URL එකකට වඩා ලබා දීමට අවශ්‍ය නම් එය කොමාවකින් වෙන් කළ අගයක් ලෙස සම්මත කරන්න.

UrlString = " https: //a.hello.com,https: //b.hello.com "

ප්‍රවේශ-පාලනය-ඉඩ දෙන්න-සම්භවය ශීර්ෂය සඳහා එක් ප්‍රභවයක් පමණක් නියම කළ හැකිය. නමුත් ඉල්ලීම අනුව ඔබේ ප්‍රතිචාරයේ මූලාරම්භය සැකසිය හැකිය. Vary ශීර්ෂකය සැකසීමටද අමතක නොකරන්න. PHP හි මම පහත සඳහන් දේ කරමි.

    /**
     * Enable CORS for the passed origins.
     * Adds the Access-Control-Allow-Origin header to the response with the origin that matched the one in the request.
     * @param array $origins
     * @return string|null returns the matched origin or null
     */
    function allowOrigins($origins)
    {
        $val = $_SERVER['HTTP_ORIGIN'] ?? null;
        if (in_array($val, $origins, true)) {
            header('Access-Control-Allow-Origin: '.$val);
            header('Vary: Origin');

            return $val;
        }

        return null;
    }

  if (allowOrigins(['http://localhost', 'https://localhost'])) {
      echo your response here, e.g. token
  }

Asp.net යෙදුම සඳහා අපට මෙය Global.asax ගොනුවේ සැකසිය හැකිය.

protected void Application_BeginRequest(object sender, EventArgs e)
    {

    // enable CORS
    HttpContext.Current.Response.AddHeader("Access-Control-Allow-Origin", "https://www.youtube.com");

    }