例如

use ic_http_certification::{HttpCertification, HttpResponse, DefaultCelBuilder, DefaultResponseCertification};

let cel_expr = DefaultCelBuilder::response_only_certification()
    .with_response_certification(DefaultResponseCertification::certified_response_headers(vec![
        "Cache-Control",
        "ETag",
    ]))
    .build();

let response = HttpResponse {
    status_code: 200,
    headers: vec![
        ("Cache-Control".to_string(), "no-cache".to_string()),
        ("ETag".to_string(), "123456789".to_string()),
        ("IC-CertificateExpression".to_string(), cel_expr.to_string()),
    ],
    body: vec![1, 2, 3, 4, 5, 6],
    upgrade: None,
};

let certification = HttpCertification::response_only(&cel_expr, &response, None).unwrap();

跳过认证

跳过认证不需要定义显式的CEL表达式，因为它始终是相同的。

例如

use ic_http_certification::HttpCertification;

let certification = HttpCertification::skip();

创建HTTP认证树

定义树路径

可以使用HttpCertificationPath结构体定义树路径，并分为两种类型：wildcard（通配符）和exact（精确）。这两种类型的路径可以以或不以反斜杠结尾，但请注意，以反斜杠结尾的路径与不以反斜杠结尾的路径是不同的路径，并且它们将由树以这种方式处理。

通配符路径可用于匹配请求URL的子路径。这对于404响应、回退或重写可能很有用。它们使用wildcard相关函数定义。

在这个例子中，使用此路径进入树的认证将适用于以/js开头的任何请求URL，除非在树中存在更具体的路径（例如/js/example.js）。

use ic_http_certification::HttpCertificationPath;

let path = HttpCertificationPath::wildcard("/js");

精确路径用于匹配整个请求URL。以反斜杠结尾的精确路径指向文件系统目录，而不以反斜杠结尾的路径指向单个文件。两者都是认证树中的单独路径，并将完全独立处理。

在这个例子中，具有此路径的证书将仅对精确的请求URL /js/example.js 有效。

use ic_http_certification::HttpCertificationPath;

let path = HttpCertificationPath::exact("/js/example.js");

使用HTTP证书树

HttpCertificationTree 可以很容易地通过 Default 特性进行初始化，并且可以使用 HttpCertificationTreeEntry 结构体向树中添加条目、从树中删除条目或由树生成见证。 HttpCertificationTreeEntry 需要一个 HttpCertification 和一个 HttpCertificationPath。

例如

use ic_http_certification::{HttpCertification, HttpRequest, HttpResponse, DefaultCelBuilder, DefaultResponseCertification, HttpCertificationTree, HttpCertificationTreeEntry, HttpCertificationPath};

let cel_expr = DefaultCelBuilder::full_certification()
    .with_request_headers(vec!["Accept", "Accept-Encoding", "If-None-Match"])
    .with_request_query_parameters(vec!["foo", "bar", "baz"])
    .with_response_certification(DefaultResponseCertification::certified_response_headers(vec![
        "Cache-Control",
        "ETag",
    ]))
    .build();

let request = HttpRequest {
    method: "GET".to_string(),
    url: "/index.html?foo=a&bar=b&baz=c".to_string(),
    headers: vec![
        ("Accept".to_string(), "application/json".to_string()),
        ("Accept-Encoding".to_string(), "gzip".to_string()),
        ("If-None-Match".to_string(), "987654321".to_string()),
    ],
    body: vec![],
};

let response = HttpResponse {
    status_code: 200,
    headers: vec![
        ("Cache-Control".to_string(), "no-cache".to_string()),
        ("ETag".to_string(), "123456789".to_string()),
        ("IC-CertificateExpression".to_string(), cel_expr.to_string()),
    ],
    body: vec![1, 2, 3, 4, 5, 6],
    upgrade: None,
};

let request_url = "/example.json";
let path = HttpCertificationPath::exact(request_url);
let certification = HttpCertification::full(&cel_expr, &request, &response, None).unwrap();

let mut http_certification_tree = HttpCertificationTree::default();

let entry = HttpCertificationTreeEntry::new(&path, &certification);

// insert the entry into the tree
http_certification_tree.insert(&entry);

// generate a witness for this entry in the tree
let witness = http_certification_tree.witness(&entry, request_url);

// delete the entry from the tree
http_certification_tree.delete(&entry);

直接创建CEL表达式

要定义一个CEL表达式，从 CelExpression 枚举开始。此枚举提供了一组变体，可以用于定义ICP HTTP网关支持的CEL表达式类型。目前仅支持一个变体，称为“默认”证书表达式，但随着HTTP证书协议的演变，未来可能还会添加更多。

当认证请求时

• 请求正文和方法总是被认证。

• 要证书请求头和查询参数，请使用 DefaultRequestCertification 结构体的 headers 和 query_paramters 字段。这两个字段都接受一个 str 切片作为参数。

当认证响应时

• 响应正文和状态码总是被认证。

• 要证书响应头，请使用 DefaultResponseCertification 枚举的 certified_response_headers 相关函数。或者要证书所有响应头（带有一些排除项），请使用 DefaultResponseCertification 枚举的 response_header_exclusions 相关函数。这两个相关函数都接受一个 str 切片作为参数。

注意，以下提供的示例CEL表达式是为了可读性而格式化的。由 CelExpression::to_string 和 create_cel_expr 产生的实际CEL表达式是压缩的。压缩的CEL表达式更受欢迎，因为它更紧凑，从而减少了HTTP网关验证证书时的有效负载，并加快了评估时间，但格式化的版本也可以接受。

完全认证的请求/响应对

要定义一个完全证书的请求和响应对，包括请求头、查询参数和响应头

use std::borrow::Cow;
use ic_http_certification::cel::{CelExpression, DefaultCelExpression, DefaultFullCelExpression, DefaultRequestCertification, DefaultResponseCertification};

let cel_expr = CelExpression::Default(DefaultCelExpression::Full(
  DefaultFullCelExpression {
    request: DefaultRequestCertification::new(
      vec!["Accept", "Accept-Encoding", "If-None-Match"],
      vec!["foo", "bar", "baz"],
    ),
    response: DefaultResponseCertification::certified_response_headers(vec![
      "ETag",
      "Cache-Control",
    ]),
  }));

这将产生以下CEL表达式

default_certification (
  ValidationArgs {
    request_certification: RequestCertification {
      certified_request_headers: ["Accept", "Accept-Encoding", "If-None-Match"],
      certified_query_parameters: ["foo", "bar", "baz"]
    },
    response_certification: ResponseCertification {
      certified_response_headers: ResponseHeaderList {
        headers: [
          "ETag",
          "Cache-Control"
        ]
      }
    }
  }
)

部分认证的请求

可以通过 DefaultRequestCertification 结构体的 headers 和 query_parameters 字段提供任意数量的请求头或查询参数，并且两者都可以是空数组。如果 headers 字段为空，则不会证书任何请求头。同样对于 query_parameters 字段，如果它为空，则不会证书任何查询参数。如果两者都为空，则只证书请求体和方法。

例如，只认证请求正文和方法

use std::borrow::Cow;
use ic_http_certification::cel::{CelExpression, DefaultCelExpression, DefaultFullCelExpression, DefaultRequestCertification, DefaultResponseCertification};

let cel_expr = CelExpression::Default(DefaultCelExpression::Full(
  DefaultFullCelExpression {
    request: DefaultRequestCertification::new(
      vec![],
      vec![],
    ),
    response: DefaultResponseCertification::certified_response_headers(vec![
      "ETag",
      "Cache-Control",
    ]),
  }));

这将产生以下CEL表达式

default_certification (
  ValidationArgs {
    request_certification: RequestCertification {
      certified_request_headers: [],
      certified_query_parameters: []
    },
    response_certification: ResponseCertification {
      certified_response_headers: ResponseHeaderList {
        headers: [
          "ETag",
          "Cache-Control"
        ]
      }
    }
  }
)

跳过请求认证

可以通过使用 DefaultCelExpression 结构体的 ResponseOnly 变体来完全跳过请求证书。

例如

use std::borrow::Cow;
use ic_http_certification::cel::{CelExpression, DefaultCelExpression, DefaultResponseOnlyCelExpression, DefaultResponseCertification};

let cel_expr = CelExpression::Default(DefaultCelExpression::ResponseOnly(
  DefaultResponseOnlyCelExpression {
    response: DefaultResponseCertification::certified_response_headers(vec![
      "ETag",
      "Cache-Control",
    ]),
  }));

这将产生以下CEL表达式

default_certification (
  ValidationArgs {
    no_request_certification: Empty {},
    response_certification: ResponseCertification {
      certified_response_headers: ResponseHeaderList {
        headers: [
          "ETag",
          "Cache-Control"
        ]
      }
    }
  }
)

部分认证的响应

与请求证书类似，可以通过 DefaultResponseCertification 枚举的 certified_response_headers 相关函数提供任意数量的响应头，也可以是空数组。如果数组为空，则不会证书任何响应头。

例如

use std::borrow::Cow;
use ic_http_certification::cel::{CelExpression, DefaultCertification, DefaultRequestCertification, DefaultResponseCertification};

let cel_expr = CelExpression::DefaultCertification(Some(DefaultCertification {
  request: DefaultRequestCertification::new(
    vec!["Accept", "Accept-Encoding", "If-None-Match"],
    vec!["foo", "bar", "baz"],
  ),
  response_certification: DefaultResponseCertification::certified_response_headers(vec![]),
}));

这将产生以下CEL表达式

default_certification (
  ValidationArgs {
    request_certification: RequestCertification {
      certified_request_headers: ["Accept", "Accept-Encoding", "If-None-Match"],
      certified_query_parameters: ["foo", "bar", "baz"]
    },
    response_certification: ResponseCertification {
      certified_response_headers: ResponseHeaderList {
        headers: []
      }
    }
  }
)

如果使用 response_header_exclusions 相关函数，则空数组将证书 所有 响应头。例如

use std::borrow::Cow;
use ic_http_certification::cel::{CelExpression, DefaultCelExpression, DefaultFullCelExpression, DefaultRequestCertification, DefaultResponseCertification};

let cel_expr = CelExpression::Default(DefaultCelExpression::Full(
  DefaultFullCelExpression {
    request: DefaultRequestCertification::new(
      vec!["Accept", "Accept-Encoding", "If-None-Match"],
      vec!["foo", "bar", "baz"],
    ),
    response: DefaultResponseCertification::response_header_exclusions(vec![]),
  }));

这将产生以下CEL表达式

default_certification (
  ValidationArgs {
    request_certification: RequestCertification {
      certified_request_headers: ["Accept", "Accept-Encoding", "If-None-Match"],
      certified_query_parameters: ["foo", "bar", "baz"]
    },
    response_certification: ResponseCertification {
      response_header_exclusions: ResponseHeaderList {
        headers: []
      }
    }
  }
)

要完全跳过响应证书，则必须完全跳过证书。证书请求而不证书响应是没有用的。

跳过认证

要完全跳过证书

use ic_http_certification::cel::{CelExpression, DefaultCelExpression};

let cel_expr = CelExpression::Default(DefaultCelExpression::Skip);

这将产生以下CEL表达式

default_certification (
  ValidationArgs {
    no_certification: Empty {}
  }
)