@growy/strapi-plugin-encrypted-field 1.0.0

package/README.md

@@ -0,0 +1,248 @@
+# Strapi Plugin - Encrypted Field
+
+<div align="center">
+  <img src="https://img.shields.io/npm/v/@growy/strapi-plugin-encrypted-field" alt="npm version" />
+  <img src="https://img.shields.io/npm/l/@growy/strapi-plugin-encrypted-field" alt="license" />
+  <img src="https://img.shields.io/badge/Strapi-v5-blueviolet" alt="Strapi v5" />
+</div>
+
+Plugin oficial de **Growy AI** para Strapi que proporciona un campo personalizado de texto cifrado con AES-256-GCM. Protege información sensible directamente en tu base de datos con cifrado transparente y validación robusta.
+
+## Características
+
+- ✅ **Campo personalizado** "Texto Cifrado" en el Content-Type Builder
+- ✅ **Cifrado automático** AES-256-GCM al guardar
+- ✅ **Descifrado transparente** al leer (panel y API)
+- ✅ **Validación backend** con soporte para regex y restricciones
+- ✅ **UI mejorada** con controles de visibilidad, copiar y contador de caracteres
+- ✅ **Gestión de claves robusta** con validación y mensajes de error claros
+- ✅ **Datos cifrados** en base de datos con IV único y Auth Tag
+- ✅ **Reutilizable** en cualquier colección o componente
+
+## Instalación
+
+### Desde npm
+
+```bash
+npm install @growy/strapi-plugin-encrypted-field
+```
+
+### Desde yarn
+
+```bash
+yarn add @growy/strapi-plugin-encrypted-field
+```
+
+## Configuración
+
+### 1. Habilitar el plugin
+
+Crea o edita `config/plugins.js` o `config/plugins.ts`:
+
+```javascript
+module.exports = {
+  'encrypted-field': {
+    enabled: true,
+  },
+};
+```
+
+### 2. Configurar la clave de cifrado (REQUERIDO)
+
+#### Opción A: Variable de entorno (recomendado)
+
+Agrega a tu `.env`:
+
+```bash
+ENCRYPTION_KEY=tu_clave_de_64_caracteres_hexadecimales_aqui
+```
+
+#### Opción B: Archivo de configuración
+
+Edita `config/plugins.js`:
+
+```javascript
+module.exports = ({ env }) => ({
+  'encrypted-field': {
+    enabled: true,
+    config: {
+      encryptionKey: env('ENCRYPTION_KEY'),
+    },
+  },
+});
+```
+
+#### Generar clave segura
+
+```bash
+node -e "console.log(require('crypto').randomBytes(32).toString('hex'))"
+```
+
+Esto generará una clave de 64 caracteres hexadecimales (32 bytes).
+
+⚠️ **CRÍTICO - Gestión de claves**:
+- **Guarda la clave de forma segura** (gestor de secretos, variables de entorno cifradas)
+- **Nunca** la incluyas en el control de versiones
+- **Si pierdes la clave**, no podrás descifrar los datos existentes
+- **Usa la misma clave** en todos los entornos que compartan la misma base de datos
+- **Para producción**, considera usar servicios como AWS Secrets Manager, HashiCorp Vault o similar
+
+### 3. Rebuild del admin
+
+```bash
+npm run build
+npm run develop
+```
+
+## Requisitos
+
+- **Strapi**: v5.0.0 o superior
+- **Node.js**: 18.x - 22.x
+- **npm**: 6.0.0 o superior
+
+## Validación de datos
+
+El plugin soporta validación antes del cifrado:
+
+### Configurar validación regex
+
+1. En el Content-Type Builder, selecciona el campo cifrado
+2. Ve a la pestaña **"Advanced Settings"**
+3. En **"RegEx pattern"**, ingresa tu expresión regular
+4. Guarda los cambios
+
+**Ejemplo**: Para validar formato de API key:
+```regex
+^sk-[a-zA-Z0-9]{32}$
+```
+
+Si el valor no cumple con el patrón, se lanzará un error antes de cifrar.
+
+## Uso
+
+### 1. Agregar campo cifrado a una colección
+
+1. Ve a **Content-Type Builder**
+2. Selecciona una colección o crea una nueva
+3. Click en **"Add another field"**
+4. Busca **"Texto Cifrado"** (con icono 🔒)
+5. Configura el nombre del campo
+6. Guarda y reinicia Strapi
+
+### 2. Usar el campo
+
+El campo funciona como un campo de texto normal:
+
+- **En el panel**: Escribe texto normalmente
+- **Al guardar**: Se cifra automáticamente
+- **Al leer**: Se descifra automáticamente
+- **En la BD**: Se guarda cifrado con formato `iv:authTag:encrypted`
+
+### 3. Uso por API
+
+```bash
+# Crear con campo cifrado
+curl -X POST http://localhost:1337/api/usuarios \
+  -H "Content-Type: application/json" \
+  -d '{
+    "data": {
+      "nombre": "Juan",
+      "apiKey": "mi-clave-secreta-123"
+    }
+  }'
+
+# Leer (devuelve descifrado)
+curl -X GET http://localhost:1337/api/usuarios/1
+# Response: { "nombre": "Juan", "apiKey": "mi-clave-secreta-123" }
+```
+
+## Ejemplo de uso
+
+### Colección "Usuario" con API Key cifrada
+
+**Schema:**
+```json
+{
+  "nombre": "string",
+  "email": "email",
+  "apiKey": "plugin::encrypted-field.encrypted-text"
+}
+```
+
+**En la BD:**
+```
+apiKey: "a1b2c3d4e5f6....:f9e8d7c6b5a4....:9f8e7d6c5b4a3..."
+```
+
+**En el panel y API:**
+```
+apiKey: "sk-1234567890abcdef"
+```
+
+## Seguridad y arquitectura
+
+### Especificaciones técnicas
+
+- **Algoritmo**: AES-256-GCM (estándar NIST, grado militar)
+- **Tamaño de clave**: 256 bits (32 bytes, 64 caracteres hexadecimales)
+- **IV (Initialization Vector)**: 96 bits (12 bytes) generado aleatoriamente por operación
+- **Auth Tag**: 128 bits (16 bytes) para verificación de integridad
+- **Formato almacenado**: `iv:authTag:encryptedData` (todos en hexadecimal)
+
+### Características de seguridad
+
+- ✅ **Cifrado autenticado**: GCM proporciona confidencialidad e integridad
+- ✅ **IV único**: Cada operación de cifrado genera un IV aleatorio
+- ✅ **Resistencia a manipulación**: Auth Tag detecta cualquier modificación
+- ✅ **Validación de entrada**: Soporte para regex y restricciones personalizadas
+- ✅ **Manejo de errores seguro**: Logs controlados sin exponer datos sensibles
+
+### Mejores prácticas
+
+1. **Rotación de claves**: Planifica un proceso de rotación periódica
+2. **Separación de entornos**: Usa claves diferentes para dev/staging/prod
+3. **Auditoría**: Monitorea logs de errores de cifrado/descifrado
+4. **Backup de claves**: Mantén copias seguras de las claves en múltiples ubicaciones
+5. **Campos privados**: Marca campos sensibles como "privados" para excluirlos de la API pública
+
+## Casos de uso
+
+- 🔑 API Keys de terceros
+- 🔐 Tokens de acceso
+- 🔒 Secretos de webhooks
+- 💳 Información sensible
+- 📧 Credenciales SMTP
+- 🔑 Contraseñas de aplicaciones
+
+## Limitaciones conocidas
+
+- ❌ **Búsqueda**: No se puede buscar por campos cifrados (datos cifrados en BD)
+- ❌ **Ordenamiento**: No se puede ordenar por campos cifrados
+- ❌ **Filtros**: No se pueden aplicar filtros directos sobre campos cifrados
+- ⚠️ **Rendimiento**: El cifrado/descifrado añade overhead mínimo (~1-2ms por operación)
+- ⚠️ **Sincronización de claves**: Todos los entornos que compartan BD deben usar la misma clave
+
+## Soporte
+
+Para reportar bugs, solicitar funcionalidades o contribuir:
+
+- **Issues**: [GitHub Issues](https://github.com/growy-ai/strapi-plugin-encrypted-field/issues)
+- **Documentación**: [README.md](https://github.com/growy-ai/strapi-plugin-encrypted-field)
+- **Email**: support@growy.ai
+
+## Licencia
+
+MIT © 2025 Growy AI
+
+## Desarrollado por
+
+**Growy AI** - Soluciones de IA y automatización empresarial
+
+**Autor principal**: Zahir El isaac
+
+---
+
+<div align="center">
+  <p>Si este plugin te resulta útil, considera darle una ⭐ en GitHub</p>
+  <p>Hecho con ❤️ por el equipo de Growy AI</p>
+</div>

package/admin/src/components/Input.jsx

@@ -0,0 +1,92 @@
+import React, { useState } from 'react';
+import { useIntl } from 'react-intl';
+import { Field, Flex, IconButton, Typography } from '@strapi/design-system';
+import { Eye, EyeStriked, Duplicate, Check } from '@strapi/icons';
+
+const Input = ({
+  attribute,
+  description,
+  disabled,
+  error,
+  intlLabel,
+  labelAction,
+  name,
+  onChange,
+  required,
+  value,
+}) => {
+  const { formatMessage } = useIntl();
+  const [showValue, setShowValue] = useState(false);
+  const [copied, setCopied] = useState(false);
+
+  const handleCopy = async () => {
+    if (value) {
+      try {
+        await navigator.clipboard.writeText(value);
+        setCopied(true);
+        setTimeout(() => setCopied(false), 2000);
+      } catch (err) {
+        console.error('Error al copiar:', err);
+      }
+    }
+  };
+
+  const charCount = value ? value.length : 0;
+
+  return (
+    <Field.Root
+      name={name}
+      id={name}
+      error={error}
+      hint={description && formatMessage(description)}
+      required={required}
+    >
+      <Flex justifyContent="space-between" alignItems="center">
+        <Field.Label action={labelAction}>
+          {formatMessage(intlLabel)} 🔒
+        </Field.Label>
+        <Flex gap={2}>
+          <IconButton
+            label={showValue ? 'Ocultar valor' : 'Mostrar valor'}
+            icon={showValue ? <EyeStriked /> : <Eye />}
+            onClick={() => setShowValue(!showValue)}
+            variant="ghost"
+            disabled={!value}
+          />
+          <IconButton
+            label={copied ? 'Copiado' : 'Copiar valor'}
+            icon={copied ? <Check /> : <Duplicate />}
+            onClick={handleCopy}
+            variant="ghost"
+            disabled={!value}
+          />
+        </Flex>
+      </Flex>
+      <Field.Input
+        type={showValue ? 'text' : 'password'}
+        placeholder={formatMessage({
+          id: 'encrypted-field.placeholder',
+          defaultMessage: 'Ingresa el texto a cifrar...',
+        })}
+        value={value || ''}
+        onChange={(e) => {
+          onChange({
+            target: { name, value: e.target.value, type: attribute.type },
+          });
+        }}
+        disabled={disabled}
+      />
+      <Flex justifyContent="space-between" alignItems="center" paddingTop={1}>
+        <Field.Hint />
+        {charCount > 0 && (
+          <Typography variant="pi" textColor="neutral600">
+            {charCount} {charCount === 1 ? 'carácter' : 'caracteres'}
+          </Typography>
+        )}
+      </Flex>
+      <Field.Error />
+    </Field.Root>
+  );
+};
+
+export default Input;

package/admin/src/index.js

@@ -0,0 +1,103 @@
+import Lock from '@strapi/icons/Lock';
+
+export default {
+  register(app) {
+    app.customFields.register({
+      name: 'encrypted-text',
+      pluginId: 'encrypted-field',
+      type: 'text',
+      intlLabel: {
+        id: 'encrypted-field.label',
+        defaultMessage: 'Texto Cifrado',
+      },
+      intlDescription: {
+        id: 'encrypted-field.description',
+        defaultMessage: 'Campo de texto que se cifra automáticamente con AES-256-GCM',
+      },
+      icon: Lock,
+      components: {
+        Input: async () => import('./components/Input.jsx'),
+      },
+      options: {
+        base: [
+          {
+            sectionTitle: {
+              id: 'encrypted-field.options.advanced.settings',
+              defaultMessage: 'Configuración',
+            },
+            items: [
+              {
+                name: 'required',
+                type: 'checkbox',
+                intlLabel: {
+                  id: 'encrypted-field.options.required.label',
+                  defaultMessage: 'Campo requerido',
+                },
+                description: {
+                  id: 'encrypted-field.options.required.description',
+                  defaultMessage: 'No se podrá guardar sin este campo',
+                },
+              },
+              {
+                name: 'private',
+                type: 'checkbox',
+                intlLabel: {
+                  id: 'encrypted-field.options.private.label',
+                  defaultMessage: 'Campo privado',
+                },
+                description: {
+                  id: 'encrypted-field.options.private.description',
+                  defaultMessage: 'Este campo no será devuelto por la API',
+                },
+              },
+            ],
+          },
+        ],
+        advanced: [
+          {
+            sectionTitle: {
+              id: 'encrypted-field.options.advanced.regex',
+              defaultMessage: 'Validación',
+            },
+            items: [
+              {
+                name: 'regex',
+                type: 'text',
+                intlLabel: {
+                  id: 'encrypted-field.options.regex.label',
+                  defaultMessage: 'RegEx pattern',
+                },
+                description: {
+                  id: 'encrypted-field.options.regex.description',
+                  defaultMessage: 'Patrón de validación antes de cifrar',
+                },
+              },
+            ],
+          },
+        ],
+      },
+    });
+  },
+
+  async registerTrads({ locales }) {
+    const importedTrads = await Promise.all(
+      locales.map((locale) => {
+        return import(`./translations/${locale}.json`)
+          .then(({ default: data }) => {
+            return {
+              data,
+              locale,
+            };
+          })
+          .catch(() => {
+            return {
+              data: {},
+              locale,
+            };
+          });
+      })
+    );
+
+    return Promise.resolve(importedTrads);
+  },
+};

package/admin/src/translations/en.json

@@ -0,0 +1,13 @@
+{
+  "encrypted-field.label": "Encrypted Text",
+  "encrypted-field.description": "Text field that is automatically encrypted with AES-256-GCM",
+  "encrypted-field.placeholder": "Enter text to encrypt...",
+  "encrypted-field.options.advanced.settings": "Settings",
+  "encrypted-field.options.required.label": "Required field",
+  "encrypted-field.options.required.description": "You won't be able to save without this field",
+  "encrypted-field.options.private.label": "Private field",
+  "encrypted-field.options.private.description": "This field will not be returned by the API",
+  "encrypted-field.options.advanced.regex": "Validation",
+  "encrypted-field.options.regex.label": "RegEx pattern",
+  "encrypted-field.options.regex.description": "Validation pattern before encryption"
+}

package/admin/src/translations/es.json

@@ -0,0 +1,13 @@
+{
+  "encrypted-field.label": "Texto Cifrado",
+  "encrypted-field.description": "Campo de texto que se cifra automáticamente con AES-256-GCM",
+  "encrypted-field.placeholder": "Ingresa el texto a cifrar...",
+  "encrypted-field.options.advanced.settings": "Configuración",
+  "encrypted-field.options.required.label": "Campo requerido",
+  "encrypted-field.options.required.description": "No se podrá guardar sin este campo",
+  "encrypted-field.options.private.label": "Campo privado",
+  "encrypted-field.options.private.description": "Este campo no será devuelto por la API",
+  "encrypted-field.options.advanced.regex": "Validación",
+  "encrypted-field.options.regex.label": "RegEx pattern",
+  "encrypted-field.options.regex.description": "Patrón de validación antes de cifrar"
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@growy/strapi-plugin-encrypted-field",
+  "version": "1.0.0",
+  "description": "Campo personalizado de texto cifrado para Strapi",
+  "strapi": {
+    "name": "encrypted-field",
+    "displayName": "Encrypted Field",
+    "description": "Agrega un campo de texto cifrado con AES-256-GCM",
+    "kind": "plugin"
+  },
+  "dependencies": {},
+  "peerDependencies": {
+    "@strapi/strapi": "^5.0.0"
+  },
+  "main": "server/index.js",
+  "author": {
+    "name": "Growy AI",
+    "email": "support@growy.ai",
+    "url": "https://getgrowy.ai"
+  },
+  "contributors": [
+    {
+      "name": "Zahir El isaac"
+    }
+  ],
+  "engines": {
+    "node": ">=18.0.0 <=22.x.x",
+    "npm": ">=6.0.0"
+  },
+  "license": "MIT",
+  "keywords": [
+    "strapi",
+    "strapi-plugin",
+    "encryption",
+    "aes-256-gcm",
+    "security",
+    "custom-field",
+    "encrypted-field",
+    "growy-ai",
+    "data-protection",
+    "cryptography",
+    "strapi-v5"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/server/bootstrap.js

@@ -0,0 +1,81 @@
+const { encrypt, decrypt, validateValue, isEncryptedField } = require('./utils/crypto');
+
+module.exports = ({ strapi }) => {
+  strapi.db.lifecycles.subscribe({
+    async beforeCreate(event) {
+      const { data } = event.params;
+      const model = strapi.getModel(event.model.uid);
+      
+      for (const [key, attribute] of Object.entries(model.attributes)) {
+        if (!isEncryptedField(attribute)) continue;
+        if (Object.prototype.hasOwnProperty.call(data, key)) {
+          const value = data[key];
+          if (value === null || value === undefined) continue;
+          
+          const validation = validateValue(value, attribute);
+          if (!validation.valid) {
+            throw new Error(`Validación fallida para el campo "${key}": ${validation.error}`);
+          }
+          
+          data[key] = encrypt(value, strapi);
+        }
+      }
+    },
+
+    async beforeUpdate(event) {
+      const { data } = event.params;
+      const model = strapi.getModel(event.model.uid);
+      
+      for (const [key, attribute] of Object.entries(model.attributes)) {
+        if (!isEncryptedField(attribute)) continue;
+        if (Object.prototype.hasOwnProperty.call(data, key)) {
+          const value = data[key];
+          if (value === null || value === undefined) continue;
+          
+          const validation = validateValue(value, attribute);
+          if (!validation.valid) {
+            throw new Error(`Validación fallida para el campo "${key}": ${validation.error}`);
+          }
+          
+          data[key] = encrypt(value, strapi);
+        }
+      }
+    },
+
+    async afterFindOne(event) {
+      const { result } = event;
+      if (!result) return;
+      
+      const model = strapi.getModel(event.model.uid);
+      
+      for (const [key, attribute] of Object.entries(model.attributes)) {
+        if (!isEncryptedField(attribute)) continue;
+        if (Object.prototype.hasOwnProperty.call(result, key)) {
+          const value = result[key];
+          if (typeof value === 'string') {
+            result[key] = decrypt(value, strapi);
+          }
+        }
+      }
+    },
+
+    async afterFindMany(event) {
+      const { result } = event;
+      if (!result || !Array.isArray(result)) return;
+      
+      const model = strapi.getModel(event.model.uid);
+      
+      for (const item of result) {
+        for (const [key, attribute] of Object.entries(model.attributes)) {
+          if (!isEncryptedField(attribute)) continue;
+          if (Object.prototype.hasOwnProperty.call(item, key)) {
+            const value = item[key];
+            if (typeof value === 'string') {
+              item[key] = decrypt(value, strapi);
+            }
+          }
+        }
+      }
+    },
+  });
+};

package/server/index.js

@@ -0,0 +1,7 @@
+const register = require('./register');
+const bootstrap = require('./bootstrap');
+
+module.exports = {
+  register,
+  bootstrap,
+};

package/server/register.js

@@ -0,0 +1,11 @@
+module.exports = ({ strapi }) => {
+  strapi.customFields.register({
+    name: 'encrypted-text',
+    plugin: 'encrypted-field',
+    type: 'text',
+    inputSize: {
+      default: 6,
+      isResizable: true,
+    },
+  });
+};

package/server/utils/crypto.js

@@ -0,0 +1,144 @@
+const crypto = require('crypto');
+
+const ALGORITHM = 'aes-256-gcm';
+const IV_LENGTH = 12;
+const AUTH_TAG_LENGTH = 16;
+const KEY_LENGTH = 32;
+
+function getEncryptionKey(strapi) {
+  const key = process.env.ENCRYPTION_KEY || strapi?.config?.get('plugin.encrypted-field.encryptionKey');
+  
+  if (!key) {
+    const errorMsg = '⚠️  ENCRYPTION_KEY no configurada. Debe establecer una clave de 64 caracteres hexadecimales en las variables de entorno o configuración de Strapi.';
+    if (strapi?.log?.error) {
+      strapi.log.error(errorMsg);
+    }
+    throw new Error(errorMsg);
+  }
+  
+  if (typeof key !== 'string' || key.length !== 64) {
+    throw new Error(`ENCRYPTION_KEY debe tener exactamente 64 caracteres hexadecimales (32 bytes). Actual: ${key?.length || 0}`);
+  }
+  
+  if (!/^[0-9a-fA-F]{64}$/.test(key)) {
+    throw new Error('ENCRYPTION_KEY debe contener solo caracteres hexadecimales (0-9, a-f, A-F)');
+  }
+  
+  return Buffer.from(key, 'hex');
+}
+
+function encrypt(text, strapi) {
+  if (typeof text !== 'string') return text;
+  
+  if (text === '') return text;
+
+  try {
+    const ENCRYPTION_KEY = getEncryptionKey(strapi);
+    const iv = crypto.randomBytes(IV_LENGTH);
+    const cipher = crypto.createCipheriv(ALGORITHM, ENCRYPTION_KEY, iv);
+    
+    let encrypted = cipher.update(text, 'utf8', 'hex');
+    encrypted += cipher.final('hex');
+    
+    const authTag = cipher.getAuthTag();
+    
+    return `${iv.toString('hex')}:${authTag.toString('hex')}:${encrypted}`;
+  } catch (error) {
+    if (strapi?.log?.error) {
+      strapi.log.error(`Error al cifrar: ${error.message}`);
+    }
+    throw error;
+  }
+}
+
+function decrypt(encryptedText, strapi) {
+  if (!encryptedText || typeof encryptedText !== 'string') return encryptedText;
+  
+  const parts = encryptedText.split(':');
+  if (parts.length !== 3) {
+    return encryptedText;
+  }
+  
+  try {
+    const [ivHex, authTagHex, encrypted] = parts;
+    
+    if (ivHex.length !== IV_LENGTH * 2 || authTagHex.length !== AUTH_TAG_LENGTH * 2) {
+      return encryptedText;
+    }
+    
+    const ENCRYPTION_KEY = getEncryptionKey(strapi);
+    const iv = Buffer.from(ivHex, 'hex');
+    const authTag = Buffer.from(authTagHex, 'hex');
+    
+    const decipher = crypto.createDecipheriv(ALGORITHM, ENCRYPTION_KEY, iv);
+    decipher.setAuthTag(authTag);
+    
+    let decrypted = decipher.update(encrypted, 'hex', 'utf8');
+    decrypted += decipher.final('utf8');
+    
+    return decrypted;
+  } catch (error) {
+    if (strapi?.log?.debug) {
+      strapi.log.debug(`Error al descifrar: ${error.message}. Retornando texto original.`);
+    }
+    return encryptedText;
+  }
+}
+
+function validateValue(value, attribute) {
+  if (value === null || value === undefined || value === '') {
+    return { valid: true };
+  }
+
+  if (typeof value !== 'string') {
+    return { 
+      valid: false, 
+      error: 'El valor debe ser una cadena de texto' 
+    };
+  }
+
+  if (attribute.regex) {
+    try {
+      const regex = new RegExp(attribute.regex);
+      if (!regex.test(value)) {
+        return { 
+          valid: false, 
+          error: `El valor no cumple con el patrón de validación: ${attribute.regex}` 
+        };
+      }
+    } catch (error) {
+      return { 
+        valid: false, 
+        error: `Patrón regex inválido: ${error.message}` 
+      };
+    }
+  }
+
+  if (attribute.maxLength && value.length > attribute.maxLength) {
+    return { 
+      valid: false, 
+      error: `El valor excede la longitud máxima de ${attribute.maxLength} caracteres` 
+    };
+  }
+
+  if (attribute.minLength && value.length < attribute.minLength) {
+    return { 
+      valid: false, 
+      error: `El valor debe tener al menos ${attribute.minLength} caracteres` 
+    };
+  }
+
+  return { valid: true };
+}
+
+function isEncryptedField(attribute) {
+  return attribute?.customField === 'plugin::encrypted-field.encrypted-text';
+}
+
+module.exports = {
+  encrypt,
+  decrypt,
+  validateValue,
+  isEncryptedField,
+  getEncryptionKey,
+};