Files
canina/backend/src/admin/ssl.service.spec.ts
T
devops ddbf1ca026
Deploy Canina / deploy (push) Successful in 4m1s
E2E Playwright Tests / Run Full E2E & Security Suites (push) Failing after 7s
test: comprehensive test suites and quality gates pass across backend, storefront and admin
- Backend (NestJS): 82 suites, 641 tests passing; 0 ESLint errors; 0 tsc errors. Hardened SSL cert/key matching, SSRF IP pinning, and eBank validation.
- Admin Panel (Vite/React): 48 suites, 300 tests passing; 0 ESLint errors; 0 tsc errors. Full coverage across all pages and settings.
- Storefront (Next.js): 62 suites, 368 tests passing; 0 ESLint errors; 0 tsc errors.
- Fixed unmount lifecycle guards, promise error handling, and component edge cases.
2026-10-13 16:01:00 +00:00

407 lines
15 KiB
TypeScript

import { Test, TestingModule } from "@nestjs/testing";
import { SslService } from "./ssl.service";
import { BadRequestException } from "@nestjs/common";
import * as fs from "fs";
import * as tls from "tls";
import * as dns from "dns/promises";
import * as crypto from "crypto";
import { EventEmitter } from "events";
jest.mock("fs");
jest.mock("tls");
jest.mock("dns/promises");
const VALID_CERT = `-----BEGIN CERTIFICATE-----
MIICyjCCAbKgAwIBAgIBATANBgkqhkiG9w0BAQsFADAUMRIwEAYDVQQDDAljYW5p
bmEuaXIwHhcNMjYwMTAxMDAwMDAwWhcNMzAwMTAxMDAwMDAwWjAUMRIwEAYDVQQD
DAljYW5pbmEuaXIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCrRe7W
fArfQ7unMhG+bT5nNangnFIrB431AaCBesk3dPeGiLljb4QkMY1iMyKsjkKT04Qc
7RtWb3GGutLR2W9i+o3yEk41YIQsAAs6FA5Wh81ncltjct16Wmm2RAwfF579qrvm
8iNVVu82nXidC9/nNyuFg/8AyJ8YGnona5SB0NkC+D2Ed53ubaf2Dd3NH2mOLAxD
x2u/eNuBSShf/7MOd4c7fUSKUABvbjyL//W1ylIhoq7Wba10LW7NimfnIt2+W/DQ
FcOFYxVlES/hcInmOomat51JbUkWD7zINUK6+aBQdPYa9rpYyvKoiUccudrU9LGU
i96s7G+2JsGiALqNAgMBAAGjJzAlMCMGA1UdEQQcMBqCCWNhbmluYS5pcoINd3d3
LmNhbmluYS5pcjANBgkqhkiG9w0BAQsFAAOCAQEAlSYQMIemuYjBQc85wUpnO9iq
hG4UDJMCTSQee5vbiSDft7YOR1mp93xHWwitxR1VxnqsFqeel+XE9O6wmotfBWlR
EJdzeQQYRVT/X7NyNdEJoSqzZBvshbExH5VHNdIZytm2NdKFStR9GYhT6CcW3qB+
WujsG3OvVgF3Ow6YKZ+NULD0+ygIGuZkVgvvUxmXwSqBxvairZeIZUE+lIcKkVHL
7ULZgF0eByhaqnR6Swyp+GnT9GYMMSnTwMwd4Ggng7Ncd09NyvpdwgVvE/YJH5MV
5Aj8eyMiKLxDyh/uZBsWuh/Fs74MOgVsLqH83TjWTCRJmQrCtPSN6831NSWqbw==
-----END CERTIFICATE-----`;
const VALID_KEY = `-----BEGIN PRIVATE KEY-----
MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCrRe7WfArfQ7un
MhG+bT5nNangnFIrB431AaCBesk3dPeGiLljb4QkMY1iMyKsjkKT04Qc7RtWb3GG
utLR2W9i+o3yEk41YIQsAAs6FA5Wh81ncltjct16Wmm2RAwfF579qrvm8iNVVu82
nXidC9/nNyuFg/8AyJ8YGnona5SB0NkC+D2Ed53ubaf2Dd3NH2mOLAxDx2u/eNuB
SShf/7MOd4c7fUSKUABvbjyL//W1ylIhoq7Wba10LW7NimfnIt2+W/DQFcOFYxVl
ES/hcInmOomat51JbUkWD7zINUK6+aBQdPYa9rpYyvKoiUccudrU9LGUi96s7G+2
JsGiALqNAgMBAAECggEAByggb0j2oVawuC9Q636gHWryIscVbePebC75uH9behxC
nZYH/R4zTNnfOQu+9qvpH0k224iS3F1Cxqj21zr5Ow8SMFvQdc2HKFmGHpKo+Leq
/xgZtoGdvJeblDiqsv/nLl1cha13iYDc9RDGcfWFkSFOicE2vh8j+rtcgFov9e6l
Kh4xS6P5GjXM2o8j6e4fwLEhaBX1pSmSIHLOCZVE8gAi+f4TvcU7B3bpPZoNii79
gGIVQuwounjtoYgv3tDu3qUSp8vxxNkV3C1N7O5fzUcmQnciWxnVn2OkwJ0ndgiA
J3Mp1/Uy4J5C7hgF7Hj+9eM4c2epzgn8jV3bMOprZwKBgQDVVHuxjx7CMNM3nZQ/
lDM0TJCygrpK6mTSpTFna9bVYbVOswJAwVuLhM+aJ+GrPLNi0p809bauHFS88Biy
Igyi+f1/ghJzKAF8XBSTkpSTKs8nR13mwPlSMsyLL+4NLt4m0NSFiwpGQymGPW4e
cBoRkgiHWCm1bm61pWTBYaamIwKBgQDNh/BJCn7h/J5/1HqyFKXweInQRNORj14L
kaQSPyZux7h0QYXWOhIP/A9CwgpFxt0ZVy9yHkexdeLf6JXlie5jkIniMj1QMnyY
N0qoiDqjnM8IPr9kJ0683IHEPmd0EbJKP4Pmems67/27eIZtejK+8UvD6IUCngCX
xXd9lcivjwKBgBnk9lq4J6Ckso62pu8MuyZnAM1aRuifCPv0p0mJcntWL97MpcJc
dhM6XMS2gJL7fD7LmB2ikbkSoUqJzkWZEnWZ6KZYkIq/2WZR+wFqsnQmpxx6cjB3
TgwnNGLUv42EGd0WTiWjmeyrbFfqDvrM2q01T6m2DuIB9JhB6jf69XKHAoGBAK7M
Ex57j6ewyjgbRHJZvzsBuOto7apZDPm31psyHASRVR2CcEnev2fazjvPfR8U3wtj
K9XZTM3vXZFiZMGACj+hOLMoWR7woShvtc4Zdg2aGjV/8BREneFfg/mbvS5osoIU
/J+ys6m/W8Lp4SIQkEH2Q6KNCTpNmGF7roEfNzufAoGAeggOz6bdGkw7vOo3kXwz
TLtuVKxWRI9LwNqpNyyO2QJf3ubcTWv5BD92takgC8JXvN233Gk3eLAWzFnHLE2l
98lSXdjVLl3UX2FR2ZUFBv4BQWDbR0QCr0hLRNUmNzeAZNtW44qF5E7NJeBRtlaK
MOSdRivJOurHR33iTfueNz0=
-----END PRIVATE KEY-----`;
describe("SslService", () => {
let service: SslService;
beforeEach(async () => {
jest.resetAllMocks();
(dns.lookup as jest.Mock).mockResolvedValue([
{ address: "93.184.216.34", family: 4 },
]);
(fs.existsSync as jest.Mock).mockReturnValue(true);
(fs.mkdirSync as jest.Mock).mockReturnValue(undefined);
const module: TestingModule = await Test.createTestingModule({
providers: [SslService],
}).compile();
service = module.get<SslService>(SslService);
jest.clearAllMocks();
});
it("should be defined", () => {
expect(service).toBeDefined();
});
describe("security regressions", () => {
it("rejects mismatched certificate/private key before any filesystem changes", () => {
const otherKey = crypto
.generateKeyPairSync("rsa", { modulusLength: 2048 })
.privateKey.export({ type: "pkcs8", format: "pem" })
.toString();
expect(() => service.updateCertificates(VALID_CERT, otherKey)).toThrow(
BadRequestException,
);
expect(fs.writeFileSync).not.toHaveBeenCalled();
});
it.each([
"127.0.0.1",
"10.0.0.1",
"172.16.0.1",
"192.168.0.1",
"169.254.169.254",
"100.64.0.1",
"::1",
"fc00::1",
"::ffff:127.0.0.1",
"2001:db8::1",
])("blocks DNS resolving to %s", async (address) => {
(dns.lookup as jest.Mock).mockResolvedValue([
{ address, family: address.includes(":") ? 6 : 4 },
]);
(tls.connect as jest.Mock).mockImplementation(() => {
throw new Error("unexpected TLS");
});
const result = await service.testOnlineDomainSsl("canina.ir");
expect(result.onlineCheck).toBe(false);
expect(tls.connect).not.toHaveBeenCalled();
});
it("rejects a mixed public/private DNS answer without opening TLS", async () => {
(dns.lookup as jest.Mock).mockResolvedValue([
{ address: "93.184.216.34", family: 4 },
{ address: "10.0.0.1", family: 4 },
]);
expect(await service.testOnlineDomainSsl("canina.ir")).toMatchObject({
onlineCheck: false,
});
expect(tls.connect).not.toHaveBeenCalled();
});
it("fails closed on DNS failure", async () => {
(dns.lookup as jest.Mock).mockRejectedValue(new Error("DNS offline"));
expect(await service.testOnlineDomainSsl("canina.ir")).toMatchObject({
onlineCheck: false,
});
expect(tls.connect).not.toHaveBeenCalled();
});
it("restores old certificate after private key rename fails", () => {
(fs.readFileSync as jest.Mock).mockReturnValue(VALID_CERT);
(fs.renameSync as jest.Mock).mockImplementation(
(from: string, to: string) => {
if (to.endsWith("privateKey.pem") && from.endsWith(".tmp"))
throw new Error("rename failed");
},
);
expect(() => service.updateCertificates(VALID_CERT, VALID_KEY)).toThrow(
"rename failed",
);
expect(fs.renameSync).toHaveBeenCalledWith(
expect.stringMatching(/fullchain\.pem\.bak$/),
expect.stringMatching(/fullchain\.pem$/),
);
});
});
describe("getStatus", () => {
it("should return { exists: false } if certificate file does not exist", () => {
(fs.existsSync as jest.Mock).mockReturnValue(false);
const status = service.getStatus();
expect(status).toEqual({ exists: false });
});
it("should parse real X509 certificate and return details if cert exists", () => {
(fs.existsSync as jest.Mock).mockReturnValue(true);
(fs.readFileSync as jest.Mock).mockReturnValue(VALID_CERT);
const status = service.getStatus();
expect(status.exists).toBe(true);
expect(status.subject).toContain("canina.ir");
expect(status.issuer).toContain("canina.ir");
expect(status.domains).toContain("canina.ir");
expect(status.domains).toContain("www.canina.ir");
expect(status.isExpired).toBeDefined();
expect(status.fingerprint).toBeDefined();
expect(status.serialNumber).toBeDefined();
});
it("should return { exists: false } if parsing fails", () => {
(fs.existsSync as jest.Mock).mockReturnValue(true);
(fs.readFileSync as jest.Mock).mockReturnValue("INVALID_PEM_CONTENT");
const status = service.getStatus();
expect(status).toEqual({ exists: false });
});
});
describe("updateCertificates", () => {
it("should throw BadRequestException if cert or key content is empty", () => {
expect(() => service.updateCertificates("", VALID_KEY)).toThrow(
BadRequestException,
);
expect(() => service.updateCertificates(VALID_CERT, "")).toThrow(
BadRequestException,
);
});
it("should throw BadRequestException if cert format is invalid", () => {
expect(() =>
service.updateCertificates("BAD_CERT_HEADER", VALID_KEY),
).toThrow(/فرمت گواهی نامعتبر است/);
});
it("should throw BadRequestException if private key format is invalid", () => {
expect(() =>
service.updateCertificates(VALID_CERT, "BAD_KEY_CONTENT"),
).toThrow(/فرمت کلید خصوصی نامعتبر است/);
});
it("should backup old certs and write new cert and key files", () => {
(fs.existsSync as jest.Mock).mockReturnValue(true);
(fs.copyFileSync as jest.Mock).mockReturnValue(undefined);
(fs.writeFileSync as jest.Mock).mockReturnValue(undefined);
(fs.readFileSync as jest.Mock).mockReturnValue(VALID_CERT);
const res = service.updateCertificates(VALID_CERT, VALID_KEY);
expect(fs.copyFileSync).toHaveBeenCalledTimes(2);
expect(fs.writeFileSync).toHaveBeenCalledTimes(2);
expect(res.success).toBe(true);
expect(res.message).toContain("با موفقیت به‌روزرسانی");
expect(res.status.exists).toBe(true);
});
});
describe("safety boundaries", () => {
it.each([
"",
"127.0.0.1",
"[::1]",
"service.internal",
"x.local",
"canina.ir:443",
"user@canina.ir",
"canina.ir?host=internal",
])("rejects unsafe target %p before opening a socket", async (domain) => {
expect(await service.testOnlineDomainSsl(domain)).toMatchObject({
onlineCheck: false,
});
expect(tls.connect).not.toHaveBeenCalled();
});
it.each([
[" ", VALID_KEY],
[VALID_CERT, " "],
["invalid", VALID_KEY],
[VALID_CERT, "invalid"],
])("never backs up or writes files on invalid input", (cert, key) => {
expect(() => service.updateCertificates(cert, key)).toThrow(
BadRequestException,
);
expect(fs.copyFileSync).not.toHaveBeenCalled();
expect(fs.writeFileSync).not.toHaveBeenCalled();
});
it("propagates certificate write failure without overwriting the private key", () => {
const error = new Error("disk full");
(fs.writeFileSync as jest.Mock).mockImplementation(() => {
throw error;
});
expect(() => service.updateCertificates(VALID_CERT, VALID_KEY)).toThrow(
error,
);
expect(fs.writeFileSync).toHaveBeenCalledTimes(1);
expect(fs.writeFileSync).toHaveBeenCalledWith(
expect.stringMatching(/fullchain\.pem\..*\.tmp$/),
VALID_CERT.trim(),
{ encoding: "utf8", mode: 0o600, flag: "wx" },
);
});
it("reports untrusted peer certificates as unauthorized", async () => {
const socket = Object.assign(new EventEmitter(), {
authorized: false,
end: jest.fn(),
getPeerCertificate: jest.fn().mockReturnValue({
valid_to: "2030-01-01T00:00:00.000Z",
issuer: { CN: "Untrusted CA" },
subject: { CN: "canina.ir" },
}),
});
(tls.connect as jest.Mock).mockImplementation((_options, callback) => {
process.nextTick(callback);
return socket;
});
expect(await service.testOnlineDomainSsl("canina.ir")).toMatchObject({
onlineCheck: true,
authorized: false,
issuer: "Untrusted CA",
});
expect(tls.connect).toHaveBeenCalledWith(
expect.objectContaining({
host: "93.184.216.34",
servername: "canina.ir",
port: 443,
timeout: 5000,
}),
expect.any(Function),
);
expect(socket.end).toHaveBeenCalledTimes(1);
});
});
describe("testOnlineDomainSsl", () => {
it("should reject invalid domains, IP addresses, or internal hosts", async () => {
const res1 = await service.testOnlineDomainSsl("localhost");
expect(res1.onlineCheck).toBe(false);
expect(res1.error).toContain("فرمت نام دامنه نامعتبر است");
const res2 = await service.testOnlineDomainSsl("192.168.1.1");
expect(res2.onlineCheck).toBe(false);
const res3 = await service.testOnlineDomainSsl("internal.server.local");
expect(res3.onlineCheck).toBe(false);
const res4 = await service.testOnlineDomainSsl("invalid..domain");
expect(res4.onlineCheck).toBe(false);
});
it("should return certificate details upon successful TLS connection", async () => {
const fakeSocket: any = new EventEmitter();
fakeSocket.authorized = true;
fakeSocket.end = jest.fn();
fakeSocket.getPeerCertificate = jest.fn().mockReturnValue({
valid_to: new Date(Date.now() + 50000000).toISOString(),
issuer: { O: "Let's Encrypt" },
subject: { CN: "canina.ir" },
});
(tls.connect as jest.Mock).mockImplementation(
(options: any, callback?: any) => {
if (callback) {
process.nextTick(callback);
}
return fakeSocket;
},
);
const res = await service.testOnlineDomainSsl("https://canina.ir/path");
expect(res.onlineCheck).toBe(true);
expect(res.domain).toBe("canina.ir");
expect(res.issuer).toBe("Let's Encrypt");
expect(res.subject).toBe("canina.ir");
expect(fakeSocket.end).toHaveBeenCalled();
});
it("should return message if peer certificate is empty", async () => {
const fakeSocket: any = new EventEmitter();
fakeSocket.authorized = false;
fakeSocket.end = jest.fn();
fakeSocket.getPeerCertificate = jest.fn().mockReturnValue(null);
(tls.connect as jest.Mock).mockImplementation(
(options: any, callback?: any) => {
if (callback) {
process.nextTick(callback);
}
return fakeSocket;
},
);
const res = await service.testOnlineDomainSsl("canina.ir");
expect(res.onlineCheck).toBe(false);
expect(res.message).toContain(
"گواهی SSL بر روی پورت ۴۴۳ این دامنه یافت نشد",
);
});
it("should handle socket connection error gracefully", async () => {
const fakeSocket: any = new EventEmitter();
fakeSocket.end = jest.fn();
(tls.connect as jest.Mock).mockImplementation(
(options: any, callback?: any) => {
process.nextTick(() => {
fakeSocket.emit("error", new Error("Connection refused"));
});
return fakeSocket;
},
);
const res = await service.testOnlineDomainSsl("canina.ir");
expect(res.onlineCheck).toBe(false);
expect(res.error).toBe("Connection refused");
});
it("should handle socket timeout gracefully", async () => {
const fakeSocket: any = new EventEmitter();
fakeSocket.destroy = jest.fn();
(tls.connect as jest.Mock).mockImplementation(
(options: any, callback?: any) => {
process.nextTick(() => {
fakeSocket.emit("timeout");
});
return fakeSocket;
},
);
const res = await service.testOnlineDomainSsl("canina.ir");
expect(res.onlineCheck).toBe(false);
expect(res.error).toContain("مهلت اتصال (Timeout)");
expect(fakeSocket.destroy).toHaveBeenCalled();
});
});
});