@chittyos/core/dist/verify/index.mjs

ChittyOS Core - Essential package with ID, auth, verification, beacon tracking, and brand components for all ChittyOS applications

// src/verify/index.ts
import { z } from "zod";
import * as crypto from "crypto";
var DEFAULT_CONFIG = {
  strictMode: false,
  hashAlgorithm: "sha256"
};
var config = { ...DEFAULT_CONFIG };
function configure(customConfig) {
  config = { ...config, ...customConfig };
}
function validateSchema(data, schema) {
  try {
    const validated = schema.parse(data);
    return {
      valid: true,
      data: validated
    };
  } catch (error) {
    if (error instanceof z.ZodError) {
      return {
        valid: false,
        errors: error.errors.map((e) => `${e.path.join(".")}: ${e.message}`)
      };
    }
    return {
      valid: false,
      errors: ["Validation failed"]
    };
  }
}
var schemas = {
  email: z.string().email(),
  chittyId: z.string().regex(/^CID_[A-Za-z0-9_-]{21}$/),
  uuid: z.string().uuid(),
  url: z.string().url(),
  phoneNumber: z.string().regex(/^\+?[1-9]\d{1,14}$/),
  dateTime: z.string().datetime(),
  ipAddress: z.string().ip(),
  semver: z.string().regex(/^\d+\.\d+\.\d+(-[a-zA-Z0-9]+)?$/),
  strongPassword: z.string().min(8).regex(/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]/),
  jwt: z.string().regex(/^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/),
  base64: z.string().regex(/^[A-Za-z0-9+/]*={0,2}$/),
  hexColor: z.string().regex(/^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/),
  creditCard: z.string().regex(/^\d{13,19}$/).refine(luhnCheck, {
    message: "Invalid credit card number"
  })
};
function luhnCheck(cardNumber) {
  const digits = cardNumber.replace(/\D/g, "");
  let sum = 0;
  let isEven = false;
  for (let i = digits.length - 1; i >= 0; i--) {
    let digit = parseInt(digits[i], 10);
    if (isEven) {
      digit *= 2;
      if (digit > 9) {
        digit -= 9;
      }
    }
    sum += digit;
    isEven = !isEven;
  }
  return sum % 10 === 0;
}
function hashData(data, algorithm = config.hashAlgorithm) {
  const stringData = typeof data === "string" ? data : JSON.stringify(data);
  return crypto.createHash(algorithm).update(stringData).digest("hex");
}
function verifyIntegrity(data, expectedHash, algorithm = config.hashAlgorithm) {
  const actualHash = hashData(data, algorithm);
  return actualHash === expectedHash;
}
function signData(data, privateKey, chittyId) {
  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
  const dataToSign = JSON.stringify({ data, timestamp });
  const sign = crypto.createSign("SHA256");
  sign.update(dataToSign);
  const signature = sign.sign(privateKey, "base64");
  return {
    data,
    signature,
    timestamp,
    chittyId
  };
}
function verifySignedData(signedData, publicKey) {
  try {
    const dataToVerify = JSON.stringify({
      data: signedData.data,
      timestamp: signedData.timestamp
    });
    const verify = crypto.createVerify("SHA256");
    verify.update(dataToVerify);
    const isValid = verify.verify(publicKey, signedData.signature, "base64");
    return {
      valid: isValid,
      errors: isValid ? void 0 : ["Invalid signature"]
    };
  } catch (error) {
    return {
      valid: false,
      errors: ["Signature verification failed"]
    };
  }
}
async function validateChecksum(filePath, expectedChecksum, algorithm = "sha256") {
  const fs = await import("fs");
  const stream = fs.createReadStream(filePath);
  const hash = crypto.createHash(algorithm);
  return new Promise((resolve, reject) => {
    stream.on("data", (data) => hash.update(data));
    stream.on("end", () => {
      const actualChecksum = hash.digest("hex");
      resolve(actualChecksum === expectedChecksum);
    });
    stream.on("error", reject);
  });
}
function sanitizeInput(input) {
  let sanitized = input.replace(/[\x00-\x1F\x7F]/g, "");
  sanitized = sanitized.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;").replace(/\//g, "&#x2F;");
  return sanitized.trim();
}
function validateJSON(jsonString) {
  try {
    const parsed = JSON.parse(jsonString);
    return {
      valid: true,
      data: parsed
    };
  } catch (error) {
    return {
      valid: false,
      errors: ["Invalid JSON: " + error.message]
    };
  }
}
var verify_default = {
  configure,
  validateSchema,
  schemas,
  hashData,
  verifyIntegrity,
  signData,
  verifySignedData,
  validateChecksum,
  sanitizeInput,
  validateJSON
};
export {
  configure,
  verify_default as default,
  hashData,
  sanitizeInput,
  schemas,
  signData,
  validateChecksum,
  validateJSON,
  validateSchema,
  verifyIntegrity,
  verifySignedData
};
//# sourceMappingURL=index.mjs.map