Cross-Origin Request Sharing - CORS (A.K.A. Cross-Domain AJAX request) is an issue that most web developers might encounter, according to Same-Origin-Policy, browsers restrict client JavaScript in a security sandbox, usually JS cannot directly communicate with a remote server from a different domain. In the past developers created many tricky ways to achieve Cross-Domain resource request, most commonly using ways are:

1. Use Flash/Silverlight or server side as a "proxy" to communicate
   with remote.


2. JSON With Padding (JSONP).


3. Embeds remote server in an iframe and communicate through fragment or window.name, refer here.

Those tricky ways have more or less some issues, for example JSONP might result in security hole if developers simply "eval" it, and #3 above, although it works, both domains should build strict contract between each other, it neither flexible nor elegant IMHO:)

W3C had introduced Cross-Origin Resource Sharing (CORS) as a standard solution to provide a safe, flexible and a recommended standard way to solve this issue.

The Mechanism

From a high level we can simply deem CORS is a contract between client AJAX call from domain A and a page hosted on domain B, a typical Cross-Origin request/response would be:

DomainA AJAX request headers

Host DomainB.com

User-Agent Mozilla/5.0 (Windows NT 6.1; WOW64; rv:2.0) Gecko/20100101 Firefox/4.0

Accept text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8,application/json

Accept-Language en-us;

Accept-Encoding gzip, deflate

Keep-Alive 115

Origin http://DomainA.com 

DomainB response headers

Cache-Control private

Content-Type application/json; charset=utf-8

Access-Control-Allow-Origin DomainA.com

Content-Length 87

Proxy-Connection Keep-Alive

Connection Keep-Alive

The blue parts I marked above were the kernal facts, "Origin" request header "indicates where the cross-origin request or preflight request originates from", the "Access-Control-Allow-Origin" response header indicates this page allows remote request from DomainA (if the value is * indicate allows remote requests from any domain).

As I mentioned above, W3 recommended browser to implement a "preflight request" before submiting the actually Cross-Origin HTTP request, in a nutshell it is an HTTP OPTIONS request:

OPTIONS DomainB.com/foo.aspx HTTP/1.1

If foo.aspx supports OPTIONS HTTP verb, it might return response like below:

HTTP/1.1 200 OK

Date: Wed, 01 Mar 2011 15:38:19 GMT

Access-Control-Allow-Origin: http://DomainA.com

Access-Control-Allow-Methods: POST, GET, OPTIONS, HEAD

Access-Control-Allow-Headers: X-Requested-With

Access-Control-Max-Age: 1728000

Connection: Keep-Alive

Content-Type: application/json

Only if the response contains "Access-Control-Allow-Origin" AND its value is "*" or contain the domain who submitted the CORS request, by satisfying this mandtory condition browser will submit the actual Cross-Domain request, and cache the result in "Preflight-Result-Cache".

I blogged about CORS three years ago: AJAX Cross-Origin HTTP request

Question is a bit too old to answer, but I am posting this for any future reference to this question.

According to this Mozilla Developer Network article,

A resource makes a cross-origin HTTP request when it requests a resource from a different domain, or port than the one which the first resource itself serves.

An HTML page served from http://domain-a.com makes an <img> src request for http://domain-b.com/image.jpg.

Many pages on the web today load resources like CSS stylesheets, images and scripts from separate domains (thus it should be cool).

Same-Origin Policy

For security reasons, browsers restrict cross-origin HTTP requests initiated from within scripts.

For example, XMLHttpRequest and Fetch follow the same-origin policy.

So, a web application using XMLHttpRequest or Fetch could only make HTTP requests to its own domain.

Cross-Origin Resource Sharing (CORS)

To improve web applications, developers asked browser vendors to allow cross-domain requests.

The Cross-Origin Resource Sharing (CORS) mechanism gives web servers cross-domain access controls, which enable secure cross-domain data transfers.

Modern browsers use CORS in an API container - such as XMLHttpRequest or Fetch - to mitigate risks of cross-origin HTTP requests.

How CORS works (Access-Control-Allow-Origin header)

Wikipedia:

The CORS standard describes new HTTP headers which provide browsers and servers a way to request remote URLs only when they have permission.

Although some validation and authorization can be performed by the server, it is generally the browser's responsibility to support these headers and honor the restrictions they impose.

Example

1. 
   

   The browser sends the OPTIONS request with an Origin HTTP header.

   
   
   

   The value of this header is the domain that served the parent page. When a page from http://www.example.com attempts to access a user's data in service.example.com, the following request header would be sent to service.example.com:

   
   
   

   Origin: http://www.example.com

   
   


2. 
   

   The server at service.example.com may respond with:

   
   
   
   
   
   • 
     

     An Access-Control-Allow-Origin (ACAO) header in its response indicating which origin sites are allowed.
     
     For example:

     
     
     

     Access-Control-Allow-Origin: http://www.example.com

     
     
   
   

   • An error page if the server does not allow the cross-origin request

   
   
   • 
     

     An Access-Control-Allow-Origin (ACAO) header with a wildcard that allows all domains:

     
     
     

     Access-Control-Allow-Origin: *

     
     
   
   
   
   

If you want just to test a cross domain application in which the browser blocks your request, then you can just open your browser in unsafe mode and test your application without changing your code and without making your code unsafe.
From MAC OS you can do this from the terminal line:

open -a Google Chrome --args --disable-web-security --user-data-dir

Using React and Axios, join proxy link to the URL and add header as shown below

https://cors-anywhere.herokuapp.com/ + Your API URL

Just by adding the Proxy link will work, but it can also throw error for No Access again. Hence better to add header as shown below.

axios.get(`https://cors-anywhere.herokuapp.com/[YOUR_API_URL]`,{headers: {'Access-Control-Allow-Origin': '*'}})

      .then(response => console.log(response:data);

  }

Whenever I start thinking about CORS, my intuition about which site hosts the headers is incorrect, just as you described in your question. For me, it helps to think about the purpose of the same origin policy.

The purpose of the same origin policy is to protect you from malicious JavaScript on siteA.com accessing private information you've chosen to share only with siteB.com. Without the same origin policy, JavaScript written by the authors of siteA.com could make your browser make requests to siteB.com, using your authentication cookies for siteB.com. In this way, siteA.com could steal the secret information you share with siteB.com.

Sometimes you need to work cross domain, which is where CORS comes in. CORS relaxes the same origin policy for domainA.com, using the Access-Control-Allow-Origin header to list other domains (domainB.com) that are trusted to run JavaScript that can interact with domainA.com.

To understand which domain should serve the CORS headers, consider this. You visit malicious.com, which contains some JavaScript that tries to make a cross domain request to mybank.com. It should be up to mybank.com, not malicious.com, to decide whether or not it sets CORS headers that relax the same origin policy allowing the JavaScript from malicious.com to interact with it. If malicous.com could set its own CORS headers allowing its own JavaScript access to mybank.com, this would completely nullify the same origin policy.

I think the reason for my bad intuition is the point of view I have when developing a site. It's my site, with all my JavaScript, therefore it isn't doing anything malicious and it should be up to me to specify which other sites my JavaScript can interact with. When in fact I should be thinking which other sites JavaScript are trying to interact with my site and should I use CORS to allow them?

1. A client downloads javascript code MyCode.js from http://siteA - the origin.

The code that does the downloading - your html script tag or xhr from javascript or whatever - came from, let's say, http://siteZ. And, when the browser requests MyCode.js, it sends an Origin: header saying "Origin: http://siteZ", because it can see that you're requesting to siteA and siteZ != siteA. (You cannot stop or interfere with this.)

2. The response header of MyCode.js contains Access-Control-Allow-Origin: http://siteB, which I thought meant that MyCode.js was allowed to make cross-origin references to the site B.

no. It means, Only siteB is allowed to do this request. So your request for MyCode.js from siteZ gets an error instead, and the browser typically gives you nothing. But if you make your server return A-C-A-O: siteZ instead, you'll get MyCode.js . Or if it sends '*', that'll work, that'll let everybody in. Or if the server always sends the string from the Origin: header... but... for security, if you're afraid of hackers, your server should only allow origins on a shortlist, that are allowed to make those requests.

Then, MyCode.js comes from siteA. When it makes requests to siteB, they are all cross-origin, the browser sends Origin: siteA, and siteB has to take the siteA, recognize it's on the short list of allowed requesters, and send back A-C-A-O: siteA. Only then will the browser let your script get the result of those requests.

i work with express 4 and node 7.4 and angular,I had the same problem me help this:

a) server side: in file app.js i give headers to all response like:

app.use(function(req, res, next) {  

      res.header('Access-Control-Allow-Origin', req.headers.origin);

      res.header("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept");

      next();

 });  

this must have before all router.

I saw a lot of added this headers:

res.header("Access-Control-Allow-Headers","*");

res.header('Access-Control-Allow-Credentials', true);

res.header('Access-Control-Allow-Methods', 'GET,PUT,POST,DELETE');

but i dont need that,

b) client side: in send ajax you need add: "withCredentials: true," like:

$http({

     method: 'POST',

     url: 'url, 

     withCredentials: true,

     data : {}

   }).then(function(response){

        // code  

   }, function (response) {

         // code 

   });

good luck.

If you are using PHP, try to add the following code at the beaning of the php file:

if you are using localhost, try this:

header("Access-Control-Allow-Origin: *");

if you are using external domains such as server, try this:

header("Access-Control-Allow-Origin: http://www.website.com");

For cross origin sharing, set header: 'Access-Control-Allow-Origin':'*';

Php: header('Access-Control-Allow-Origin':'*');

Node: app.use('Access-Control-Allow-Origin':'*');

This will allow to share content for different domain.

In Python I have been using the Flask-CORS library with great success. It makes dealing with CORS super easy and painless. I added some code from the library's documentation below.

Installing:

$ pip install -U flask-cors

Simple example that allows CORS for all domains on all routes:

from flask import Flask

from flask_cors import CORS



app = Flask(__name__)

CORS(app)



@app.route("/")

def helloWorld():

  return "Hello, cross-origin-world!"

For more specific examples see the documentation. I have used the simple example above to get around the CORS issue in an ionic application I am building that has to access a separate flask server.

Simply paste the following code in your web.config file.

Noted that, you have to paste the following code under <system.webServer> tag

    <httpProtocol>  

    <customHeaders>  

     <add name="Access-Control-Allow-Origin" value="*" />  

     <add name="Access-Control-Allow-Headers" value="Content-Type" />  

     <add name="Access-Control-Allow-Methods" value="GET, POST, PUT, DELETE, OPTIONS" />  

    </customHeaders>  

  </httpProtocol>  

The Access-Control-Allow-Origin response header indicates whether the
response can be shared with requesting code from the given origin.

Header type Response       header

Forbidden header name      no

A response that tells the browser to allow code from any origin to
access a resource will include the following:

Access-Control-Allow-Origin: *

For more info, visit here....