Primeiro commit do projeto Angular
This commit is contained in:
+9
@@ -0,0 +1,9 @@
|
||||
# @sigstore/verify · [](https://www.npmjs.com/package/@sigstore/verify) [](https://github.com/sigstore/sigstore-js/actions/workflows/ci.yml) [](https://github.com/sigstore/sigstore-js/actions/workflows/smoke-test.yml)
|
||||
|
||||
A library for verifying [Sigstore][1] signatures.
|
||||
|
||||
## Prerequisites
|
||||
|
||||
- Node.js version ^20.17.0 || >=22.9.0
|
||||
|
||||
[1]: https://www.sigstore.dev
|
||||
+12
@@ -0,0 +1,12 @@
|
||||
import { crypto } from '@sigstore/core';
|
||||
import type { Envelope } from '@sigstore/bundle';
|
||||
import type { SignatureContent } from '../shared.types';
|
||||
export declare class DSSESignatureContent implements SignatureContent {
|
||||
private readonly env;
|
||||
constructor(env: Envelope);
|
||||
compareDigest(digest: Buffer): boolean;
|
||||
compareSignature(signature: Buffer): boolean;
|
||||
verifySignature(key: crypto.KeyObject): boolean;
|
||||
get signature(): Buffer;
|
||||
private get preAuthEncoding();
|
||||
}
|
||||
+44
@@ -0,0 +1,44 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.DSSESignatureContent = void 0;
|
||||
/*
|
||||
Copyright 2023 The Sigstore Authors.
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
See the License for the specific language governing permissions and
|
||||
limitations under the License.
|
||||
*/
|
||||
const core_1 = require("@sigstore/core");
|
||||
class DSSESignatureContent {
|
||||
env;
|
||||
constructor(env) {
|
||||
this.env = env;
|
||||
}
|
||||
compareDigest(digest) {
|
||||
return core_1.crypto.bufferEqual(digest, core_1.crypto.digest('sha256', this.env.payload));
|
||||
}
|
||||
compareSignature(signature) {
|
||||
return core_1.crypto.bufferEqual(signature, this.signature);
|
||||
}
|
||||
verifySignature(key) {
|
||||
return core_1.crypto.verify(this.preAuthEncoding, key, this.signature);
|
||||
}
|
||||
get signature() {
|
||||
return this.env.signatures.length > 0
|
||||
? this.env.signatures[0].sig
|
||||
: Buffer.from('');
|
||||
}
|
||||
// DSSE Pre-Authentication Encoding
|
||||
get preAuthEncoding() {
|
||||
return core_1.dsse.preAuthEncoding(this.env.payloadType, this.env.payload);
|
||||
}
|
||||
}
|
||||
exports.DSSESignatureContent = DSSESignatureContent;
|
||||
+4
@@ -0,0 +1,4 @@
|
||||
import { Bundle } from '@sigstore/bundle';
|
||||
import type { SignatureContent, SignedEntity } from '../shared.types';
|
||||
export declare function toSignedEntity(bundle: Bundle, artifact?: Buffer): SignedEntity;
|
||||
export declare function signatureContent(bundle: Bundle, artifact?: Buffer): SignatureContent;
|
||||
+59
@@ -0,0 +1,59 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.toSignedEntity = toSignedEntity;
|
||||
exports.signatureContent = signatureContent;
|
||||
const core_1 = require("@sigstore/core");
|
||||
const dsse_1 = require("./dsse");
|
||||
const message_1 = require("./message");
|
||||
function toSignedEntity(bundle, artifact) {
|
||||
const { tlogEntries, timestampVerificationData } = bundle.verificationMaterial;
|
||||
const timestamps = [];
|
||||
for (const entry of tlogEntries) {
|
||||
if (entry.integratedTime && entry.integratedTime !== '0') {
|
||||
timestamps.push({
|
||||
$case: 'transparency-log',
|
||||
tlogEntry: entry,
|
||||
});
|
||||
}
|
||||
}
|
||||
for (const ts of timestampVerificationData?.rfc3161Timestamps ?? []) {
|
||||
timestamps.push({
|
||||
$case: 'timestamp-authority',
|
||||
timestamp: core_1.RFC3161Timestamp.parse(Buffer.from(ts.signedTimestamp)),
|
||||
});
|
||||
}
|
||||
return {
|
||||
signature: signatureContent(bundle, artifact),
|
||||
key: key(bundle),
|
||||
tlogEntries,
|
||||
timestamps,
|
||||
};
|
||||
}
|
||||
function signatureContent(bundle, artifact) {
|
||||
switch (bundle.content.$case) {
|
||||
case 'dsseEnvelope':
|
||||
return new dsse_1.DSSESignatureContent(bundle.content.dsseEnvelope);
|
||||
case 'messageSignature':
|
||||
return new message_1.MessageSignatureContent(bundle.content.messageSignature, artifact);
|
||||
}
|
||||
}
|
||||
function key(bundle) {
|
||||
switch (bundle.verificationMaterial.content.$case) {
|
||||
case 'publicKey':
|
||||
return {
|
||||
$case: 'public-key',
|
||||
hint: bundle.verificationMaterial.content.publicKey.hint,
|
||||
};
|
||||
case 'x509CertificateChain':
|
||||
return {
|
||||
$case: 'certificate',
|
||||
certificate: core_1.X509Certificate.parse(Buffer.from(bundle.verificationMaterial.content.x509CertificateChain
|
||||
.certificates[0].rawBytes)),
|
||||
};
|
||||
case 'certificate':
|
||||
return {
|
||||
$case: 'certificate',
|
||||
certificate: core_1.X509Certificate.parse(Buffer.from(bundle.verificationMaterial.content.certificate.rawBytes)),
|
||||
};
|
||||
}
|
||||
}
|
||||
+13
@@ -0,0 +1,13 @@
|
||||
import { crypto } from '@sigstore/core';
|
||||
import type { MessageSignature } from '@sigstore/bundle';
|
||||
import type { SignatureContent } from '../shared.types';
|
||||
export declare class MessageSignatureContent implements SignatureContent {
|
||||
readonly signature: Buffer;
|
||||
private readonly messageDigest;
|
||||
private readonly artifact;
|
||||
private readonly hashAlgorithm;
|
||||
constructor(messageSignature: MessageSignature, artifact: Buffer);
|
||||
compareSignature(signature: Buffer): boolean;
|
||||
compareDigest(digest: Buffer): boolean;
|
||||
verifySignature(key: crypto.KeyObject): boolean;
|
||||
}
|
||||
+54
@@ -0,0 +1,54 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.MessageSignatureContent = void 0;
|
||||
/*
|
||||
Copyright 2023 The Sigstore Authors.
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
See the License for the specific language governing permissions and
|
||||
limitations under the License.
|
||||
*/
|
||||
const core_1 = require("@sigstore/core");
|
||||
const protobuf_specs_1 = require("@sigstore/protobuf-specs");
|
||||
// Map from the Sigstore protobuf HashAlgorithm enum to
|
||||
// the string values used by the Node.js crypto module.
|
||||
const HASH_ALGORITHM_MAP = {
|
||||
[protobuf_specs_1.HashAlgorithm.HASH_ALGORITHM_UNSPECIFIED]: 'sha256',
|
||||
[protobuf_specs_1.HashAlgorithm.SHA2_256]: 'sha256',
|
||||
[protobuf_specs_1.HashAlgorithm.SHA2_384]: 'sha384',
|
||||
[protobuf_specs_1.HashAlgorithm.SHA2_512]: 'sha512',
|
||||
[protobuf_specs_1.HashAlgorithm.SHA3_256]: 'sha3-256',
|
||||
[protobuf_specs_1.HashAlgorithm.SHA3_384]: 'sha3-384',
|
||||
};
|
||||
class MessageSignatureContent {
|
||||
signature;
|
||||
messageDigest;
|
||||
artifact;
|
||||
hashAlgorithm;
|
||||
constructor(messageSignature, artifact) {
|
||||
this.signature = messageSignature.signature;
|
||||
this.messageDigest = messageSignature.messageDigest.digest;
|
||||
this.artifact = artifact;
|
||||
this.hashAlgorithm =
|
||||
HASH_ALGORITHM_MAP[messageSignature.messageDigest.algorithm] ??
|
||||
/* istanbul ignore next */ 'sha256';
|
||||
}
|
||||
compareSignature(signature) {
|
||||
return core_1.crypto.bufferEqual(signature, this.signature);
|
||||
}
|
||||
compareDigest(digest) {
|
||||
return core_1.crypto.bufferEqual(digest, this.messageDigest);
|
||||
}
|
||||
verifySignature(key) {
|
||||
return core_1.crypto.verify(this.artifact, key, this.signature, this.hashAlgorithm);
|
||||
}
|
||||
}
|
||||
exports.MessageSignatureContent = MessageSignatureContent;
|
||||
+16
@@ -0,0 +1,16 @@
|
||||
declare class BaseError<T extends string> extends Error {
|
||||
code: T;
|
||||
cause: any;
|
||||
constructor({ code, message, cause, }: {
|
||||
code: T;
|
||||
message: string;
|
||||
cause?: any;
|
||||
});
|
||||
}
|
||||
type VerificationErrorCode = 'NOT_IMPLEMENTED_ERROR' | 'TLOG_ERROR' | 'TLOG_INCLUSION_PROOF_ERROR' | 'TLOG_INCLUSION_PROMISE_ERROR' | 'TLOG_MISSING_INCLUSION_ERROR' | 'TLOG_BODY_ERROR' | 'CERTIFICATE_ERROR' | 'PUBLIC_KEY_ERROR' | 'SIGNATURE_ERROR' | 'TIMESTAMP_ERROR';
|
||||
export declare class VerificationError extends BaseError<VerificationErrorCode> {
|
||||
}
|
||||
type PolicyErrorCode = 'UNTRUSTED_SIGNER_ERROR';
|
||||
export declare class PolicyError extends BaseError<PolicyErrorCode> {
|
||||
}
|
||||
export {};
|
||||
+34
@@ -0,0 +1,34 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.PolicyError = exports.VerificationError = void 0;
|
||||
/*
|
||||
Copyright 2023 The Sigstore Authors.
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
See the License for the specific language governing permissions and
|
||||
limitations under the License.
|
||||
*/
|
||||
class BaseError extends Error {
|
||||
code;
|
||||
cause; /* eslint-disable-line @typescript-eslint/no-explicit-any */
|
||||
constructor({ code, message, cause, }) {
|
||||
super(message);
|
||||
this.code = code;
|
||||
this.cause = cause;
|
||||
this.name = this.constructor.name;
|
||||
}
|
||||
}
|
||||
class VerificationError extends BaseError {
|
||||
}
|
||||
exports.VerificationError = VerificationError;
|
||||
class PolicyError extends BaseError {
|
||||
}
|
||||
exports.PolicyError = PolicyError;
|
||||
+5
@@ -0,0 +1,5 @@
|
||||
export { toSignedEntity } from './bundle';
|
||||
export { PolicyError, VerificationError } from './error';
|
||||
export { KeyFinderFunc, TrustMaterial, toTrustMaterial } from './trust';
|
||||
export { Verifier, VerifierOptions } from './verifier';
|
||||
export type { SignedEntity, Signer, VerificationPolicy } from './shared.types';
|
||||
+28
@@ -0,0 +1,28 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.Verifier = exports.toTrustMaterial = exports.VerificationError = exports.PolicyError = exports.toSignedEntity = void 0;
|
||||
/* istanbul ignore file */
|
||||
/*
|
||||
Copyright 2023 The Sigstore Authors.
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
See the License for the specific language governing permissions and
|
||||
limitations under the License.
|
||||
*/
|
||||
var bundle_1 = require("./bundle");
|
||||
Object.defineProperty(exports, "toSignedEntity", { enumerable: true, get: function () { return bundle_1.toSignedEntity; } });
|
||||
var error_1 = require("./error");
|
||||
Object.defineProperty(exports, "PolicyError", { enumerable: true, get: function () { return error_1.PolicyError; } });
|
||||
Object.defineProperty(exports, "VerificationError", { enumerable: true, get: function () { return error_1.VerificationError; } });
|
||||
var trust_1 = require("./trust");
|
||||
Object.defineProperty(exports, "toTrustMaterial", { enumerable: true, get: function () { return trust_1.toTrustMaterial; } });
|
||||
var verifier_1 = require("./verifier");
|
||||
Object.defineProperty(exports, "Verifier", { enumerable: true, get: function () { return verifier_1.Verifier; } });
|
||||
+21
@@ -0,0 +1,21 @@
|
||||
import { X509Certificate } from '@sigstore/core';
|
||||
import { CertAuthority } from '../trust';
|
||||
export declare function verifyCertificateChain(timestamp: Date, leaf: X509Certificate, certificateAuthorities: CertAuthority[]): X509Certificate[];
|
||||
interface CertificateChainVerifierOptions {
|
||||
trustedCerts: X509Certificate[];
|
||||
untrustedCert: X509Certificate;
|
||||
timestamp: Date;
|
||||
}
|
||||
export declare class CertificateChainVerifier {
|
||||
private untrustedCert;
|
||||
private trustedCerts;
|
||||
private localCerts;
|
||||
private timestamp;
|
||||
constructor(opts: CertificateChainVerifierOptions);
|
||||
verify(): X509Certificate[];
|
||||
private sort;
|
||||
private buildPaths;
|
||||
private findIssuer;
|
||||
private checkPath;
|
||||
}
|
||||
export {};
|
||||
+216
@@ -0,0 +1,216 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.CertificateChainVerifier = void 0;
|
||||
exports.verifyCertificateChain = verifyCertificateChain;
|
||||
const error_1 = require("../error");
|
||||
const trust_1 = require("../trust");
|
||||
function verifyCertificateChain(timestamp, leaf, certificateAuthorities) {
|
||||
// Filter list of trusted CAs to those which are valid for the given
|
||||
// timestamp
|
||||
const cas = (0, trust_1.filterCertAuthorities)(certificateAuthorities, timestamp);
|
||||
/* eslint-disable-next-line @typescript-eslint/no-explicit-any */
|
||||
let error;
|
||||
for (const ca of cas) {
|
||||
try {
|
||||
const verifier = new CertificateChainVerifier({
|
||||
trustedCerts: ca.certChain,
|
||||
untrustedCert: leaf,
|
||||
timestamp,
|
||||
});
|
||||
return verifier.verify();
|
||||
}
|
||||
catch (err) {
|
||||
error = err;
|
||||
}
|
||||
}
|
||||
// If we failed to verify the certificate chain for all of the trusted
|
||||
// CAs, throw the last error we encountered.
|
||||
throw new error_1.VerificationError({
|
||||
code: 'CERTIFICATE_ERROR',
|
||||
message: 'Failed to verify certificate chain',
|
||||
cause: error,
|
||||
});
|
||||
}
|
||||
class CertificateChainVerifier {
|
||||
untrustedCert;
|
||||
trustedCerts;
|
||||
localCerts;
|
||||
timestamp;
|
||||
constructor(opts) {
|
||||
this.untrustedCert = opts.untrustedCert;
|
||||
this.trustedCerts = opts.trustedCerts;
|
||||
this.localCerts = dedupeCertificates([
|
||||
...opts.trustedCerts,
|
||||
opts.untrustedCert,
|
||||
]);
|
||||
this.timestamp = opts.timestamp;
|
||||
}
|
||||
verify() {
|
||||
// Construct certificate path from leaf to root
|
||||
const certificatePath = this.sort();
|
||||
// Perform validation checks on each certificate in the path
|
||||
this.checkPath(certificatePath);
|
||||
const validForDate = certificatePath.every((cert) => cert.validForDate(this.timestamp));
|
||||
if (!validForDate) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'CERTIFICATE_ERROR',
|
||||
message: 'certificate is not valid or expired at the specified date',
|
||||
});
|
||||
}
|
||||
// Return verified certificate path
|
||||
return certificatePath;
|
||||
}
|
||||
sort() {
|
||||
const leafCert = this.untrustedCert;
|
||||
// Construct all possible paths from the leaf
|
||||
let paths = this.buildPaths(leafCert);
|
||||
// Filter for paths which contain a trusted certificate
|
||||
paths = paths.filter((path) => path.some((cert) => this.trustedCerts.includes(cert)));
|
||||
if (paths.length === 0) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'CERTIFICATE_ERROR',
|
||||
message: 'no trusted certificate path found',
|
||||
});
|
||||
}
|
||||
// Find the shortest of possible paths
|
||||
/* istanbul ignore next */
|
||||
const path = paths.reduce((prev, curr) => prev.length < curr.length ? prev : curr);
|
||||
// Construct chain from shortest path
|
||||
// Removes the last certificate in the path, which will be a second copy
|
||||
// of the root certificate given that the root is self-signed.
|
||||
return [leafCert, ...path].slice(0, -1);
|
||||
}
|
||||
// Recursively build all possible paths from the leaf to the root
|
||||
buildPaths(certificate) {
|
||||
const paths = [];
|
||||
const issuers = this.findIssuer(certificate);
|
||||
if (issuers.length === 0) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'CERTIFICATE_ERROR',
|
||||
message: 'no valid certificate path found',
|
||||
});
|
||||
}
|
||||
for (let i = 0; i < issuers.length; i++) {
|
||||
const issuer = issuers[i];
|
||||
// Base case - issuer is self
|
||||
if (issuer.equals(certificate)) {
|
||||
paths.push([certificate]);
|
||||
continue;
|
||||
}
|
||||
// Recursively build path for the issuer
|
||||
const subPaths = this.buildPaths(issuer);
|
||||
// Construct paths by appending the issuer to each subpath
|
||||
for (let j = 0; j < subPaths.length; j++) {
|
||||
paths.push([issuer, ...subPaths[j]]);
|
||||
}
|
||||
}
|
||||
return paths;
|
||||
}
|
||||
// Return all possible issuers for the given certificate
|
||||
findIssuer(certificate) {
|
||||
let issuers = [];
|
||||
let keyIdentifier;
|
||||
// Exit early if the certificate is self-signed
|
||||
if (certificate.subject.equals(certificate.issuer)) {
|
||||
if (certificate.verify()) {
|
||||
return [certificate];
|
||||
}
|
||||
}
|
||||
// If the certificate has an authority key identifier, use that
|
||||
// to find the issuer
|
||||
if (certificate.extAuthorityKeyID) {
|
||||
keyIdentifier = certificate.extAuthorityKeyID.keyIdentifier;
|
||||
// TODO: Add support for authorityCertIssuer/authorityCertSerialNumber
|
||||
// though Fulcio doesn't appear to use these
|
||||
}
|
||||
// Find possible issuers by comparing the authorityKeyID/subjectKeyID
|
||||
// or issuer/subject. Potential issuers are added to the result array.
|
||||
this.localCerts.forEach((possibleIssuer) => {
|
||||
if (keyIdentifier) {
|
||||
/* istanbul ignore else */
|
||||
if (possibleIssuer.extSubjectKeyID) {
|
||||
if (possibleIssuer.extSubjectKeyID.keyIdentifier.equals(keyIdentifier)) {
|
||||
issuers.push(possibleIssuer);
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
// Fallback to comparing certificate issuer and subject if
|
||||
// subjectKey/authorityKey extensions are not present
|
||||
if (possibleIssuer.subject.equals(certificate.issuer)) {
|
||||
issuers.push(possibleIssuer);
|
||||
}
|
||||
});
|
||||
// Remove any issuers which fail to verify the certificate
|
||||
issuers = issuers.filter((issuer) => {
|
||||
try {
|
||||
return certificate.verify(issuer);
|
||||
}
|
||||
catch (ex) {
|
||||
/* istanbul ignore next - should never error */
|
||||
return false;
|
||||
}
|
||||
});
|
||||
return issuers;
|
||||
}
|
||||
checkPath(path) {
|
||||
/* istanbul ignore if */
|
||||
if (path.length < 1) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'CERTIFICATE_ERROR',
|
||||
message: 'certificate chain must contain at least one certificate',
|
||||
});
|
||||
}
|
||||
// Ensure that all certificates beyond the leaf are CAs
|
||||
const validCAs = path.slice(1).every((cert) => cert.isCA);
|
||||
if (!validCAs) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'CERTIFICATE_ERROR',
|
||||
message: 'intermediate certificate is not a CA',
|
||||
});
|
||||
}
|
||||
// Certificate's issuer must match the subject of the next certificate
|
||||
// in the chain
|
||||
for (let i = path.length - 2; i >= 0; i--) {
|
||||
/* istanbul ignore if */
|
||||
if (!path[i].issuer.equals(path[i + 1].subject)) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'CERTIFICATE_ERROR',
|
||||
message: 'incorrect certificate name chaining',
|
||||
});
|
||||
}
|
||||
}
|
||||
// Check pathlength constraints
|
||||
for (let i = 0; i < path.length; i++) {
|
||||
const cert = path[i];
|
||||
// If the certificate is a CA, check the path length
|
||||
if (cert.extBasicConstraints?.isCA) {
|
||||
const pathLength = cert.extBasicConstraints.pathLenConstraint;
|
||||
// The path length, if set, indicates how many intermediate
|
||||
// certificates (NOT including the leaf) are allowed to follow. The
|
||||
// pathLength constraint of any intermediate CA certificate MUST be
|
||||
// greater than or equal to it's own depth in the chain (with an
|
||||
// adjustment for the leaf certificate)
|
||||
if (pathLength !== undefined && pathLength < i - 1) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'CERTIFICATE_ERROR',
|
||||
message: 'path length constraint exceeded',
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
exports.CertificateChainVerifier = CertificateChainVerifier;
|
||||
// Remove duplicate certificates from the array
|
||||
function dedupeCertificates(certs) {
|
||||
for (let i = 0; i < certs.length; i++) {
|
||||
for (let j = i + 1; j < certs.length; j++) {
|
||||
if (certs[i].equals(certs[j])) {
|
||||
certs.splice(j, 1);
|
||||
j--;
|
||||
}
|
||||
}
|
||||
}
|
||||
return certs;
|
||||
}
|
||||
+10
@@ -0,0 +1,10 @@
|
||||
import { X509Certificate } from '@sigstore/core';
|
||||
import { VerifiedSCTProvider } from './sct';
|
||||
import type { Signer } from '../shared.types';
|
||||
import type { TrustMaterial } from '../trust';
|
||||
export type CertificateVerificationResult = {
|
||||
signer: Signer;
|
||||
scts: VerifiedSCTProvider[];
|
||||
};
|
||||
export declare function verifyPublicKey(hint: string, timestamps: Date[], trustMaterial: TrustMaterial): Signer;
|
||||
export declare function verifyCertificate(leaf: X509Certificate, timestamps: Date[], trustMaterial: TrustMaterial): CertificateVerificationResult;
|
||||
+67
@@ -0,0 +1,67 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.verifyPublicKey = verifyPublicKey;
|
||||
exports.verifyCertificate = verifyCertificate;
|
||||
/*
|
||||
Copyright 2023 The Sigstore Authors.
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
See the License for the specific language governing permissions and
|
||||
limitations under the License.
|
||||
*/
|
||||
const core_1 = require("@sigstore/core");
|
||||
const error_1 = require("../error");
|
||||
const certificate_1 = require("./certificate");
|
||||
const sct_1 = require("./sct");
|
||||
const OID_FULCIO_ISSUER_V1 = '1.3.6.1.4.1.57264.1.1';
|
||||
const OID_FULCIO_ISSUER_V2 = '1.3.6.1.4.1.57264.1.8';
|
||||
function verifyPublicKey(hint, timestamps, trustMaterial) {
|
||||
const key = trustMaterial.publicKey(hint);
|
||||
timestamps.forEach((timestamp) => {
|
||||
if (!key.validFor(timestamp)) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'PUBLIC_KEY_ERROR',
|
||||
message: `Public key is not valid for timestamp: ${timestamp.toISOString()}`,
|
||||
});
|
||||
}
|
||||
});
|
||||
return { key: key.publicKey };
|
||||
}
|
||||
function verifyCertificate(leaf, timestamps, trustMaterial) {
|
||||
// Check that leaf certificate chains to a trusted CA
|
||||
let path = [];
|
||||
timestamps.forEach((timestamp) => {
|
||||
path = (0, certificate_1.verifyCertificateChain)(timestamp, leaf, trustMaterial.certificateAuthorities);
|
||||
});
|
||||
return {
|
||||
scts: (0, sct_1.verifySCTs)(path[0], path[1], trustMaterial.ctlogs),
|
||||
signer: getSigner(path[0]),
|
||||
};
|
||||
}
|
||||
function getSigner(cert) {
|
||||
let issuer;
|
||||
const issuerExtension = cert.extension(OID_FULCIO_ISSUER_V2);
|
||||
/* istanbul ignore next */
|
||||
if (issuerExtension) {
|
||||
issuer = issuerExtension.valueObj.subs?.[0]?.value.toString('ascii');
|
||||
}
|
||||
else {
|
||||
issuer = cert.extension(OID_FULCIO_ISSUER_V1)?.value.toString('ascii');
|
||||
}
|
||||
const identity = {
|
||||
extensions: { issuer },
|
||||
subjectAlternativeName: cert.subjectAltName,
|
||||
};
|
||||
return {
|
||||
key: core_1.crypto.createPublicKey(cert.publicKey),
|
||||
identity,
|
||||
};
|
||||
}
|
||||
+4
@@ -0,0 +1,4 @@
|
||||
import { X509Certificate } from '@sigstore/core';
|
||||
import type { TLogAuthority } from '../trust';
|
||||
export type VerifiedSCTProvider = Buffer;
|
||||
export declare function verifySCTs(cert: X509Certificate, issuer: X509Certificate, ctlogs: TLogAuthority[]): VerifiedSCTProvider[];
|
||||
+78
@@ -0,0 +1,78 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.verifySCTs = verifySCTs;
|
||||
/*
|
||||
Copyright 2023 The Sigstore Authors.
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
See the License for the specific language governing permissions and
|
||||
limitations under the License.
|
||||
*/
|
||||
const core_1 = require("@sigstore/core");
|
||||
const error_1 = require("../error");
|
||||
const trust_1 = require("../trust");
|
||||
function verifySCTs(cert, issuer, ctlogs) {
|
||||
let extSCT;
|
||||
// Verifying the SCT requires that we remove the SCT extension and
|
||||
// re-encode the TBS structure to DER -- this value is part of the data
|
||||
// over which the signature is calculated. Since this is a destructive action
|
||||
// we create a copy of the certificate so we can remove the SCT extension
|
||||
// without affecting the original certificate.
|
||||
const clone = cert.clone();
|
||||
// Intentionally not using the findExtension method here because we want to
|
||||
// remove the the SCT extension from the certificate before calculating the
|
||||
// PreCert structure
|
||||
for (let i = 0; i < clone.extensions.length; i++) {
|
||||
const ext = clone.extensions[i];
|
||||
if (ext.subs[0].toOID() === core_1.EXTENSION_OID_SCT) {
|
||||
extSCT = new core_1.X509SCTExtension(ext);
|
||||
// Remove the extension from the certificate
|
||||
clone.extensions.splice(i, 1);
|
||||
break;
|
||||
}
|
||||
}
|
||||
// No SCT extension found to verify
|
||||
if (!extSCT) {
|
||||
return [];
|
||||
}
|
||||
// Found an SCT extension but it has no SCTs
|
||||
/* istanbul ignore if -- too difficult to fabricate test case for this */
|
||||
if (extSCT.signedCertificateTimestamps.length === 0) {
|
||||
return [];
|
||||
}
|
||||
// Construct the PreCert structure
|
||||
// https://www.rfc-editor.org/rfc/rfc6962#section-3.2
|
||||
const preCert = new core_1.ByteStream();
|
||||
// Calculate hash of the issuer's public key
|
||||
const issuerId = core_1.crypto.digest('sha256', issuer.publicKey);
|
||||
preCert.appendView(issuerId);
|
||||
// Re-encodes the certificate to DER after removing the SCT extension
|
||||
const tbs = clone.tbsCertificate.toDER();
|
||||
preCert.appendUint24(tbs.length);
|
||||
preCert.appendView(tbs);
|
||||
// Calculate and return the verification results for each SCT
|
||||
return extSCT.signedCertificateTimestamps.map((sct) => {
|
||||
// Find the ctlog instance that corresponds to the SCT's logID
|
||||
const validCTLogs = (0, trust_1.filterTLogAuthorities)(ctlogs, {
|
||||
logID: sct.logID,
|
||||
targetDate: sct.datetime,
|
||||
});
|
||||
// See if the SCT is valid for any of the CT logs
|
||||
const verified = validCTLogs.some((log) => sct.verify(preCert.buffer, log.publicKey));
|
||||
if (!verified) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'CERTIFICATE_ERROR',
|
||||
message: 'SCT verification failed',
|
||||
});
|
||||
}
|
||||
return sct.logID;
|
||||
});
|
||||
}
|
||||
+3
@@ -0,0 +1,3 @@
|
||||
import { CertificateExtensions } from './shared.types';
|
||||
export declare function verifySubjectAlternativeName(policyIdentity: string, signerIdentity: string | undefined): void;
|
||||
export declare function verifyExtensions(policyExtensions: CertificateExtensions, signerExtensions?: CertificateExtensions): void;
|
||||
+24
@@ -0,0 +1,24 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.verifySubjectAlternativeName = verifySubjectAlternativeName;
|
||||
exports.verifyExtensions = verifyExtensions;
|
||||
const error_1 = require("./error");
|
||||
function verifySubjectAlternativeName(policyIdentity, signerIdentity) {
|
||||
if (signerIdentity === undefined || !signerIdentity.match(policyIdentity)) {
|
||||
throw new error_1.PolicyError({
|
||||
code: 'UNTRUSTED_SIGNER_ERROR',
|
||||
message: `certificate identity error - expected ${policyIdentity}, got ${signerIdentity}`,
|
||||
});
|
||||
}
|
||||
}
|
||||
function verifyExtensions(policyExtensions, signerExtensions = {}) {
|
||||
let key;
|
||||
for (key in policyExtensions) {
|
||||
if (signerExtensions[key] !== policyExtensions[key]) {
|
||||
throw new error_1.PolicyError({
|
||||
code: 'UNTRUSTED_SIGNER_ERROR',
|
||||
message: `invalid certificate extension - expected ${key}=${policyExtensions[key]}, got ${key}=${signerExtensions[key]}`,
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
+48
@@ -0,0 +1,48 @@
|
||||
import type { TransparencyLogEntry } from '@sigstore/bundle';
|
||||
import type { RFC3161Timestamp, X509Certificate, crypto } from '@sigstore/core';
|
||||
export type CertificateExtensionName = 'issuer';
|
||||
export type CertificateExtensions = {
|
||||
[key in CertificateExtensionName]?: string;
|
||||
};
|
||||
export type CertificateIdentity = {
|
||||
subjectAlternativeName?: string;
|
||||
extensions?: CertificateExtensions;
|
||||
};
|
||||
export type VerificationPolicy = CertificateIdentity;
|
||||
export type Signer = {
|
||||
key: crypto.KeyObject;
|
||||
identity?: CertificateIdentity;
|
||||
};
|
||||
export type Timestamp = {
|
||||
$case: 'timestamp-authority';
|
||||
timestamp: RFC3161Timestamp;
|
||||
} | {
|
||||
$case: 'transparency-log';
|
||||
tlogEntry: TransparencyLogEntry;
|
||||
};
|
||||
export type VerificationKey = {
|
||||
$case: 'public-key';
|
||||
hint: string;
|
||||
} | {
|
||||
$case: 'certificate';
|
||||
certificate: X509Certificate;
|
||||
};
|
||||
export type SignatureContent = {
|
||||
signature: Buffer;
|
||||
compareSignature(signature: Buffer): boolean;
|
||||
compareDigest(digest: Buffer): boolean;
|
||||
verifySignature(key: crypto.KeyObject): boolean;
|
||||
};
|
||||
export type TimestampProvider = {
|
||||
timestamps: Timestamp[];
|
||||
};
|
||||
export type SignatureProvider = {
|
||||
signature: SignatureContent;
|
||||
};
|
||||
export type KeyProvider = {
|
||||
key: VerificationKey;
|
||||
};
|
||||
export type TLogEntryProvider = {
|
||||
tlogEntries: TransparencyLogEntry[];
|
||||
};
|
||||
export type SignedEntity = SignatureProvider & KeyProvider & TimestampProvider & TLogEntryProvider;
|
||||
+2
@@ -0,0 +1,2 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
+11
@@ -0,0 +1,11 @@
|
||||
import { RFC3161Timestamp } from '@sigstore/core';
|
||||
import type { TransparencyLogEntry } from '@sigstore/bundle';
|
||||
import type { CertAuthority } from '../trust';
|
||||
export type TimestampType = 'transparency-log' | 'timestamp-authority';
|
||||
export type TimestampVerificationResult = {
|
||||
type: TimestampType;
|
||||
logID: Buffer;
|
||||
timestamp: Date;
|
||||
};
|
||||
export declare function getTSATimestamp(timestamp: RFC3161Timestamp, data: Buffer, timestampAuthorities: CertAuthority[]): TimestampVerificationResult;
|
||||
export declare function getTLogTimestamp(entry: TransparencyLogEntry): TimestampVerificationResult;
|
||||
+20
@@ -0,0 +1,20 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.getTSATimestamp = getTSATimestamp;
|
||||
exports.getTLogTimestamp = getTLogTimestamp;
|
||||
const tsa_1 = require("./tsa");
|
||||
function getTSATimestamp(timestamp, data, timestampAuthorities) {
|
||||
(0, tsa_1.verifyRFC3161Timestamp)(timestamp, data, timestampAuthorities);
|
||||
return {
|
||||
type: 'timestamp-authority',
|
||||
logID: timestamp.signerSerialNumber,
|
||||
timestamp: timestamp.signingTime,
|
||||
};
|
||||
}
|
||||
function getTLogTimestamp(entry) {
|
||||
return {
|
||||
type: 'transparency-log',
|
||||
logID: entry.logId.keyId,
|
||||
timestamp: new Date(Number(entry.integratedTime) * 1000),
|
||||
};
|
||||
}
|
||||
+3
@@ -0,0 +1,3 @@
|
||||
import { RFC3161Timestamp } from '@sigstore/core';
|
||||
import { CertAuthority } from '../trust';
|
||||
export declare function verifyRFC3161Timestamp(timestamp: RFC3161Timestamp, data: Buffer, timestampAuthorities: CertAuthority[]): void;
|
||||
+63
@@ -0,0 +1,63 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.verifyRFC3161Timestamp = verifyRFC3161Timestamp;
|
||||
const core_1 = require("@sigstore/core");
|
||||
const error_1 = require("../error");
|
||||
const certificate_1 = require("../key/certificate");
|
||||
const trust_1 = require("../trust");
|
||||
function verifyRFC3161Timestamp(timestamp, data, timestampAuthorities) {
|
||||
const signingTime = timestamp.signingTime;
|
||||
// Filter for CAs which were valid at the time of signing
|
||||
timestampAuthorities = (0, trust_1.filterCertAuthorities)(timestampAuthorities, signingTime);
|
||||
// Filter for CAs which match serial and issuer embedded in the timestamp
|
||||
timestampAuthorities = filterCAsBySerialAndIssuer(timestampAuthorities, {
|
||||
serialNumber: timestamp.signerSerialNumber,
|
||||
issuer: timestamp.signerIssuer,
|
||||
});
|
||||
// Check that we can verify the timestamp with AT LEAST ONE of the remaining
|
||||
// CAs
|
||||
const verified = timestampAuthorities.some((ca) => {
|
||||
try {
|
||||
verifyTimestampForCA(timestamp, data, ca);
|
||||
return true;
|
||||
}
|
||||
catch (e) {
|
||||
return false;
|
||||
}
|
||||
});
|
||||
if (!verified) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'TIMESTAMP_ERROR',
|
||||
message: 'timestamp could not be verified',
|
||||
});
|
||||
}
|
||||
}
|
||||
function verifyTimestampForCA(timestamp, data, ca) {
|
||||
const [leaf, ...cas] = ca.certChain;
|
||||
const signingKey = core_1.crypto.createPublicKey(leaf.publicKey);
|
||||
const signingTime = timestamp.signingTime;
|
||||
// Verify the certificate chain for the provided CA
|
||||
try {
|
||||
new certificate_1.CertificateChainVerifier({
|
||||
untrustedCert: leaf,
|
||||
trustedCerts: cas,
|
||||
timestamp: signingTime,
|
||||
}).verify();
|
||||
}
|
||||
catch (e) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'TIMESTAMP_ERROR',
|
||||
message: 'invalid certificate chain',
|
||||
});
|
||||
}
|
||||
// Check that the signing certificate's key can be used to verify the
|
||||
// timestamp signature.
|
||||
timestamp.verify(data, signingKey);
|
||||
}
|
||||
// Filters the list of CAs to those which have a leaf signing certificate which
|
||||
// matches the given serial number and issuer.
|
||||
function filterCAsBySerialAndIssuer(timestampAuthorities, criteria) {
|
||||
return timestampAuthorities.filter((ca) => ca.certChain.length > 0 &&
|
||||
core_1.crypto.bufferEqual(ca.certChain[0].serialNumber, criteria.serialNumber) &&
|
||||
core_1.crypto.bufferEqual(ca.certChain[0].issuer, criteria.issuer));
|
||||
}
|
||||
+11
@@ -0,0 +1,11 @@
|
||||
import { TLogAuthority } from '../trust';
|
||||
import type { TLogEntryWithInclusionProof } from '@sigstore/bundle';
|
||||
export declare function verifyCheckpoint(entry: TLogEntryWithInclusionProof, tlogs: TLogAuthority[]): LogCheckpoint;
|
||||
export declare class LogCheckpoint {
|
||||
readonly origin: string;
|
||||
readonly logSize: bigint;
|
||||
readonly logHash: Buffer;
|
||||
readonly rest: string[];
|
||||
constructor(origin: string, logSize: bigint, logHash: Buffer, rest: string[]);
|
||||
static fromString(note: string): LogCheckpoint;
|
||||
}
|
||||
+154
@@ -0,0 +1,154 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.LogCheckpoint = void 0;
|
||||
exports.verifyCheckpoint = verifyCheckpoint;
|
||||
/*
|
||||
Copyright 2025 The Sigstore Authors.
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
See the License for the specific language governing permissions and
|
||||
limitations under the License.
|
||||
*/
|
||||
const core_1 = require("@sigstore/core");
|
||||
const error_1 = require("../error");
|
||||
// Separator between the note and the signatures in a checkpoint
|
||||
const CHECKPOINT_SEPARATOR = '\n\n';
|
||||
// Checkpoint signatures are of the following form:
|
||||
// "– <identity> <key_hint+signature_bytes>\n"
|
||||
// where:
|
||||
// - the prefix is an emdash (U+2014).
|
||||
// - <identity> gives a human-readable representation of the signing ID.
|
||||
// - <key_hint+signature_bytes> is the first 4 bytes of the SHA256 hash of the
|
||||
// associated public key followed by the signature bytes.
|
||||
const SIGNATURE_REGEX = /\u2014 (\S+) (\S+)\n/g;
|
||||
// Verifies the checkpoint value in the given tlog entry. There are two steps
|
||||
// to the verification:
|
||||
// 1. Verify that all signatures in the checkpoint can be verified against a
|
||||
// trusted public key
|
||||
// 2. Verify that the root hash in the checkpoint matches the root hash in the
|
||||
// inclusion proof
|
||||
// See: https://github.com/transparency-dev/formats/blob/main/log/README.md
|
||||
function verifyCheckpoint(entry, tlogs) {
|
||||
const inclusionProof = entry.inclusionProof;
|
||||
const signedNote = SignedNote.fromString(inclusionProof.checkpoint.envelope);
|
||||
const checkpoint = LogCheckpoint.fromString(signedNote.note);
|
||||
// Verify that the signatures in the checkpoint are all valid
|
||||
if (!verifySignedNote(signedNote, tlogs)) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'TLOG_INCLUSION_PROOF_ERROR',
|
||||
message: 'invalid checkpoint signature',
|
||||
});
|
||||
}
|
||||
return checkpoint;
|
||||
}
|
||||
// Verifies the signatures in the SignedNote. For each signature, the
|
||||
// corresponding transparency log is looked up by the key hint and the
|
||||
// signature is verified against the public key in the transparency log.
|
||||
// Throws an error if any of the signatures are invalid.
|
||||
function verifySignedNote(signedNote, tlogs) {
|
||||
const data = Buffer.from(signedNote.note, 'utf-8');
|
||||
return signedNote.signatures.some((signature) => {
|
||||
// Find the transparency log instance with the matching key hint
|
||||
const tlog = tlogs.find((tlog) => core_1.crypto.bufferEqual(tlog.logID.subarray(0, 4), signature.keyHint) &&
|
||||
tlog.baseURL.match(signature.name) // Match the name to the base URL of the tlog
|
||||
);
|
||||
if (!tlog) {
|
||||
return false;
|
||||
}
|
||||
return core_1.crypto.verify(data, tlog.publicKey, signature.signature);
|
||||
});
|
||||
}
|
||||
// SignedNote represents a signed note from a transparency log checkpoint. Consists
|
||||
// of a body (or note) and one more signatures calculated over the body. See
|
||||
// https://github.com/transparency-dev/formats/blob/main/log/README.md#signed-envelope
|
||||
class SignedNote {
|
||||
note;
|
||||
signatures;
|
||||
constructor(note, signatures) {
|
||||
this.note = note;
|
||||
this.signatures = signatures;
|
||||
}
|
||||
// Deserialize a SignedNote from a string
|
||||
static fromString(envelope) {
|
||||
if (!envelope.includes(CHECKPOINT_SEPARATOR)) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'TLOG_INCLUSION_PROOF_ERROR',
|
||||
message: 'missing checkpoint separator',
|
||||
});
|
||||
}
|
||||
// Split the note into the header and the data portions at the separator
|
||||
const split = envelope.indexOf(CHECKPOINT_SEPARATOR);
|
||||
const header = envelope.slice(0, split + 1);
|
||||
const data = envelope.slice(split + CHECKPOINT_SEPARATOR.length);
|
||||
// Find all the signature lines in the data portion
|
||||
const matches = data.matchAll(SIGNATURE_REGEX);
|
||||
// Parse each of the matched signature lines into the name and signature.
|
||||
// The first four bytes of the signature are the key hint (should match the
|
||||
// first four bytes of the log ID), and the rest is the signature itself.
|
||||
const signatures = Array.from(matches, (match) => {
|
||||
const [, name, signature] = match;
|
||||
const sigBytes = Buffer.from(signature, 'base64');
|
||||
if (sigBytes.length < 5) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'TLOG_INCLUSION_PROOF_ERROR',
|
||||
message: 'malformed checkpoint signature',
|
||||
});
|
||||
}
|
||||
return {
|
||||
name,
|
||||
keyHint: sigBytes.subarray(0, 4),
|
||||
signature: sigBytes.subarray(4),
|
||||
};
|
||||
});
|
||||
if (signatures.length === 0) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'TLOG_INCLUSION_PROOF_ERROR',
|
||||
message: 'no signatures found in checkpoint',
|
||||
});
|
||||
}
|
||||
return new SignedNote(header, signatures);
|
||||
}
|
||||
}
|
||||
// LogCheckpoint represents a transparency log checkpoint. Consists of the
|
||||
// following:
|
||||
// - origin: the name of the transparency log
|
||||
// - logSize: the size of the log at the time of the checkpoint
|
||||
// - logHash: the root hash of the log at the time of the checkpoint
|
||||
// - rest: the rest of the checkpoint body, which is a list of log entries
|
||||
// See:
|
||||
// https://github.com/transparency-dev/formats/blob/main/log/README.md#checkpoint-body
|
||||
class LogCheckpoint {
|
||||
origin;
|
||||
logSize;
|
||||
logHash;
|
||||
rest;
|
||||
constructor(origin, logSize, logHash, rest) {
|
||||
this.origin = origin;
|
||||
this.logSize = logSize;
|
||||
this.logHash = logHash;
|
||||
this.rest = rest;
|
||||
}
|
||||
static fromString(note) {
|
||||
const lines = note.trimEnd().split('\n');
|
||||
if (lines.length < 3) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'TLOG_INCLUSION_PROOF_ERROR',
|
||||
message: 'too few lines in checkpoint header',
|
||||
});
|
||||
}
|
||||
const origin = lines[0];
|
||||
const logSize = BigInt(lines[1]);
|
||||
const rootHash = Buffer.from(lines[2], 'base64');
|
||||
const rest = lines.slice(3);
|
||||
return new LogCheckpoint(origin, logSize, rootHash, rest);
|
||||
}
|
||||
}
|
||||
exports.LogCheckpoint = LogCheckpoint;
|
||||
+6
@@ -0,0 +1,6 @@
|
||||
import type { Entry } from '@sigstore/protobuf-specs/rekor/v2';
|
||||
import type { ProposedDSSEEntry } from '@sigstore/rekor-types';
|
||||
import type { SignatureContent } from '../shared.types';
|
||||
export declare const DSSE_API_VERSION_V1 = "0.0.1";
|
||||
export declare function verifyDSSETLogBody(tlogEntry: ProposedDSSEEntry, content: SignatureContent): void;
|
||||
export declare function verifyDSSETLogBodyV2(tlogEntry: Entry, content: SignatureContent): void;
|
||||
+106
@@ -0,0 +1,106 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.DSSE_API_VERSION_V1 = void 0;
|
||||
exports.verifyDSSETLogBody = verifyDSSETLogBody;
|
||||
exports.verifyDSSETLogBodyV2 = verifyDSSETLogBodyV2;
|
||||
/*
|
||||
Copyright 2025 The Sigstore Authors.
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
See the License for the specific language governing permissions and
|
||||
limitations under the License.
|
||||
*/
|
||||
const error_1 = require("../error");
|
||||
exports.DSSE_API_VERSION_V1 = '0.0.1';
|
||||
// Compare the given dsse tlog entry to the given bundle
|
||||
function verifyDSSETLogBody(tlogEntry, content) {
|
||||
switch (tlogEntry.apiVersion) {
|
||||
case exports.DSSE_API_VERSION_V1:
|
||||
return verifyDSSE001TLogBody(tlogEntry, content);
|
||||
default:
|
||||
throw new error_1.VerificationError({
|
||||
code: 'TLOG_BODY_ERROR',
|
||||
message: `unsupported dsse version: ${tlogEntry.apiVersion}`,
|
||||
});
|
||||
}
|
||||
}
|
||||
// Compare the given dsse tlog entry to the given bundle. This function is
|
||||
// specifically for Rekor V2 entries.
|
||||
function verifyDSSETLogBodyV2(tlogEntry, content) {
|
||||
const spec = tlogEntry.spec?.spec;
|
||||
if (!spec) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'TLOG_BODY_ERROR',
|
||||
message: `missing dsse spec`,
|
||||
});
|
||||
}
|
||||
switch (spec.$case) {
|
||||
case 'dsseV002':
|
||||
return verifyDSSE002TLogBody(spec.dsseV002, content);
|
||||
default:
|
||||
throw new error_1.VerificationError({
|
||||
code: 'TLOG_BODY_ERROR',
|
||||
message: `unsupported version: ${spec.$case}`,
|
||||
});
|
||||
}
|
||||
}
|
||||
// Compare the given dsse v0.0.1 tlog entry to the given DSSE envelope.
|
||||
function verifyDSSE001TLogBody(tlogEntry, content) {
|
||||
// Ensure the bundle's DSSE only contains a single signature
|
||||
if (tlogEntry.spec.signatures?.length !== 1) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'TLOG_BODY_ERROR',
|
||||
message: 'signature count mismatch',
|
||||
});
|
||||
}
|
||||
const tlogSig = tlogEntry.spec.signatures[0].signature;
|
||||
// Ensure that the signature in the bundle's DSSE matches tlog entry
|
||||
if (!content.compareSignature(Buffer.from(tlogSig, 'base64')))
|
||||
throw new error_1.VerificationError({
|
||||
code: 'TLOG_BODY_ERROR',
|
||||
message: 'tlog entry signature mismatch',
|
||||
});
|
||||
// Ensure the digest of the bundle's DSSE payload matches the digest in the
|
||||
// tlog entry
|
||||
const tlogHash = tlogEntry.spec.payloadHash?.value || '';
|
||||
if (!content.compareDigest(Buffer.from(tlogHash, 'hex'))) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'TLOG_BODY_ERROR',
|
||||
message: 'DSSE payload hash mismatch',
|
||||
});
|
||||
}
|
||||
}
|
||||
// Compare the given dsse v0.0.2 tlog entry to the given DSSE envelope.
|
||||
function verifyDSSE002TLogBody(spec, content) {
|
||||
// Ensure the bundle's DSSE only contains a single signature
|
||||
if (spec.signatures?.length !== 1) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'TLOG_BODY_ERROR',
|
||||
message: 'signature count mismatch',
|
||||
});
|
||||
}
|
||||
const tlogSig = spec.signatures[0].content;
|
||||
// Ensure that the signature in the bundle's DSSE matches tlog entry
|
||||
if (!content.compareSignature(tlogSig))
|
||||
throw new error_1.VerificationError({
|
||||
code: 'TLOG_BODY_ERROR',
|
||||
message: 'tlog entry signature mismatch',
|
||||
});
|
||||
// Ensure the digest of the bundle's DSSE payload matches the digest in the
|
||||
// tlog entry
|
||||
const tlogHash = spec.payloadHash?.digest || Buffer.from('');
|
||||
if (!content.compareDigest(tlogHash)) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'TLOG_BODY_ERROR',
|
||||
message: 'DSSE payload hash mismatch',
|
||||
});
|
||||
}
|
||||
}
|
||||
+6
@@ -0,0 +1,6 @@
|
||||
import { Entry } from '@sigstore/protobuf-specs/rekor/v2';
|
||||
import type { ProposedHashedRekordEntry } from '@sigstore/rekor-types';
|
||||
import type { SignatureContent } from '../shared.types';
|
||||
export declare const HASHEDREKORD_API_VERSION_V1 = "0.0.1";
|
||||
export declare function verifyHashedRekordTLogBody(tlogEntry: ProposedHashedRekordEntry, content: SignatureContent): void;
|
||||
export declare function verifyHashedRekordTLogBodyV2(tlogEntry: Entry, content: SignatureContent): void;
|
||||
+94
@@ -0,0 +1,94 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.HASHEDREKORD_API_VERSION_V1 = void 0;
|
||||
exports.verifyHashedRekordTLogBody = verifyHashedRekordTLogBody;
|
||||
exports.verifyHashedRekordTLogBodyV2 = verifyHashedRekordTLogBodyV2;
|
||||
/*
|
||||
Copyright 2025 The Sigstore Authors.
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
See the License for the specific language governing permissions and
|
||||
limitations under the License.
|
||||
*/
|
||||
const error_1 = require("../error");
|
||||
exports.HASHEDREKORD_API_VERSION_V1 = '0.0.1';
|
||||
// Compare the given hashedrekord tlog entry to the given bundle
|
||||
function verifyHashedRekordTLogBody(tlogEntry, content) {
|
||||
switch (tlogEntry.apiVersion) {
|
||||
case exports.HASHEDREKORD_API_VERSION_V1:
|
||||
return verifyHashedrekord001TLogBody(tlogEntry, content);
|
||||
default:
|
||||
throw new error_1.VerificationError({
|
||||
code: 'TLOG_BODY_ERROR',
|
||||
message: `unsupported hashedrekord version: ${tlogEntry.apiVersion}`,
|
||||
});
|
||||
}
|
||||
}
|
||||
// Compare the given hashedrekor tlog entry to the given bundle. This function is
|
||||
// specifically for Rekor V2 entries.
|
||||
function verifyHashedRekordTLogBodyV2(tlogEntry, content) {
|
||||
const spec = tlogEntry.spec?.spec;
|
||||
if (!spec) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'TLOG_BODY_ERROR',
|
||||
message: `missing dsse spec`,
|
||||
});
|
||||
}
|
||||
switch (spec.$case) {
|
||||
case 'hashedRekordV002':
|
||||
return verifyHashedrekord002TLogBody(spec.hashedRekordV002, content);
|
||||
default:
|
||||
throw new error_1.VerificationError({
|
||||
code: 'TLOG_BODY_ERROR',
|
||||
message: `unsupported version: ${spec.$case}`,
|
||||
});
|
||||
}
|
||||
}
|
||||
// Compare the given hashedrekord v0.0.1 tlog entry to the given message
|
||||
// signature
|
||||
function verifyHashedrekord001TLogBody(tlogEntry, content) {
|
||||
// Ensure that the bundles message signature matches the tlog entry
|
||||
const tlogSig = tlogEntry.spec.signature.content || '';
|
||||
if (!content.compareSignature(Buffer.from(tlogSig, 'base64'))) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'TLOG_BODY_ERROR',
|
||||
message: 'signature mismatch',
|
||||
});
|
||||
}
|
||||
// Ensure that the bundle's message digest matches the tlog entry
|
||||
const tlogDigest = tlogEntry.spec.data.hash?.value || '';
|
||||
if (!content.compareDigest(Buffer.from(tlogDigest, 'hex'))) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'TLOG_BODY_ERROR',
|
||||
message: 'digest mismatch',
|
||||
});
|
||||
}
|
||||
}
|
||||
// Compare the given hashedrekord v0.0.2 tlog entry to the given message
|
||||
// signature
|
||||
function verifyHashedrekord002TLogBody(spec, content) {
|
||||
// Ensure that the bundles message signature matches the tlog entry
|
||||
const tlogSig = spec.signature?.content || Buffer.from('');
|
||||
if (!content.compareSignature(tlogSig)) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'TLOG_BODY_ERROR',
|
||||
message: 'signature mismatch',
|
||||
});
|
||||
}
|
||||
// Ensure that the bundle's message digest matches the tlog entry
|
||||
const tlogHash = spec.data?.digest || Buffer.from('');
|
||||
if (!content.compareDigest(tlogHash)) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'TLOG_BODY_ERROR',
|
||||
message: 'digest mismatch',
|
||||
});
|
||||
}
|
||||
}
|
||||
+5
@@ -0,0 +1,5 @@
|
||||
import type { TransparencyLogEntry } from '@sigstore/bundle';
|
||||
import type { SignatureContent } from '../shared.types';
|
||||
import { TLogAuthority } from '../trust';
|
||||
export declare function verifyTLogBody(entry: TransparencyLogEntry, sigContent: SignatureContent): void;
|
||||
export declare function verifyTLogInclusion(entry: TransparencyLogEntry, tlogAuthorities: TLogAuthority[]): void;
|
||||
+92
@@ -0,0 +1,92 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.verifyTLogBody = verifyTLogBody;
|
||||
exports.verifyTLogInclusion = verifyTLogInclusion;
|
||||
/*
|
||||
Copyright 2023 The Sigstore Authors.
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
See the License for the specific language governing permissions and
|
||||
limitations under the License.
|
||||
*/
|
||||
const v2_1 = require("@sigstore/protobuf-specs/rekor/v2");
|
||||
const error_1 = require("../error");
|
||||
const dsse_1 = require("./dsse");
|
||||
const hashedrekord_1 = require("./hashedrekord");
|
||||
const intoto_1 = require("./intoto");
|
||||
const checkpoint_1 = require("./checkpoint");
|
||||
const merkle_1 = require("./merkle");
|
||||
const set_1 = require("./set");
|
||||
// Verifies that the given tlog entry matches the supplied signature content.
|
||||
function verifyTLogBody(entry, sigContent) {
|
||||
const { kind, version } = entry.kindVersion;
|
||||
const body = JSON.parse(entry.canonicalizedBody.toString('utf8'));
|
||||
// validate body
|
||||
if (kind !== body.kind || version !== body.apiVersion) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'TLOG_BODY_ERROR',
|
||||
message: `kind/version mismatch - expected: ${kind}/${version}, received: ${body.kind}/${body.apiVersion}`,
|
||||
});
|
||||
}
|
||||
switch (kind) {
|
||||
case 'dsse':
|
||||
// Rekor V1 and V2 use incompatible types so we need to branch here based on version
|
||||
if (version == dsse_1.DSSE_API_VERSION_V1) {
|
||||
return (0, dsse_1.verifyDSSETLogBody)(body, sigContent);
|
||||
}
|
||||
else {
|
||||
const entryRekorV2 = v2_1.Entry.fromJSON(body);
|
||||
return (0, dsse_1.verifyDSSETLogBodyV2)(entryRekorV2, sigContent);
|
||||
}
|
||||
case 'intoto':
|
||||
return (0, intoto_1.verifyIntotoTLogBody)(body, sigContent);
|
||||
case 'hashedrekord':
|
||||
// Rekor V1 and V2 use incompatible types so we need to branch here based on version
|
||||
if (version == hashedrekord_1.HASHEDREKORD_API_VERSION_V1) {
|
||||
return (0, hashedrekord_1.verifyHashedRekordTLogBody)(body, sigContent);
|
||||
}
|
||||
else {
|
||||
const entryRekorV2 = v2_1.Entry.fromJSON(body);
|
||||
return (0, hashedrekord_1.verifyHashedRekordTLogBodyV2)(entryRekorV2, sigContent);
|
||||
}
|
||||
/* istanbul ignore next */
|
||||
default:
|
||||
throw new error_1.VerificationError({
|
||||
code: 'TLOG_BODY_ERROR',
|
||||
message: `unsupported kind: ${kind}`,
|
||||
});
|
||||
}
|
||||
}
|
||||
function verifyTLogInclusion(entry, tlogAuthorities) {
|
||||
let inclusionVerified = false;
|
||||
if (isTLogEntryWithInclusionPromise(entry)) {
|
||||
(0, set_1.verifyTLogSET)(entry, tlogAuthorities);
|
||||
inclusionVerified = true;
|
||||
}
|
||||
if (isTLogEntryWithInclusionProof(entry)) {
|
||||
const checkpoint = (0, checkpoint_1.verifyCheckpoint)(entry, tlogAuthorities);
|
||||
(0, merkle_1.verifyMerkleInclusion)(entry, checkpoint);
|
||||
inclusionVerified = true;
|
||||
}
|
||||
if (!inclusionVerified) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'TLOG_MISSING_INCLUSION_ERROR',
|
||||
message: 'inclusion could not be verified',
|
||||
});
|
||||
}
|
||||
return;
|
||||
}
|
||||
function isTLogEntryWithInclusionPromise(entry) {
|
||||
return entry.inclusionPromise !== undefined;
|
||||
}
|
||||
function isTLogEntryWithInclusionProof(entry) {
|
||||
return entry.inclusionProof !== undefined;
|
||||
}
|
||||
+3
@@ -0,0 +1,3 @@
|
||||
import type { ProposedIntotoEntry } from '@sigstore/rekor-types';
|
||||
import type { SignatureContent } from '../shared.types';
|
||||
export declare function verifyIntotoTLogBody(tlogEntry: ProposedIntotoEntry, content: SignatureContent): void;
|
||||
+62
@@ -0,0 +1,62 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.verifyIntotoTLogBody = verifyIntotoTLogBody;
|
||||
/*
|
||||
Copyright 2023 The Sigstore Authors.
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
See the License for the specific language governing permissions and
|
||||
limitations under the License.
|
||||
*/
|
||||
const error_1 = require("../error");
|
||||
// Compare the given intoto tlog entry to the given bundle
|
||||
function verifyIntotoTLogBody(tlogEntry, content) {
|
||||
switch (tlogEntry.apiVersion) {
|
||||
case '0.0.2':
|
||||
return verifyIntoto002TLogBody(tlogEntry, content);
|
||||
default:
|
||||
throw new error_1.VerificationError({
|
||||
code: 'TLOG_BODY_ERROR',
|
||||
message: `unsupported intoto version: ${tlogEntry.apiVersion}`,
|
||||
});
|
||||
}
|
||||
}
|
||||
// Compare the given intoto v0.0.2 tlog entry to the given DSSE envelope.
|
||||
function verifyIntoto002TLogBody(tlogEntry, content) {
|
||||
// Ensure the bundle's DSSE contains a single signature
|
||||
if (tlogEntry.spec.content.envelope.signatures?.length !== 1) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'TLOG_BODY_ERROR',
|
||||
message: 'signature count mismatch',
|
||||
});
|
||||
}
|
||||
// Signature is double-base64-encoded in the tlog entry
|
||||
const tlogSig = base64Decode(tlogEntry.spec.content.envelope.signatures[0].sig);
|
||||
// Ensure that the signature in the bundle's DSSE matches tlog entry
|
||||
if (!content.compareSignature(Buffer.from(tlogSig, 'base64'))) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'TLOG_BODY_ERROR',
|
||||
message: 'tlog entry signature mismatch',
|
||||
});
|
||||
}
|
||||
// Ensure the digest of the bundle's DSSE payload matches the digest in the
|
||||
// tlog entry
|
||||
const tlogHash = tlogEntry.spec.content.payloadHash?.value || '';
|
||||
if (!content.compareDigest(Buffer.from(tlogHash, 'hex'))) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'TLOG_BODY_ERROR',
|
||||
message: 'DSSE payload hash mismatch',
|
||||
});
|
||||
}
|
||||
}
|
||||
function base64Decode(str) {
|
||||
return Buffer.from(str, 'base64').toString('utf-8');
|
||||
}
|
||||
+3
@@ -0,0 +1,3 @@
|
||||
import { LogCheckpoint } from './checkpoint';
|
||||
import type { TLogEntryWithInclusionProof } from '@sigstore/bundle';
|
||||
export declare function verifyMerkleInclusion(entry: TLogEntryWithInclusionProof, checkpoint: LogCheckpoint): void;
|
||||
+104
@@ -0,0 +1,104 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.verifyMerkleInclusion = verifyMerkleInclusion;
|
||||
/*
|
||||
Copyright 2023 The Sigstore Authors.
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
See the License for the specific language governing permissions and
|
||||
limitations under the License.
|
||||
*/
|
||||
const core_1 = require("@sigstore/core");
|
||||
const error_1 = require("../error");
|
||||
const RFC6962_LEAF_HASH_PREFIX = Buffer.from([0x00]);
|
||||
const RFC6962_NODE_HASH_PREFIX = Buffer.from([0x01]);
|
||||
function verifyMerkleInclusion(entry, checkpoint) {
|
||||
const inclusionProof = entry.inclusionProof;
|
||||
const logIndex = BigInt(inclusionProof.logIndex);
|
||||
const treeSize = BigInt(checkpoint.logSize);
|
||||
if (logIndex < 0n || logIndex >= treeSize) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'TLOG_INCLUSION_PROOF_ERROR',
|
||||
message: `invalid index: ${logIndex}`,
|
||||
});
|
||||
}
|
||||
// Figure out which subset of hashes corresponds to the inner and border
|
||||
// nodes
|
||||
const { inner, border } = decompInclProof(logIndex, treeSize);
|
||||
if (inclusionProof.hashes.length !== inner + border) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'TLOG_INCLUSION_PROOF_ERROR',
|
||||
message: 'invalid hash count',
|
||||
});
|
||||
}
|
||||
const innerHashes = inclusionProof.hashes.slice(0, inner);
|
||||
const borderHashes = inclusionProof.hashes.slice(inner);
|
||||
// The entry's hash is the leaf hash
|
||||
const leafHash = hashLeaf(entry.canonicalizedBody);
|
||||
// Chain the hashes belonging to the inner and border portions
|
||||
const calculatedHash = chainBorderRight(chainInner(leafHash, innerHashes, logIndex), borderHashes);
|
||||
// Calculated hash should match the root hash in the inclusion proof
|
||||
if (!core_1.crypto.bufferEqual(calculatedHash, checkpoint.logHash)) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'TLOG_INCLUSION_PROOF_ERROR',
|
||||
message: 'calculated root hash does not match inclusion proof',
|
||||
});
|
||||
}
|
||||
}
|
||||
// Breaks down inclusion proof for a leaf at the specified index in a tree of
|
||||
// the specified size. The split point is where paths to the index leaf and
|
||||
// the (size - 1) leaf diverge. Returns lengths of the bottom and upper proof
|
||||
// parts.
|
||||
function decompInclProof(index, size) {
|
||||
const inner = innerProofSize(index, size);
|
||||
const border = onesCount(index >> BigInt(inner));
|
||||
return { inner, border };
|
||||
}
|
||||
// Computes a subtree hash for a node on or below the tree's right border.
|
||||
// Assumes the provided proof hashes are ordered from lower to higher levels
|
||||
// and seed is the initial hash of the node specified by the index.
|
||||
function chainInner(seed, hashes, index) {
|
||||
return hashes.reduce((acc, h, i) => {
|
||||
if ((index >> BigInt(i)) & BigInt(1)) {
|
||||
return hashChildren(h, acc);
|
||||
}
|
||||
else {
|
||||
return hashChildren(acc, h);
|
||||
}
|
||||
}, seed);
|
||||
}
|
||||
// Computes a subtree hash for nodes along the tree's right border.
|
||||
function chainBorderRight(seed, hashes) {
|
||||
return hashes.reduce((acc, h) => hashChildren(h, acc), seed);
|
||||
}
|
||||
function innerProofSize(index, size) {
|
||||
return bitLength(index ^ (size - BigInt(1)));
|
||||
}
|
||||
// Counts the number of ones in the binary representation of the given number.
|
||||
// https://en.wikipedia.org/wiki/Hamming_weight
|
||||
function onesCount(num) {
|
||||
return num.toString(2).split('1').length - 1;
|
||||
}
|
||||
// Returns the number of bits necessary to represent an integer in binary.
|
||||
function bitLength(n) {
|
||||
if (n === 0n) {
|
||||
return 0;
|
||||
}
|
||||
return n.toString(2).length;
|
||||
}
|
||||
// Hashing logic according to RFC6962.
|
||||
// https://datatracker.ietf.org/doc/html/rfc6962#section-2
|
||||
function hashChildren(left, right) {
|
||||
return core_1.crypto.digest('sha256', RFC6962_NODE_HASH_PREFIX, left, right);
|
||||
}
|
||||
function hashLeaf(leaf) {
|
||||
return core_1.crypto.digest('sha256', RFC6962_LEAF_HASH_PREFIX, leaf);
|
||||
}
|
||||
+3
@@ -0,0 +1,3 @@
|
||||
import { TLogAuthority } from '../trust';
|
||||
import type { TLogEntryWithInclusionPromise } from '@sigstore/bundle';
|
||||
export declare function verifyTLogSET(entry: TLogEntryWithInclusionPromise, tlogs: TLogAuthority[]): void;
|
||||
+60
@@ -0,0 +1,60 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.verifyTLogSET = verifyTLogSET;
|
||||
/*
|
||||
Copyright 2023 The Sigstore Authors.
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
See the License for the specific language governing permissions and
|
||||
limitations under the License.
|
||||
*/
|
||||
const core_1 = require("@sigstore/core");
|
||||
const error_1 = require("../error");
|
||||
const trust_1 = require("../trust");
|
||||
// Verifies the SET for the given entry against the list of trusted
|
||||
// transparency logs. Returns true if the SET can be verified against at least
|
||||
// one of the trusted logs; otherwise, returns false.
|
||||
function verifyTLogSET(entry, tlogs) {
|
||||
// Filter the list of tlog instances to only those which might be able to
|
||||
// verify the SET
|
||||
const validTLogs = (0, trust_1.filterTLogAuthorities)(tlogs, {
|
||||
logID: entry.logId.keyId,
|
||||
targetDate: new Date(Number(entry.integratedTime) * 1000),
|
||||
});
|
||||
// Check to see if we can verify the SET against any of the valid tlogs
|
||||
const verified = validTLogs.some((tlog) => {
|
||||
// Re-create the original Rekor verification payload
|
||||
const payload = toVerificationPayload(entry);
|
||||
// Canonicalize the payload and turn into a buffer for verification
|
||||
const data = Buffer.from(core_1.json.canonicalize(payload), 'utf8');
|
||||
// Extract the SET from the tlog entry
|
||||
const signature = entry.inclusionPromise.signedEntryTimestamp;
|
||||
return core_1.crypto.verify(data, tlog.publicKey, signature);
|
||||
});
|
||||
if (!verified) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'TLOG_INCLUSION_PROMISE_ERROR',
|
||||
message: 'inclusion promise could not be verified',
|
||||
});
|
||||
}
|
||||
}
|
||||
// Returns a properly formatted "VerificationPayload" for one of the
|
||||
// transaction log entires in the given bundle which can be used for SET
|
||||
// verification.
|
||||
function toVerificationPayload(entry) {
|
||||
const { integratedTime, logIndex, logId, canonicalizedBody } = entry;
|
||||
return {
|
||||
body: canonicalizedBody.toString('base64'),
|
||||
integratedTime: Number(integratedTime),
|
||||
logIndex: Number(logIndex),
|
||||
logID: logId.keyId.toString('hex'),
|
||||
};
|
||||
}
|
||||
+8
@@ -0,0 +1,8 @@
|
||||
import type { CertAuthority, TLogAuthority } from './trust.types';
|
||||
export declare function filterCertAuthorities(certAuthorities: CertAuthority[], timestamp: Date): CertAuthority[];
|
||||
type TLogAuthorityFilterCriteria = {
|
||||
targetDate: Date;
|
||||
logID?: Buffer;
|
||||
};
|
||||
export declare function filterTLogAuthorities(tlogAuthorities: TLogAuthority[], criteria: TLogAuthorityFilterCriteria): TLogAuthority[];
|
||||
export {};
|
||||
+23
@@ -0,0 +1,23 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.filterCertAuthorities = filterCertAuthorities;
|
||||
exports.filterTLogAuthorities = filterTLogAuthorities;
|
||||
function filterCertAuthorities(certAuthorities, timestamp) {
|
||||
return certAuthorities.filter((ca) => {
|
||||
return ca.validFor.start <= timestamp && ca.validFor.end >= timestamp;
|
||||
});
|
||||
}
|
||||
// Filter the list of tlog instances to only those which match the given log
|
||||
// ID and have public keys which are valid for the given integrated time.
|
||||
function filterTLogAuthorities(tlogAuthorities, criteria) {
|
||||
return tlogAuthorities.filter((tlog) => {
|
||||
// If we're filtering by log ID and the log IDs don't match, we can't use
|
||||
// this tlog
|
||||
if (criteria.logID && !tlog.logID.equals(criteria.logID)) {
|
||||
return false;
|
||||
}
|
||||
// Check that the integrated time is within the validFor range
|
||||
return (tlog.validFor.start <= criteria.targetDate &&
|
||||
criteria.targetDate <= tlog.validFor.end);
|
||||
});
|
||||
}
|
||||
+5
@@ -0,0 +1,5 @@
|
||||
import { type PublicKey, type TrustedRoot } from '@sigstore/protobuf-specs';
|
||||
import type { KeyFinderFunc, TrustMaterial } from './trust.types';
|
||||
export { filterCertAuthorities, filterTLogAuthorities } from './filter';
|
||||
export type { CertAuthority, KeyFinderFunc, TLogAuthority, TrustMaterial, } from './trust.types';
|
||||
export declare function toTrustMaterial(root: TrustedRoot, keys?: Record<string, PublicKey> | KeyFinderFunc): TrustMaterial;
|
||||
+90
@@ -0,0 +1,90 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.filterTLogAuthorities = exports.filterCertAuthorities = void 0;
|
||||
exports.toTrustMaterial = toTrustMaterial;
|
||||
/*
|
||||
Copyright 2023 The Sigstore Authors.
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
See the License for the specific language governing permissions and
|
||||
limitations under the License.
|
||||
*/
|
||||
const core_1 = require("@sigstore/core");
|
||||
const protobuf_specs_1 = require("@sigstore/protobuf-specs");
|
||||
const error_1 = require("../error");
|
||||
const BEGINNING_OF_TIME = new Date(0);
|
||||
const END_OF_TIME = new Date(8640000000000000);
|
||||
var filter_1 = require("./filter");
|
||||
Object.defineProperty(exports, "filterCertAuthorities", { enumerable: true, get: function () { return filter_1.filterCertAuthorities; } });
|
||||
Object.defineProperty(exports, "filterTLogAuthorities", { enumerable: true, get: function () { return filter_1.filterTLogAuthorities; } });
|
||||
function toTrustMaterial(root, keys) {
|
||||
const keyFinder = typeof keys === 'function' ? keys : keyLocator(keys);
|
||||
return {
|
||||
certificateAuthorities: root.certificateAuthorities.map(createCertAuthority),
|
||||
timestampAuthorities: root.timestampAuthorities.map(createCertAuthority),
|
||||
tlogs: root.tlogs.map(createTLogAuthority),
|
||||
ctlogs: root.ctlogs.map(createTLogAuthority),
|
||||
publicKey: keyFinder,
|
||||
};
|
||||
}
|
||||
function createTLogAuthority(tlogInstance) {
|
||||
const keyDetails = tlogInstance.publicKey.keyDetails;
|
||||
const keyType = keyDetails === protobuf_specs_1.PublicKeyDetails.PKCS1_RSA_PKCS1V5 ||
|
||||
keyDetails === protobuf_specs_1.PublicKeyDetails.PKIX_RSA_PKCS1V5 ||
|
||||
keyDetails === protobuf_specs_1.PublicKeyDetails.PKIX_RSA_PKCS1V15_2048_SHA256 ||
|
||||
keyDetails === protobuf_specs_1.PublicKeyDetails.PKIX_RSA_PKCS1V15_3072_SHA256 ||
|
||||
keyDetails === protobuf_specs_1.PublicKeyDetails.PKIX_RSA_PKCS1V15_4096_SHA256
|
||||
? 'pkcs1'
|
||||
: 'spki';
|
||||
/* istanbul ignore next */
|
||||
return {
|
||||
baseURL: tlogInstance.baseUrl,
|
||||
logID: tlogInstance.checkpointKeyId
|
||||
? tlogInstance.checkpointKeyId.keyId
|
||||
: tlogInstance.logId.keyId,
|
||||
publicKey: core_1.crypto.createPublicKey(tlogInstance.publicKey.rawBytes, keyType),
|
||||
validFor: {
|
||||
start: tlogInstance.publicKey.validFor?.start || BEGINNING_OF_TIME,
|
||||
end: tlogInstance.publicKey.validFor?.end || END_OF_TIME,
|
||||
},
|
||||
};
|
||||
}
|
||||
function createCertAuthority(ca) {
|
||||
/* istanbul ignore next */
|
||||
return {
|
||||
certChain: ca.certChain.certificates.map((cert) => {
|
||||
return core_1.X509Certificate.parse(Buffer.from(cert.rawBytes));
|
||||
}),
|
||||
validFor: {
|
||||
start: ca.validFor?.start || BEGINNING_OF_TIME,
|
||||
end: ca.validFor?.end || END_OF_TIME,
|
||||
},
|
||||
};
|
||||
}
|
||||
function keyLocator(keys) {
|
||||
return (hint) => {
|
||||
const key = (keys || {})[hint];
|
||||
if (!key) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'PUBLIC_KEY_ERROR',
|
||||
message: `key not found: ${hint}`,
|
||||
});
|
||||
}
|
||||
return {
|
||||
publicKey: core_1.crypto.createPublicKey(key.rawBytes),
|
||||
validFor: (date) => {
|
||||
/* istanbul ignore next */
|
||||
return ((key.validFor?.start || BEGINNING_OF_TIME) <= date &&
|
||||
(key.validFor?.end || END_OF_TIME) >= date);
|
||||
},
|
||||
};
|
||||
};
|
||||
}
|
||||
+29
@@ -0,0 +1,29 @@
|
||||
import type { X509Certificate, crypto } from '@sigstore/core';
|
||||
export type TLogAuthority = {
|
||||
logID: Buffer;
|
||||
baseURL: string;
|
||||
publicKey: crypto.KeyObject;
|
||||
validFor: {
|
||||
start: Date;
|
||||
end: Date;
|
||||
};
|
||||
};
|
||||
export type CertAuthority = {
|
||||
certChain: X509Certificate[];
|
||||
validFor: {
|
||||
start: Date;
|
||||
end: Date;
|
||||
};
|
||||
};
|
||||
export type TimeConstrainedKey = {
|
||||
publicKey: crypto.KeyObject;
|
||||
validFor(date: Date): boolean;
|
||||
};
|
||||
export type KeyFinderFunc = (hint: string) => TimeConstrainedKey;
|
||||
export type TrustMaterial = {
|
||||
certificateAuthorities: CertAuthority[];
|
||||
timestampAuthorities: CertAuthority[];
|
||||
tlogs: TLogAuthority[];
|
||||
ctlogs: TLogAuthority[];
|
||||
publicKey: KeyFinderFunc;
|
||||
};
|
||||
+2
@@ -0,0 +1,2 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
+31
@@ -0,0 +1,31 @@
|
||||
import type { SignedEntity, Signer, VerificationPolicy } from './shared.types';
|
||||
import type { TrustMaterial } from './trust';
|
||||
/**
|
||||
* Configuration options for the verifier.
|
||||
*
|
||||
* @public
|
||||
*/
|
||||
export interface VerifierOptions {
|
||||
/** Minimum number of transparency log entries required for verification */
|
||||
tlogThreshold?: number;
|
||||
/** Minimum number of certificate transparency log entries required */
|
||||
ctlogThreshold?: number;
|
||||
/**
|
||||
* Minimum number of timestamp authority timestamps required for verification
|
||||
* @deprecated Use timestampThreshold instead
|
||||
*/
|
||||
tsaThreshold?: number;
|
||||
/** Minimum number of timestamps required for verification */
|
||||
timestampThreshold?: number;
|
||||
}
|
||||
export declare class Verifier {
|
||||
private trustMaterial;
|
||||
private options;
|
||||
constructor(trustMaterial: TrustMaterial, options?: VerifierOptions);
|
||||
verify(entity: SignedEntity, policy?: VerificationPolicy): Signer;
|
||||
private verifyTimestamps;
|
||||
private verifySigningKey;
|
||||
private verifyTLogs;
|
||||
private verifySignature;
|
||||
private verifyPolicy;
|
||||
}
|
||||
+150
@@ -0,0 +1,150 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.Verifier = void 0;
|
||||
/*
|
||||
Copyright 2023 The Sigstore Authors.
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
See the License for the specific language governing permissions and
|
||||
limitations under the License.
|
||||
*/
|
||||
const util_1 = require("util");
|
||||
const error_1 = require("./error");
|
||||
const key_1 = require("./key");
|
||||
const policy_1 = require("./policy");
|
||||
const timestamp_1 = require("./timestamp");
|
||||
const tlog_1 = require("./tlog");
|
||||
class Verifier {
|
||||
trustMaterial;
|
||||
options;
|
||||
constructor(trustMaterial, options = {}) {
|
||||
this.trustMaterial = trustMaterial;
|
||||
this.options = {
|
||||
ctlogThreshold: options.ctlogThreshold ?? 1,
|
||||
tlogThreshold: options.tlogThreshold ?? 1,
|
||||
timestampThreshold: options.timestampThreshold ?? options.tsaThreshold ?? 1,
|
||||
tsaThreshold: 0,
|
||||
};
|
||||
}
|
||||
verify(entity, policy) {
|
||||
const timestamps = this.verifyTimestamps(entity);
|
||||
const signer = this.verifySigningKey(entity, timestamps);
|
||||
this.verifyTLogs(entity);
|
||||
this.verifySignature(entity, signer);
|
||||
if (policy) {
|
||||
this.verifyPolicy(policy, signer.identity || {});
|
||||
}
|
||||
return signer;
|
||||
}
|
||||
// Checks that all of the timestamps in the entity are valid and returns them
|
||||
verifyTimestamps(entity) {
|
||||
let timestampCount = 0;
|
||||
const timestamps = entity.timestamps.map((timestamp) => {
|
||||
switch (timestamp.$case) {
|
||||
case 'timestamp-authority':
|
||||
timestampCount++;
|
||||
return (0, timestamp_1.getTSATimestamp)(timestamp.timestamp, entity.signature.signature, this.trustMaterial.timestampAuthorities);
|
||||
case 'transparency-log':
|
||||
timestampCount++;
|
||||
return (0, timestamp_1.getTLogTimestamp)(timestamp.tlogEntry);
|
||||
}
|
||||
});
|
||||
// Check for duplicate timestamps
|
||||
if (containsDupes(timestamps)) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'TIMESTAMP_ERROR',
|
||||
message: 'duplicate timestamp',
|
||||
});
|
||||
}
|
||||
if (timestampCount < this.options.timestampThreshold) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'TIMESTAMP_ERROR',
|
||||
message: `expected ${this.options.timestampThreshold} timestamps, got ${timestampCount}`,
|
||||
});
|
||||
}
|
||||
return timestamps.map((t) => t.timestamp);
|
||||
}
|
||||
// Checks that the signing key is valid for all of the the supplied timestamps
|
||||
// and returns the signer.
|
||||
verifySigningKey({ key }, timestamps) {
|
||||
switch (key.$case) {
|
||||
case 'public-key': {
|
||||
return (0, key_1.verifyPublicKey)(key.hint, timestamps, this.trustMaterial);
|
||||
}
|
||||
case 'certificate': {
|
||||
const result = (0, key_1.verifyCertificate)(key.certificate, timestamps, this.trustMaterial);
|
||||
/* istanbul ignore next - no fixture */
|
||||
if (containsDupes(result.scts)) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'CERTIFICATE_ERROR',
|
||||
message: 'duplicate SCT',
|
||||
});
|
||||
}
|
||||
if (result.scts.length < this.options.ctlogThreshold) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'CERTIFICATE_ERROR',
|
||||
message: `expected ${this.options.ctlogThreshold} SCTs, got ${result.scts.length}`,
|
||||
});
|
||||
}
|
||||
return result.signer;
|
||||
}
|
||||
}
|
||||
}
|
||||
// Checks that the tlog entries are valid for the supplied content
|
||||
verifyTLogs({ signature: content, tlogEntries }) {
|
||||
let tlogCount = 0;
|
||||
tlogEntries.forEach((entry) => {
|
||||
tlogCount++;
|
||||
(0, tlog_1.verifyTLogInclusion)(entry, this.trustMaterial.tlogs);
|
||||
(0, tlog_1.verifyTLogBody)(entry, content);
|
||||
});
|
||||
if (tlogCount < this.options.tlogThreshold) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'TLOG_ERROR',
|
||||
message: `expected ${this.options.tlogThreshold} tlog entries, got ${tlogCount}`,
|
||||
});
|
||||
}
|
||||
}
|
||||
// Checks that the signature is valid for the supplied content
|
||||
verifySignature(entity, signer) {
|
||||
if (!entity.signature.verifySignature(signer.key)) {
|
||||
throw new error_1.VerificationError({
|
||||
code: 'SIGNATURE_ERROR',
|
||||
message: 'signature verification failed',
|
||||
});
|
||||
}
|
||||
}
|
||||
verifyPolicy(policy, identity) {
|
||||
// Check the subject alternative name of the signer matches the policy
|
||||
/* istanbul ignore else */
|
||||
if (policy.subjectAlternativeName) {
|
||||
(0, policy_1.verifySubjectAlternativeName)(policy.subjectAlternativeName, identity.subjectAlternativeName);
|
||||
}
|
||||
// Check that the extensions of the signer match the policy
|
||||
/* istanbul ignore else */
|
||||
if (policy.extensions) {
|
||||
(0, policy_1.verifyExtensions)(policy.extensions, identity.extensions);
|
||||
}
|
||||
}
|
||||
}
|
||||
exports.Verifier = Verifier;
|
||||
// Checks for duplicate items in the array. Objects are compared using
|
||||
// deep equality.
|
||||
function containsDupes(arr) {
|
||||
for (let i = 0; i < arr.length; i++) {
|
||||
for (let j = i + 1; j < arr.length; j++) {
|
||||
if ((0, util_1.isDeepStrictEqual)(arr[i], arr[j])) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
+36
@@ -0,0 +1,36 @@
|
||||
{
|
||||
"name": "@sigstore/verify",
|
||||
"version": "3.1.0",
|
||||
"description": "Verification of Sigstore signatures",
|
||||
"main": "dist/index.js",
|
||||
"types": "dist/index.d.ts",
|
||||
"scripts": {
|
||||
"clean": "shx rm -rf dist *.tsbuildinfo",
|
||||
"build": "tsc --build",
|
||||
"test": "jest"
|
||||
},
|
||||
"files": [
|
||||
"dist"
|
||||
],
|
||||
"author": "bdehamer@github.com",
|
||||
"license": "Apache-2.0",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git+https://github.com/sigstore/sigstore-js.git"
|
||||
},
|
||||
"bugs": {
|
||||
"url": "https://github.com/sigstore/sigstore-js/issues"
|
||||
},
|
||||
"homepage": "https://github.com/sigstore/sigstore-js/tree/main/packages/verify#readme",
|
||||
"publishConfig": {
|
||||
"provenance": true
|
||||
},
|
||||
"dependencies": {
|
||||
"@sigstore/protobuf-specs": "^0.5.0",
|
||||
"@sigstore/bundle": "^4.0.0",
|
||||
"@sigstore/core": "^3.1.0"
|
||||
},
|
||||
"engines": {
|
||||
"node": "^20.17.0 || >=22.9.0"
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user