@jjlmoya/utils-developer 1.2.0

package/src/tool/hashGenerator/i18n/fr.ts

@@ -0,0 +1,118 @@
+import type { WithContext, FAQPage, HowToThing, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { HashGeneratorUI } from '../ui';
+
+const slug = 'generateur-hashes';
+const title = 'G\u00e9n\u00e9rateur de Hashes de S\u00e9curit\u00e9 en Ligne';
+const description = 'Calculez des hashes MD5, SHA-1, SHA-256 et SHA-512 instantan\u00e9ment. Outil de s\u00e9curit\u00e9 gratuit, priv\u00e9 et ultra-rapide pour les d\u00e9veloppeurs. 100% C\u00f4t\u00e9 Client.';
+
+const faqData = [
+  {
+    question: "Qu'est-ce qu'un hash et \u00e0 quoi sert-il?",
+    answer: "Un hash est une empreinte num\u00e9rique unique d'un texte ou d'un fichier. Il sert \u00e0 v\u00e9rifier que les donn\u00e9es n'ont pas \u00e9t\u00e9 alt\u00e9r\u00e9es et \u00e0 stocker les mots de passe de mani\u00e8re s\u00e9curis\u00e9e.",
+  },
+  {
+    question: 'Est-il s\u00fbr d\'utiliser ce g\u00e9n\u00e9rateur en ligne?',
+    answer: 'Oui, c\'est totalement s\u00fbr. Contrairement \u00e0 d\'autres sites, nous traitons le hash directement dans votre navigateur. Vos donn\u00e9es ne sont jamais envoy\u00e9es \u00e0 aucun serveur.',
+  },
+  {
+    question: 'Quel algorithme de hash devrais-je choisir?',
+    answer: 'Pour la s\u00e9curit\u00e9 moderne et le stockage de cl\u00e9s, nous recommandons SHA-256 ou SHA-512. MD5 et SHA-1 ne doivent \u00eatre utilis\u00e9s que pour la compatibilit\u00e9 avec les syst\u00e8mes h\u00e9rit\u00e9s.',
+  },
+  {
+    question: "Que signifie ajouter un 'Salt'?",
+    answer: "Un Salt est une cha\u00eene suppl\u00e9mentaire m\u00e9lang\u00e9e \u00e0 votre texte pour rendre le hash unique et beaucoup plus difficile \u00e0 d\u00e9chiffrer par des attaques par dictionnaire.",
+  },
+];
+
+const howToData = [
+  { name: 'Saisir le texte', text: 'Tapez ou collez le texte que vous souhaitez hacher dans le champ de saisie.' },
+  { name: 'Configurer la s\u00e9curit\u00e9', text: 'Ajoutez un Salt optionnel ou augmentez les tours de traitement pour plus de robustesse.' },
+  { name: 'Obtenir les r\u00e9sultats', text: 'Les diff\u00e9rents hashes (MD5, SHA etc.) sont calcul\u00e9s en temps r\u00e9el pendant que vous tapez.' },
+  { name: 'Copier le hash', text: "Cliquez sur l'ic\u00f4ne de copie \u00e0 c\u00f4t\u00e9 de chaque algorithme pour le sauvegarder dans votre presse-papiers." },
+];
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faqData.map((item) => ({
+    '@type': 'Question',
+    name: item.question,
+    acceptedAnswer: { '@type': 'Answer', text: item.answer },
+  })),
+};
+
+const howToSchema: WithContext<HowToThing> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: title,
+  description,
+  step: howToData.map((s, i) => ({ '@type': 'HowToStep', position: i + 1, name: s.name, text: s.text })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: title,
+  description,
+  applicationCategory: 'UtilityApplication',
+  operatingSystem: 'All',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+  inLanguage: 'fr',
+};
+
+const ui: HashGeneratorUI = {
+  labelInput: 'Texte d\'entr\u00e9e',
+  placeholderInput: 'Tapez ou collez le texte ici pour calculer ses hashes...',
+  labelSalt: 'Salt (Optionnel)',
+  placeholderSalt: 'Graine de s\u00e9curit\u00e9...',
+  labelRounds: 'Tours (Stretch)',
+  copyMd5: 'Copier MD5',
+  copySha1: 'Copier SHA-1',
+  copySha256: 'Copier SHA-256',
+  copySha512: 'Copier SHA-512',
+};
+
+export const content: ToolLocaleContent<HashGeneratorUI> = {
+  slug,
+  title,
+  description,
+  ui,
+  faqTitle: 'Questions Fr\u00e9quentes',
+  faq: faqData,
+  bibliographyTitle: 'Ressources Techniques sur le Hachage',
+  bibliography: [
+    { name: 'MDN Web Docs: SubtleCrypto.digest() API', url: 'https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/digest' },
+    { name: 'NIST: FIPS 180-4 Secure Hash Standard (SHA)', url: 'https://csrc.nist.gov/publications/detail/fips/180/4/final' },
+    { name: 'IETF: The MD5 Message-Digest Algorithm (RFC 1321)', url: 'https://datatracker.ietf.org/doc/html/rfc1321' },
+  ],
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    { type: 'title', text: "Qu'est-ce qu'un Hash Cryptographique?", level: 2 },
+    {
+      type: 'paragraph',
+      html: 'Un <strong>hash cryptographique</strong> est une fonction math\u00e9matique qui transforme n\'importe quelle quantit\u00e9 de donn\u00e9es en une cha\u00eene de longueur fixe. La m\u00eame entr\u00e9e produit toujours le m\u00eame r\u00e9sultat, mais tout changement minimal dans l\'entr\u00e9e g\u00e9n\u00e8re un hash compl\u00e8tement diff\u00e9rent.',
+    },
+    { type: 'title', text: 'Algorithmes disponibles', level: 3 },
+    {
+      type: 'list',
+      items: [
+        '<strong>MD5 (128 bits):</strong> Rapide et largement support\u00e9. Consid\u00e9r\u00e9 non s\u00e9curis\u00e9 pour les mots de passe mais utile pour v\u00e9rifier l\'int\u00e9grit\u00e9 des fichiers dans des environnements non critiques.',
+        '<strong>SHA-1 (160 bits):</strong> D\u00e9pr\u00e9ci\u00e9 pour les usages critiques de s\u00e9curit\u00e9 depuis 2017. Encore pr\u00e9sent dans les syst\u00e8mes h\u00e9rit\u00e9s.',
+        '<strong>SHA-256 (256 bits):</strong> La norme actuelle pour la plupart des applications. Utilis\u00e9 dans Bitcoin, TLS et la signature de code.',
+        '<strong>SHA-512 (512 bits):</strong> Variante plus longue de SHA-2, id\u00e9ale lorsqu\'une r\u00e9sistance maximale aux collisions est requise.',
+      ],
+    },
+    { type: 'title', text: 'Salt et Key Stretching', level: 3 },
+    {
+      type: 'paragraph',
+      html: 'Le <strong>Salt</strong> est une cha\u00eene al\u00e9atoire ajout\u00e9e au texte avant de le hacher, garantissant que deux entr\u00e9es identiques produisent des hashes diff\u00e9rents. Le <strong>Key Stretching</strong> (tours) applique la fonction de hachage plusieurs fois pour rendre les attaques par force brute plus difficiles.',
+    },
+    { type: 'title', text: 'Confidentialit\u00e9 totale: 100% C\u00f4t\u00e9 Client', level: 3 },
+    {
+      type: 'paragraph',
+      html: 'Cet outil utilise l\'<strong>API Web Crypto</strong> du navigateur pour SHA et une impl\u00e9mentation TypeScript pure pour MD5. Tout le traitement se fait localement: vos donn\u00e9es ne quittent jamais votre appareil.',
+    },
+  ],
+};

package/src/tool/hashGenerator/index.ts

@@ -0,0 +1,33 @@
+import type { DeveloperToolEntry, ToolLocaleContent, ToolDefinition } from '../../types';
+import HashGeneratorComponent from './component.astro';
+import HashGeneratorSEO from './seo.astro';
+import HashGeneratorBibliography from './bibliography.astro';
+import type { HashGeneratorUI } from './ui';
+
+export type HashGeneratorLocaleContent = ToolLocaleContent<HashGeneratorUI>;
+
+import { content as es } from './i18n/es';
+import { content as en } from './i18n/en';
+import { content as fr } from './i18n/fr';
+
+export const hashGenerator: DeveloperToolEntry<HashGeneratorUI> = {
+  id: 'hash-generator',
+  icons: {
+    bg: 'mdi:shield-lock',
+    fg: 'mdi:pound',
+  },
+  i18n: {
+    es: async () => es,
+    en: async () => en,
+    fr: async () => fr,
+  },
+};
+
+export { HashGeneratorComponent, HashGeneratorSEO, HashGeneratorBibliography };
+
+export const HASH_GENERATOR_TOOL: ToolDefinition = {
+  entry: hashGenerator,
+  Component: HashGeneratorComponent,
+  SEOComponent: HashGeneratorSEO,
+  BibliographyComponent: HashGeneratorBibliography,
+};

package/src/tool/hashGenerator/md5.ts

@@ -0,0 +1,138 @@
+type Fn3 = (y: number, z: number, w: number) => number;
+type StepArgs = [number, number, number];
+interface Md5State { a: number; b: number; c: number; d: number; }
+
+const F: Fn3 = (y, z, w) => (y & z) | (~y & w);
+const G: Fn3 = (y, z, w) => (y & w) | (z & ~w);
+const H: Fn3 = (y, z, w) => y ^ z ^ w;
+const I: Fn3 = (y, z, w) => z ^ (y | ~w);
+
+function rotL(n: number, s: number): number {
+  return (n << s) | (n >>> (32 - s));
+}
+
+function step(s: Md5State, fn: Fn3, args: StepArgs): Md5State {
+  const [x, sh, k] = args;
+  const v = rotL((s.a + fn(s.b, s.c, s.d) + x + k) | 0, sh) + s.b;
+  return { a: s.d, b: v, c: s.b, d: s.c };
+}
+
+function round1(s: Md5State, x: number[]): Md5State {
+  s = step(s, F, [x[0], 7, -680876936]);
+  s = step(s, F, [x[1], 12, -389564586]);
+  s = step(s, F, [x[2], 17, 606105819]);
+  s = step(s, F, [x[3], 22, -1044525330]);
+  s = step(s, F, [x[4], 7, -176418897]);
+  s = step(s, F, [x[5], 12, 1200080426]);
+  s = step(s, F, [x[6], 17, -1473231341]);
+  s = step(s, F, [x[7], 22, -45705983]);
+  s = step(s, F, [x[8], 7, 1770035416]);
+  s = step(s, F, [x[9], 12, -1958414417]);
+  s = step(s, F, [x[10], 17, -42063]);
+  s = step(s, F, [x[11], 22, -1990404162]);
+  s = step(s, F, [x[12], 7, 1804603682]);
+  s = step(s, F, [x[13], 12, -40341101]);
+  s = step(s, F, [x[14], 17, -1502002290]);
+  s = step(s, F, [x[15], 22, 1236535329]);
+  return s;
+}
+
+function round2(s: Md5State, x: number[]): Md5State {
+  s = step(s, G, [x[1], 5, -165796510]);
+  s = step(s, G, [x[6], 9, -1069501632]);
+  s = step(s, G, [x[11], 14, 643717713]);
+  s = step(s, G, [x[0], 20, -373897302]);
+  s = step(s, G, [x[5], 5, -701558691]);
+  s = step(s, G, [x[10], 9, 38016083]);
+  s = step(s, G, [x[15], 14, -660478335]);
+  s = step(s, G, [x[4], 20, -405537848]);
+  s = step(s, G, [x[9], 5, 568446438]);
+  s = step(s, G, [x[14], 9, -1019803690]);
+  s = step(s, G, [x[3], 14, -187363961]);
+  s = step(s, G, [x[8], 20, 1163531501]);
+  s = step(s, G, [x[13], 5, -1444681467]);
+  s = step(s, G, [x[2], 9, -51403784]);
+  s = step(s, G, [x[7], 14, 1735328473]);
+  s = step(s, G, [x[12], 20, -1926607734]);
+  return s;
+}
+
+function round3(s: Md5State, x: number[]): Md5State {
+  s = step(s, H, [x[5], 4, -378558]);
+  s = step(s, H, [x[8], 11, -2022574463]);
+  s = step(s, H, [x[11], 16, 1839030562]);
+  s = step(s, H, [x[14], 23, -35309556]);
+  s = step(s, H, [x[1], 4, -1530992060]);
+  s = step(s, H, [x[4], 11, 1272893353]);
+  s = step(s, H, [x[7], 16, -155497632]);
+  s = step(s, H, [x[10], 23, -1094730640]);
+  s = step(s, H, [x[13], 4, 681279174]);
+  s = step(s, H, [x[0], 11, -358537222]);
+  s = step(s, H, [x[3], 16, -722521979]);
+  s = step(s, H, [x[6], 23, 76029189]);
+  s = step(s, H, [x[9], 4, -640364487]);
+  s = step(s, H, [x[12], 11, -421815835]);
+  s = step(s, H, [x[15], 16, 530742520]);
+  s = step(s, H, [x[2], 23, -995338651]);
+  return s;
+}
+
+function round4(s: Md5State, x: number[]): Md5State {
+  s = step(s, I, [x[0], 6, -198630844]);
+  s = step(s, I, [x[7], 10, 1126891415]);
+  s = step(s, I, [x[14], 15, -1416354905]);
+  s = step(s, I, [x[5], 21, -57434055]);
+  s = step(s, I, [x[12], 6, 1700485571]);
+  s = step(s, I, [x[3], 10, -1894986606]);
+  s = step(s, I, [x[10], 15, -1051523]);
+  s = step(s, I, [x[1], 21, -2054922799]);
+  s = step(s, I, [x[8], 6, 1873313359]);
+  s = step(s, I, [x[15], 10, -30611744]);
+  s = step(s, I, [x[6], 15, -1560198380]);
+  s = step(s, I, [x[13], 21, 1309151649]);
+  s = step(s, I, [x[4], 6, -145523070]);
+  s = step(s, I, [x[11], 10, -1120210379]);
+  s = step(s, I, [x[2], 15, 718787280]);
+  s = step(s, I, [x[9], 21, -343485551]);
+  return s;
+}
+
+function prepareInput(str: string): number[] {
+  const x: number[] = [];
+  const bytes = Array.from(new TextEncoder().encode(str));
+  for (let i = 0; i < bytes.length; i++) {
+    x[i >> 2] |= bytes[i] << ((i % 4) * 8);
+  }
+  x[bytes.length >> 2] |= 0x80 << ((bytes.length % 4) * 8);
+  x[(((bytes.length + 8) >> 6) << 4) + 14] = bytes.length * 8;
+  return x;
+}
+
+function processBlock(init: Md5State, x: number[]): Md5State {
+  let s = round1(init, x);
+  s = round2(s, x);
+  s = round3(s, x);
+  s = round4(s, x);
+  return { a: (s.a + init.a) | 0, b: (s.b + init.b) | 0, c: (s.c + init.c) | 0, d: (s.d + init.d) | 0 };
+}
+
+function stateToHex(state: Md5State): string {
+  const hexChars = '0123456789abcdef';
+  const vals = [state.a, state.b, state.c, state.d];
+  let hex = '';
+  for (const n of vals) {
+    for (let j = 0; j < 4; j++) {
+      hex += hexChars[(n >> (j * 8 + 4)) & 0x0f] + hexChars[(n >> (j * 8)) & 0x0f];
+    }
+  }
+  return hex;
+}
+
+export function md5(str: string): string {
+  const x = prepareInput(str);
+  let state: Md5State = { a: 1732584193, b: -271733879, c: -1732584194, d: 271733878 };
+  for (let i = 0; i < x.length; i += 16) {
+    state = processBlock(state, x.slice(i, i + 16));
+  }
+  return stateToHex(state);
+}

package/src/tool/hashGenerator/seo.astro

@@ -0,0 +1,14 @@
+---
+import { SEORenderer } from '@jjlmoya/utils-shared';
+import { hashGenerator } from './index';
+import type { KnownLocale } from '../../types';
+
+interface Props {
+  locale?: KnownLocale;
+}
+
+const { locale = 'es' } = Astro.props;
+const content = await hashGenerator.i18n[locale]?.();
+---
+
+{content && <SEORenderer content={{ locale, sections: content.seo }} />}

package/src/tool/hashGenerator/ui.ts

@@ -0,0 +1,11 @@
+export interface HashGeneratorUI extends Record<string, string> {
+  labelInput: string;
+  placeholderInput: string;
+  labelSalt: string;
+  placeholderSalt: string;
+  labelRounds: string;
+  copyMd5: string;
+  copySha1: string;
+  copySha256: string;
+  copySha512: string;
+}

package/src/tool/inspectorCertificadosSsl/bibliography.astro

@@ -0,0 +1,14 @@
+---
+import { Bibliography as SharedBibliography } from '@jjlmoya/utils-shared';
+import { inspectorCertificadosSsl } from './index';
+import type { KnownLocale } from '../../types';
+
+interface Props {
+  locale?: KnownLocale;
+}
+
+const { locale = 'es' } = Astro.props;
+const content = await inspectorCertificadosSsl.i18n[locale]?.();
+---
+
+{content && <SharedBibliography links={content.bibliography} />}