使用媒体格式化程序时，在 Web API 中绕过 AuthorizeAttribute

>我创建了一个Web api应用程序，用于向前端应用程序公开ODATA API。 这样做的原因之一是能够为相同的数据返回不同的内容类型，例如 Excel 文件。

我使用自定义媒体格式化程序来输出我的 Excel 数据，但是，我注意到当我从客户端调用它时，没有适当的安全性。

创建没有 ACCEPT 标头的 GET 时，将检查 OAuth 持有者令牌，并接受或撤销访问权限。 授权是通过控制器上的[授权]设置的。

当我进行相同的 GET 时，将 ACCEPT 标头设置为请求 Excel 文件，无论令牌如何，都会调用控制器，从而绕过控制器上的安全性。

我

显然做错了什么，但是，我无法弄清楚它可能是什么。 它是相同的控制器，但由于某种原因，当 ACCEPT 设置为支持的媒体类型时，它始终允许访问。

我的设置的精简版本如下。

欧文创业：

[assembly: OwinStartup(typeof(Rest.Startup))]
namespace Rest
{
    public class Startup
    {
        public void Configuration(IAppBuilder app)
        {
            ConfigureOAuth(app);
            HttpConfiguration config = new HttpConfiguration();
            WebApiConfig.Register(config);
            app.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
            app.UseWebApi(config);
        }
        private void ConfigureOAuth(IAppBuilder app)
        {
            OAuthAuthorizationServerOptions oauthServerOptions = new OAuthAuthorizationServerOptions
            {
                AllowInsecureHttp = true,
                TokenEndpointPath = new PathString("/token"),
                AccessTokenExpireTimeSpan = TimeSpan.FromDays(1),
                Provider = new SimpleAuthorisationServerProvider()
            };
            // Token generation
            app.UseOAuthAuthorizationServer(oauthServerOptions);
            app.UseOAuthBearerAuthentication(new OAuthBearerAuthenticationOptions());
        }
    }
}

对 WebApiConfig.Register（） 的调用

namespace Rest
{
    public static class WebApiConfig
    {
        public static void Register(HttpConfiguration config)
        {
            var json = config.Formatters.JsonFormatter;
            json.SerializerSettings.PreserveReferencesHandling = Newtonsoft.Json.PreserveReferencesHandling.Objects;
            config.Formatters.Remove(config.Formatters.XmlFormatter);
            config.Formatters.Add(new ExcelSimpleFormatter());
            // Web API routes
            config.MapHttpAttributeRoutes();
            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );
            // Configure CORS globally
            var cors = new EnableCorsAttribute(
                origins:"*",
                headers:"*",
                methods:"*");
            config.EnableCors(cors);
        }
    }
}

我的媒体格式化程序（删除代码以节省空间）：

namespace Rest.Formatters
{
    public class ExcelSimpleFormatter : BufferedMediaTypeFormatter
    {
        public ExcelSimpleFormatter()
        {
            SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"));
            SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/excel"));
        }
        public override bool CanWriteType(Type type)
        {
            return true;
        }
        public override bool CanReadType(Type type)
        {
            return false;
        }
        public override void WriteToStream(Type type, object value, Stream writeStream, HttpContent content)
        {
            // This gets called regardless of authorization
        }
    }
}

示例/简化控制器：

namespace Rest.Controllers
{
    [Authorize]
    public class TestController : ApiController
    {
        private dbSDSContext db = new dbSDSContext();
        // GET: api/Test
        public IQueryable<test> GetTests()
        {
            return db.test;
        }
        // GET: api/Test/5
        [ResponseType(typeof(test))]
        public async Task<IHttpActionResult> GetTest(int id)
        {
            test test = await db.test.FindAsync(id);
            if (test == null)
            {
                return NotFound();
            }
            return Ok(test);
        }
        // PUT: api/Test/5
        [ResponseType(typeof(void))]
        public async Task<IHttpActionResult> PutTest(int id, test test)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }
            if (id != test.testID)
            {
                return BadRequest();
            }
            db.Entry(test).State = EntityState.Modified;
            try
            {
                await db.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!TestExists(id))
                {
                    return NotFound();
                }
                else
                {
                    throw;
                }
            }
            return StatusCode(HttpStatusCode.NoContent);
        }
        // POST: api/Test
        [ResponseType(typeof(test))]
        public async Task<IHttpActionResult> PostTest(test test)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }
            db.test.Add(test);
            await db.SaveChangesAsync();
            return CreatedAtRoute("DefaultApi", new { id = test.testID}, test);
        }
        // DELETE: api/Test/5
        [ResponseType(typeof(test))]
        public async Task<IHttpActionResult> DeleteTest(int id)
        {
            test test = await db.test.FindAsync(id);
            if (test == null)
            {
                return NotFound();
            }
            db.test.Remove(test);
            await db.SaveChangesAsync();
            return Ok(test);
        }
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                db.Dispose();
            }
            base.Dispose(disposing);
        }
        private bool TestExists(int id)
        {
            return db.test.Count(e => e.testID == id) > 0;
        }
    }
}

using System.Web.Http;

using System.Web.Mvc;